Coords.h

// ===========================================================================
// Imagine++ Libraries
// Copyright (C) Imagine
// For detailed information: http://imagine.enpc.fr/software
// ===========================================================================

namespace Imagine {


    template <int dim> class Coords : public FVector<int,dim> {
    private: 
        typedef FVector<int,dim> Base;
    public:
        Coords() : Base() {}
        Coords(const Base& v) :  Base(v) {}
        Coords(const int v[dim]): Base(v) {}
        Coords(int v) : Base(v) {}
        Coords(int x,int y) : Base(x,y) {}
        Coords(int x,int y,int z) : Base(x,y,z) {}
        size_t prod() const {
            size_t p=1;
            for (int i=0;i<dim;i++)
                p*=(*this)[i];
            return p;
        }
    };

    template <int dim> class CoordsIterator {
        Coords<dim> _a;
        Coords<dim> _b;
        Coords<dim> _pos;
        bool _stop;
    public:
        typedef std::input_iterator_tag iterator_category; 
        typedef Coords<dim> value_type; 
        typedef int difference_type;    
        typedef Coords<dim>* pointer;   
        typedef Coords<dim>& reference; 

        CoordsIterator() : _stop(true) {}
        CoordsIterator(const Coords<dim>& a, const Coords<dim>& b) : _a(a), _b(b), _pos(a), _stop(false) {}
        CoordsIterator& operator = (const CoordsIterator& it) {
            _a = it._a;
            _b = it._b;
            _pos = it._pos;
            _stop = it._stop;
            return *this;
        }   
        bool operator == (const CoordsIterator& it) const {
            return (_stop ? it._stop : !it._stop && _pos == it._pos);
        }
        bool operator != (const CoordsIterator& it) const {
            return (_stop ? !it._stop : it._stop || _pos != it._pos);
        }
        CoordsIterator& operator ++ () {
            for (int i=0;i<dim;i++) {
                if (_pos[i]!=_b[i]) {
                    _pos[i]++;
                    return *this;
                }
                _pos[i]=_a[i];
            }
            _stop = true;
            return *this;
        }
        CoordsIterator operator ++(int) {
            CoordsIterator tmp(*this);
            ++(*this);
            return tmp;
        }
        Coords<dim> operator * () const {
            return _pos;
        }
        const Coords<dim>* operator -> () const {
            return &_pos;
        }
    };


}