element.h

#ifndef ELEMENT_H
#define ELEMENT_H

#include <sstream>

#include "exc/aflexc.h"

#define WRONG_CONSTRUCTOR(A) \
    checkFor4();\
    std::ostringstream oss;\
    oss << D;\
    throw exc::InvalidArgumentException("Can't construct a " + oss.str() + "D element with " + #A + " elements"); 

namespace afl
{
    template <size_t D>
    class Element
    {
        public:
            Element(  ) { checkFor4(); for (size_t i = 0 ; i < D+1 ; ++i) _indices[i] = 0; }

            Element( const Element<D>& toCopy ) { for (size_t i = 0 ; i <= D ; ++i) _indices[i] = toCopy._indices[i]; }

            Element<D>& operator=( const Element<D>& toCopy ) { for (size_t i = 0 ; i <= D ; ++i) _indices[i] = toCopy._indices[i]; return *this; }

            Element( size_t u1, size_t u2 );

            Element( size_t u1, size_t u2, size_t u3 );

            Element( size_t u1, size_t u2, size_t u3, size_t u4 );

            Element( size_t u1, size_t u2, size_t u3, size_t u4, size_t u5 );

            size_t& operator[]( size_t i ) { if (i <= D) return _indices[i]; throw exc::OutOfBoundsException("Element access outside the element dimensions"); }

            size_t operator[]( size_t i ) const { if (i <= D) return _indices[i]; throw exc::OutOfBoundsException("Element access outside the element dimensions"); }

        private:
            void checkFor4(  ) { if ( D > 4) throw exc::InvalidArgumentException("Elements can only be of 1, 2, 3, or 4 dimensions"); }
            size_t _indices[D+1]; 
    };

    template <size_t D>
    Element<D>::Element( size_t, size_t ) { WRONG_CONSTRUCTOR(2); }

    template <size_t D>
    Element<D>::Element( size_t, size_t, size_t ) { WRONG_CONSTRUCTOR(3); }

    template <size_t D>
    Element<D>::Element( size_t, size_t, size_t, size_t ) { WRONG_CONSTRUCTOR(4); }

    template <size_t D>
    Element<D>::Element( size_t, size_t, size_t, size_t, size_t) { WRONG_CONSTRUCTOR(5); }
}

#undef WRONG_CONSTRUCTOR
#endif

---