value.h

#ifndef AFL_VALUET_H
#define AFL_VALUET_H

#include "exc/invalidargumentexception.h"
#include "exc/outofboundsexception.h"
#include "ddf/geometry.h"
#include "ddf/ddf.h"
#include <vector>
#include <sstream>

namespace afl
{
    template <typename T>
    class ValueT
    {
        private:
            template <typename R>
            class ValueRow
            {
                friend class ValueT<R>;

                public:
                    ValueRow(ValueT<R>* parent, size_t row) 
                        : _parent(parent), _cparent(NULL), _r(row) 
                    { 
                        if (_r > _parent->getRows()) 
                            throw exc::OutOfBoundsException("value row is beyond size of value"); 
                    }

                    ValueRow(const ValueT<R>* parent, size_t row) 
                        : _parent(NULL), _cparent(parent), _r(row) 
                    { 
                        if (_r > _cparent->getRows()) 
                            throw exc::OutOfBoundsException("value row is beyond size of value"); 
                    }
                    
                    operator const T&() const
                    {
                        if (_parent->_c != 1)
                            throw exc::InvalidArgumentException("Only a Nx1 value can be dereferenced as a vector");

                        return _parent->_v[_r];
                    }

                    operator T&() 
                    {
                        if (_parent->_c != 1)
                            throw exc::InvalidArgumentException("Only a Nx1 value can be dereferenced as a vector");

                        return _parent->_v[_r];
                    }

                    const T& operator[](size_t c) const 
                    { 
                        if (c >= _cparent->_c) 
                            throw exc::OutOfBoundsException("value out of bounds"); 

                        return  _cparent->_v[_r * _cparent->_c + c];
                    }

                    T& operator[](size_t c) 
                    { 
                        if (c >= _parent->_c) 
                        {
                            std::ostringstream oss;
                            oss << "value out of bounds: There are " << _parent->_c << " columns, and you asked for column #" << c ;
                            throw exc::OutOfBoundsException(oss.str()); 
                        }
                        return  _parent->_v[_r * _parent->_c + c];
                    }

                private:
                    ValueT<R>* _parent;
                    const ValueT<R>* _cparent;
                    size_t _r;

            };

            friend class ValueRow<T>;

        public:

            ValueT(  ) 
                : _v(), _c(0) 
            {
            }

            ValueT( const T& d ) 
                : _v(), _c(1)
            {
                _v.push_back(d);
            }

            ValueT( const T& x, const T& y ) 
                : _v(), _c(1)
            {
                _v.push_back(x);
                _v.push_back(y);
            }

            ValueT( const T& x, const T& y, const T& z ) 
                : _v(), _c(1)
            {
                _v.push_back(x);
                _v.push_back(y);
                _v.push_back(z);
            }

            ValueT( const T& x, const T& y, const T& z, const T& t ) 
                : _v(), _c(1)
            {
                _v.push_back(x);
                _v.push_back(y);
                _v.push_back(z);
                _v.push_back(t);
            }

            explicit ValueT( const ddf::Geometry* geom );

            explicit ValueT( const ddf::Geometry& geom );

            ddf::Geometry getGeometry(  ) const
            {
                return ddf::Geometry(_v.size()/_c, _c);
            }

            ~ValueT(  ) {  }

            ValueT( const ValueT<T>& c ) : _v(c._v), _c(c._c) { }

            ValueT<T>& operator=( const ValueT<T>& c) 
            { 
                if (&c == this)
                    return *this;

                _v = c._v; 
                _c = c._c; 
                return *this; 
            }

            size_t getRows(  ) const { return _v.size() / _c; }

            size_t getColumns(  ) const { return _c; } 

            const T& at( size_t r, size_t c = 0 ) const
            {
                if ( c > _c || r*_c+c > _v.size())
                    throw exc::OutOfBoundsException("at() is out of bounds");

                return _v[r*_c+c];
            }

            T& at( size_t r, size_t c = 0 )
            {
                if ( c > _c || r*_c+c > _v.size())
                    throw exc::OutOfBoundsException("at() is out of bounds");

                return _v[r*_c+c];
            }

            const ValueRow<T> operator[](size_t r) const { return ValueRow<T>(this, r); } 

            ValueRow<T> operator[](size_t r) { return ValueRow<T>(this, r); } 

            operator const T&() const
            {
                //std::cerr << "the size of _v is " << _v.size() << std::endl;

                if (_v.size() != 1)
                {
                    std::ostringstream oss;
                    oss << _v.size();
                    //std::cerr << (char*)(10) << std::endl;

                    throw exc::InvalidArgumentException("Only a 1x1 value can be dereferenced as a scalar. The value has " + oss.str() + " elements");
                }

                return _v[0];
            }

            operator T&() 
            {
                //std::cerr << "the size of _v is " << _v.size() << std::endl;

                if (_v.size() != 1)
                {
                    std::ostringstream oss;
                    oss << _v.size();
                    //std::cerr << (char*)(10) << std::endl;

                    throw exc::InvalidArgumentException("Only a 1x1 value can be dereferenced as a scalar. The value has " + oss.str() + " elements");
                }

                return _v[0];
            }

            std::string geomString(  ) const
            {
                if (_c == 3)
                    return "tensor3D";
                if (_c == 2)
                    return "tensor2D";
                size_t rows = _v.size() / _c;
                if (rows == 3)
                    return "vector3D";
                if (rows == 2)
                    return "vector2D";
                return "scalar";
            }
            
            ValueT<T>& operator+=( const ValueT<T>& v )
            {
                if (_c != v._c || _v.size() != v._v.size())
                        throw exc::InvalidArgumentException("can't add values of differing geometries");
            
                for (size_t i = 0 ; i < _v.size() ; ++i)
                    _v[i] += v._v[i];
                
                return *this;
            }

            ValueT<T>& operator/=( const data_t& div )
            {
                for (size_t i = 0 ; i < _v.size() ; ++i)
                    _v[i] /= div;
                
                return *this;
            }

            ValueT<T>& operator*=( const data_t& multiplier )
            {
                for (size_t i = 0 ; i < _v.size() ; ++i)
                    _v[i] *= multiplier;
                
                return *this;
            }

            bool operator==( const ValueT<T>& lhs ) const
            {
                if (_c != lhs._c || _v.size() != lhs._v.size())
                    return false;
            
                for (size_t i = 0 ; i < _v.size() ; ++i)
                    if (_v[i] != lhs._v[i])
                        return false;
                
                return true;
            }

            bool operator!=( const ValueT<T>& lhs ) const
            {
                return ! (*this == lhs);
            }

        protected:
            std::vector<T> _v;

            size_t _c;
    };

}

#endif // AFL_VALUET_H

---