vector/Iterator.hpp

#ifndef __vector_Iterator_HPP
#define __vector_Iterator_HPP "Created 21.05.2006 12:12:12 by werner"
 
#include "fvectorAPI.h"
#include <eagle/FixedArray.hpp>
#include "VVector.hpp"
#include "Index.hpp"
#include <typeinfo>
#include "HyperslabParameters.hpp"
 
#include <memcore/Verbose.hpp>
 
#if defined(__GNUC__) && defined(_GLIBCXX_USE_NOEXCEPT)
#define USE_NOEXCEPT _GLIBCXX_USE_NOEXCEPT
#else
#define USE_NOEXCEPT throw()
#endif
 
#define COOL_ITERATOR
 
 
 
 
 
namespace Fiber
{
        using std::type_info;
        using Eagle::FixedArray;
 
typedef Eagle::Mult Mult;
typedef Eagle::Div  Div;
typedef Eagle::Add  Add;
typedef Eagle::Sub  Sub;
 
template <int Configuration> struct RangeFailureAction;
 
template <>
struct  RangeFailureAction<0> : std::exception
{
static  void check(const char*funcname, index_t i, index_t max_i)
        {}
 
    const char* what() const USE_NOEXCEPT override
        {
                return "Range check error";
        }
};
 
template <>
struct  RangeFailureAction<1> : std::exception
{
static  void check(const char*funcname, index_t i, index_t max_i)
        {
//              std::cout << "HERE!" << std::endl;
 
                if (i>=max_i)
                {
                        Assertion( i<max_i, "Range check Failure: " + std::to_string(i) + "/" + std::to_string(max_i) );
                }
        }
 
        const char* what() const USE_NOEXCEPT override
        {
                return "Range check error";
        }
};
 
struct  RangeException : std::exception
{
        RangeException(const char*func, index_t i, index_t max_i)
        {}
 
        const char* what() const USE_NOEXCEPT override
        {
                return "Range check error";
        }
};
 
template <>
struct  RangeFailureAction<2> : std::exception
{
static  void check(const char*funcname, index_t i, index_t max_i)
        {
                if (i>=max_i)
                {
                        throw RangeException(funcname, i, max_i);
                }
        }
 
    const char* what() const USE_NOEXCEPT override
        {
                return "Range check error";
        }
};
 
template <>
struct  RangeFailureAction<3> : std::exception
{
static  void check(const char*funcname, index_t i, index_t max_i)
        {
                if (i>=max_i)
                {
                        std::cerr << "RangeFailueAction<3>: ERROR " << funcname << ":" << i << " of " << max_i << " accessed!" << std::endl;
                        throw RangeException(funcname, i, max_i);
                }
        }
 
        const char*what() const USE_NOEXCEPT override
        {
                return "Range check error";
        }
};
 
 
#ifndef FIBER_VECTOR_RANGE_FAILURE_ACTION
#ifdef  NDEBUG
#define FIBER_VECTOR_RANGE_FAILURE_ACTION 0
#else
#define FIBER_VECTOR_RANGE_FAILURE_ACTION 1
#endif
#endif
 
typedef RangeFailureAction<FIBER_VECTOR_RANGE_FAILURE_ACTION> DefaultRangeFailureAction;
 
template <class T>
        class   Iterator;
 
template <int Components, class T>
        class   Iterator<FixedArray<T, Components> >;
 
 
template <class T>
class   ElementIterator : public HyperslabParameters
{
private:
        T*data;
 
protected:
        using HyperslabParameters::length;
        using HyperslabParameters::stride;
        using HyperslabParameters::offset;
        using HyperslabParameters::shift;
        using HyperslabParameters::cropped;
 
        void incPtr(index_t what)
        {
                data += what;
        }
 
public:
        typedef Eagle::MetaInfo<T>  info_t;
        typedef typename info_t::element_t element_info_t;
 
        ElementIterator(index_t Length, T*Data, index_t Stride, index_t Offset)
        : HyperslabParameters(Length, Stride, Offset)
        , data(Data)
        {
#ifdef  FIBER_ITERATOR_NULLPTR_ASSERTION
                Assert(Data);
#elif defined(FIBER_ITERATOR_NULLPTR_WARNING)
                if (!data)
                {
                        Verbose(0) << "ElementIterator constructed with NULL pointer, provided length is " << Length;
                }
#endif
        }
 
        ElementIterator(const ElementIterator&It)
        : HyperslabParameters(It)
        , data  (It.data)
        {
#ifdef  FIBER_ITERATOR_NULLPTR_ASSERTION
                Assert(It.data);
#elif defined(FIBER_ITERATOR_NULLPTR_WARNING)
                if (!data)
                {
                        Verbose(0) << "ElementIterator constructed with NULL pointer, provided length is " << Length;
                }
#endif
        }
 
        ElementIterator(const HyperslabParameters&It, T*newData)
        : HyperslabParameters(It)
        , data  (newData)
        {
#ifdef  FIBER_ITERATOR_NULLPTR_ASSERTION
                Assert( newData );
#elif defined(FIBER_ITERATOR_NULLPTR_WARNING)
                if (!data)
                {
                        Verbose(0) << "ElementIterator constructed with NULL pointer, provided length is " << Length;
                }
#endif
        }
 
        ElementIterator(index_t i, const ElementIterator&It, const Add&)
        : HyperslabParameters(i, It)
        , data  (It.data)
        {
#ifdef  FIBER_ITERATOR_NULLPTR_ASSERTION
                Assert(It.data);
#elif defined(FIBER_ITERATOR_NULLPTR_WARNING)
                if (!data)
                {
                        Verbose(0) << "ElementIterator constructed with NULL pointer, provided length is " << Length;
                }
#endif
        }
 
        void SetNewData(T*newData, index_t newLength) throw()
        {
                data   = newData;
                length = newLength;
 
#ifdef  FIBER_ITERATOR_NULLPTR_ASSERTION
                Assert( data );
#elif defined(FIBER_ITERATOR_NULLPTR_WARNING)
                if (!data)
                {
                        Verbose(0) << "ElementIterator setNew Data with NULL pointer, provided length is " << Length;
                }
#endif
                if( stride == 1 )
                {
                        offset = length;
                        //incPtr = length;
                        //shift  = It.getShift();
                        //cropped= It.getCropped();
                }
                else
                {
                        offset = 0;
                        //stride = sizeof(Eagle::FixedArray<T, Components>)/sizeof(T);
                        //incPtr = Eagle::FixedArray<T, Components>;
                        //this->shift  = It.getShift();
                        //this->length = It.getLength();
                        //this->cropped= It.getCropped();
                }
        }
 
        T*ptr(int c=0) const
        {
                if (!data)
                        return 0;
 
                return data+c*offset;
        }
 
        T&getElement(index_t i, int c) const
        {
        index_t index = getIndex(i,c);
 
        //      printf("i: %ld, c: %d, index: %ld, getLength: %ld, count: %ld ", i, c, index, getLength(), count() );
        //      printf("stride: %ld, offset: %ld, shift: %ld, cropped: %ld\n", stride, offset, shift, cropped);
 
                DefaultRangeFailureAction::check(__FUNCTION__, index, getLength() );
                DefaultRangeFailureAction::check(__FUNCTION__, i    , count() );
//              DefaultRangeFailureAction::check(__PRETTY_FUNCTION__, index, size() );
 
                return data[index];
        }
 
        operator bool() const
        {
                return data!=0;
        }
 
        // MSVC                          GCC                                              SGI C++
#if     defined(_IOSTREAM_) || defined(_GLIBCXX_OSTREAM) || defined(_CPP_IOSTREAM) || defined(__SGI_STL_IOSTREAM) || defined(__clang__)
#define ITERATOR_OSTREAM
         friend std::ostream&operator<<(std::ostream&os, const ElementIterator&It)
         {
                 os << '(' << It.shift << " + i)*" << It.stride << " + c*" << It.offset
                    << " ; " << It.length << " elements of type "
                    <<   typeid (T).name() << ", " << It.count() << " iterable.\n"
                   ;
                 return os;
         }
#endif
 
};
 
 
template <class T>
class   IteratorBase : public ElementIterator<T>
{
protected:
        using ElementIterator<T>::length;
        using ElementIterator<T>::stride;
        using ElementIterator<T>::offset;
        using ElementIterator<T>::shift;
        using ElementIterator<T>::cropped;
 
public:
        using ElementIterator<T>::getLength;
        using ElementIterator<T>::count;
        using ElementIterator<T>::ptr;
        using ElementIterator<T>::getStride;
        using ElementIterator<T>::getOffset;
//      using ElementIterator<T>::operator();
        using ElementIterator<T>::getElement;
 
        IteratorBase(index_t Length, T*d, index_t Stride, index_t Offset)
        : ElementIterator<T>(Length, d, Stride, Offset)
        {}
 
        IteratorBase(const IteratorBase&IB)
        : ElementIterator<T>(IB)
        {}
 
        IteratorBase(const HyperslabParameters&IB, T*d)
        : ElementIterator<T>(IB,d)
        {}
 
        IteratorBase(index_t ishift, const IteratorBase&P, const Add&)
        : ElementIterator<T>(ishift, P, Add() )
        {}
};
 
 
template <class T>
        class   Iterator;
 
template <int C, class T>
        class   Iterator<FixedArray<T, C> >;
 
template <class T, int C>
        class FixedArrayTrait
        {
        public: typedef FixedArray<T, C> array_t;
        };
 
template <class T>
        class FixedArrayTrait<T,1>
        {
        public: typedef T array_t;
        };
 
 
template <class Type>
        struct ElementryArrayTrait
        {
                typedef Eagle::MetaInfo<Type> FI;
                typedef typename FixedArrayTrait<typename FI::element_t, FI::MULTIPLICITY>::array_t basetype_t;
        };
 
 
 
template <class T>
struct  const_ranged_for_iterator
{
        index_t myIndex;
        const Iterator<T>&myContainer;
 
        const_ranged_for_iterator(index_t theIndex, const Iterator<T>&theContainer)
        : myIndex(theIndex)
        , myContainer(theContainer)
        {}
 
        bool    operator!=(const const_ranged_for_iterator&RFI) const
        {
                return myIndex !=RFI.myIndex;
        }
 
        void    operator++()
        {
                myIndex++;
        }
 
        const T&operator*() const
        {
                return myContainer[ myIndex ];
        }
};
 
 
template <class T>
struct  ranged_for_iterator
{
        index_t myIndex;
        Iterator<T>&myContainer;
 
        ranged_for_iterator(index_t theIndex, Iterator<T>&theContainer)
        : myIndex(theIndex)
        , myContainer(theContainer)
        {}
 
        bool    operator!=(const ranged_for_iterator&RFI) const
        {
                return myIndex !=RFI.myIndex;
        }
 
        void    operator++()
        {
                myIndex++;
        }
 
//#ifndef       NON_INDEXABLE_ITERATOR
        T*operator->() const
        {
                return &myContainer[ myIndex ];
        }
 
        operator T&() const
        {
                return myContainer[ myIndex ];
        }
 
        T& operator=(const T&value) const
        {
                return myContainer[ myIndex ] = value;
        }
 
#if     0
        struct proxy
        {
                T&t;
                index_t myIndex;
 
                operator T&() const { return t; }
                T&operator*() const { return t; }
 
                T*operator->() const
                {
                        return &t;
                }
 
                T& operator=(const T&value) const
                {
                        return t = value;
                }
 
                index_t getIndex() const
                {
                        return myIndex;
                }
        };
 
        proxy operator*()
        {
                return { myContainer[ myIndex ], myIndex };
        }
 
#elif   1
        // allows to call the getIndex() function on iterators
        const ranged_for_iterator&operator*() const
        {
                return *this;
        }
#else
        T&operator*() const
        {
                return myContainer[ myIndex ];
        }
#endif
 
        index_t getIndex() const
        {
                return myIndex;
        }
};
 
 
 
 
template <class T>
class   Iterator : public IteratorBase<T>
{
protected:
        using IteratorBase<T>::length;
        using IteratorBase<T>::stride;
        using IteratorBase<T>::offset;
        using IteratorBase<T>::shift;
        using IteratorBase<T>::cropped;
 
public:
        typedef IteratorBase<T> Base_t;
 
        using IteratorBase<T>::getLength;
        using IteratorBase<T>::count;
        using IteratorBase<T>::ptr;
        using IteratorBase<T>::getStride;
        using IteratorBase<T>::getOffset;
        using IteratorBase<T>::getElement;
//      using IteratorBase<T>::operator();
 
        typedef T value_t;
 
        typedef Eagle::MetaInfo<value_t> FI;
        typedef typename FI::element_t component_t;
        typedef typename ElementryArrayTrait<T>::basetype_t array_t;
 
        Iterator(index_t howmany, T*Ptr)
        : IteratorBase<T>(howmany, Ptr, 1, howmany)
        {}
 
#if 0 // better not allow this constructor, should force using first version
        Iterator(T*Ptr, index_t howmany)
        : IteratorBase<T>(howmany, Ptr, 1, howmany)
        {}
#endif
 
        Iterator(const HyperslabParameters&P, T*Ptr)
        : IteratorBase<T>(P, Ptr)
        {}
 
        Iterator(const Iterator&P)
        : IteratorBase<T>(P)
        {}
 
        Iterator(const Iterator&P, int)
        : IteratorBase<T>(P)
        {}
 
        template <int Components>
        Iterator(index_t howmany, FixedArray<T, Components>*Ptr, int component)
        : IteratorBase<T>(howmany*Components,   // that many doubles exist
                          Ptr?Ptr->ptr(component):0,
                          sizeof(FixedArray<T, Components>)/sizeof(T), // stride
                          0)
        {
                assert(component<Components);
        }
 
        template <int Components>
        Iterator(const Iterator<FixedArray<T, Components> >&It, int component)
        : IteratorBase<T>(It.count()*Components,        // that many doubles exist
                          It?It.ptr():0,
                          sizeof(Eagle::FixedArray<T, Components>)/sizeof(T), // stride
                          0)
        {
                assert(component<Components);
                if (It.isSeparatedCompound() )
                {
                //      puts("------------------------------------------------------Created a XXYYZZ");fflush(stdout);
                index_t nElements = It.getLength() / Components;
                        this->stride = 1;
                        this->offset = nElements;
                        this->length = nElements;
                        this->incPtr( nElements );
                        this->shift  = It.getShift();
                        this->cropped= It.getCropped();
                }
                else
                {
                //      puts("------------------------------------------------------Created a XYZXYZ");fflush(stdout);
                        this->incPtr( component );
                        this->stride = sizeof(Eagle::FixedArray<T, Components>)/sizeof(T);
                        this->offset = 0;
                        this->shift  = It.getShift();
                        this->length = It.getLength();
                        this->cropped= It.getCropped();
                }
        }
 
 
        template <int Components>
        Iterator(index_t Length, Eagle::VVector<Components, T>*Ptr, int component)
        : IteratorBase<T>(Length*Components,
                          Ptr?Ptr->ptr(component):0,
                          sizeof(Eagle::VVector<Components, T>)/sizeof(T),      // stride (incl. eventual alignment!)
                          0)                                            // offset
        {
                assert(component<Components);
        }
 
        Iterator(index_t ishift, const Iterator&P, const Add&)
        : IteratorBase<T>(ishift, P, Add() )
        {
//              printf("Addition pointer constructor: old count %d, offset %d, new count %d\n",
//                     P.count(), Offset, count() );
        }
 
        Iterator<array_t> getArrayIterator() const;
 
        Iterator<component_t> getComponent(int n) const;
 
        friend Iterator operator+(const Iterator&P, uint32_t i)
        {
                return Iterator(i, P, Add() );
        }
 
        friend Iterator operator+(uint32_t i, const Iterator&P)
        {
                return Iterator(i, P, Add() );
        }
 
        friend Iterator operator+(const Iterator&P, uint64_t i)
        {
                return Iterator(i, P, Add() );
        }
 
        friend Iterator operator+(uint64_t i, const Iterator&P)
        {
                return Iterator(i, P, Add() );
        }
 
 
 
        friend Iterator operator+(const Iterator&P, int32_t i)
        {
                return Iterator(i, P, Add() );
        }
 
        friend Iterator operator+(int32_t i, const Iterator&P)
        {
                return Iterator(i, P, Add() );
        }
 
        friend Iterator operator+(const Iterator&P, int64_t i)
        {
                return Iterator(i, P, Add() );
        }
 
        friend Iterator operator+(int64_t i, const Iterator&P)
        {
                return Iterator(i, P, Add() );
        }
 
#if 0
        friend Iterator operator+(const Iterator&P, long long i)
        {
                return Iterator(i, P, Add() );
        }
 
        friend Iterator operator+(long long i, const Iterator&P)
        {
                return Iterator(i, P, Add() );
        }
#endif
 
        typedef T& reference_t;
 
              T&operator[](index_t i) const
        {
                return getElement(i,0);
        }
 
        const T&getValue(index_t i) const
        {
                return getElement(i,0);
        }
 
        void    set(const T&Value)
        {
                for(index_t i=0; i<count(); i++)
                {
                        getElement(i,0) = Value;
                }
        }
 
        const_ranged_for_iterator<T> begin() const
        {
                return const_ranged_for_iterator<T>(0, *this);
        }
 
        const_ranged_for_iterator<T> end() const
        {
                return const_ranged_for_iterator<T>(count(), *this);
        }
 
        ranged_for_iterator<T> begin()
        {
                return ranged_for_iterator<T>(0, *this);
        }
 
        ranged_for_iterator<T> end()
        {
                return ranged_for_iterator<T>(count(), *this);
        }
 
        template <class S>
        T&operator[](const ranged_for_iterator<S>&I)
        {
                return (*this)[I.myIndex];
        }
 
        template <class S>
        const T&operator[](const ranged_for_iterator<S>&I) const
        {
                return (*this)[I.myIndex];
        }
 
        template <class S>
        T&operator[](const const_ranged_for_iterator<S>&I)
        {
                return (*this)[I.myIndex];
        }
 
        template <class S>
        const T&operator[](const const_ranged_for_iterator<S>&I) const
        {
                return (*this)[I.myIndex];
        }
};
 
 
#if 0
template <class T>
        class   constViewPtr<const T> : public ViewPtrBase<const T, 1>
{
//      const T*data;
//      index_t stride, offset;
 
public:
        using ViewPtrBase<T, 1>::data;
        using ViewPtrBase<T, 1>::stride;
        using ViewPtrBase<T, 1>::offset;
 
        typedef T value_t;
 
        ViewPtr(const T*ptr)
        : ViewPtrBase<const T, 1>(ptr, 1, 0)
        {}
 
        ViewPtr(const ViewPtr&P)
        : ViewPtrBase<const T, 1>(P.data, P.stride, P.offset)
        {}
 
        template <int Components>
        ViewPtr(const FixedArray<Components, T>*ptr, int component)
        : ViewPtrBase<const T, 1>(ptr->ptr(0),
                                  sizeof(FixedArray<Components, T>)/sizeof(T) ,
                                  component)
        {
                assert(component<Components);
        }
 
 
        template <int Components>
        ViewPtr(const VVector<Components, T>*ptr, int component)
        : ViewPtrBase<const T,1>(ptr->ptr(0),
                           stride(sizeof(VVector<Components, T>)/sizeof(T) ),
                           component)
        {}
 
 
        ViewPtr(const ViewPtr&P, index_t ElementShift)
        : ViewPtrBase<const T,1>(P.data + P.stride*ElementShift, P.stride, P.offset)
//..    : data(P.data + P.stride*ElementShift), stride(P.stride), offset(P.offset)
        {}
 
        void setOffset(int o)
        {
                offset = o;
        }
 
        const T&operator[](index_t i) const
        {
                return data[i*stride + offset];
        }
};
#endif
 
 
template <class Iterator>
        class   ElementProxy
        {
                typedef typename Iterator::array_t array_t;
                enum { Components = Iterator::Components };
                typedef typename Iterator::element_value_t element_value_t;
 
                const Iterator&owner;
                index_t   idx;
 
        public:
                ElementProxy(const Iterator&Owner, index_t Idx)
                : owner(Owner), idx(Idx)
                {}
 
                operator array_t() const
                {
                array_t retval;
                        for(int c=0; c<Components; c++)
                        {
                                retval[c] = owner.getComponent(idx,c);
                        }
                        return retval;
                }
 
                ElementProxy&operator=(const array_t&v)
                {
                        for(int c=0; c<Components; c++)
                        {
                                owner.getComponent(idx,c) = v[c];
                        }
                        return *this;
                }
 
 
                ElementProxy&operator=(const ElementProxy&in)
                {
                        for(int c=0; c<Components; c++)
                        {
                                owner.getComponent(idx,c) = in.owner.getComponent( in.idx, c);
                        }
                        return *this;
                }
 
                typedef element_value_t value_type;
                enum { SIZE = Components };
 
                Eagle::Assignment<ElementProxy, 0> operator=(const element_value_t&x)
                {
                        return Eagle::Assignment<ElementProxy, 0>(*this, x);
                }
 
 
                ElementProxy&operator+=(const array_t&v)
                {
                        for(int c=0; c<Components; c++)
                        {
                                owner.getComponent(idx,c) += v[c];
                        }
                        return *this;
                }
 
                ElementProxy&operator-=(const array_t&v)
                {
                        for(int c=0; c<Components; c++)
                        {
                                owner.getComponent(idx,c) -= v[c];
                        }
                        return *this;
                }
 
                element_value_t&operator[](int c) const
                {
                        return owner.getComponent(idx,c);
                }
        };
 
 
 
 
template <int C, class T>
struct  ranged_for_iterator<Eagle::FixedArray<T, C> >
{
        using array_t = Eagle::FixedArray<T, C>;
 
        typedef T element_value_t;
 
        typedef Iterator<array_t>         Iterator_t;
 
        typedef ElementProxy<Iterator_t>        Proxy;
 
        index_t myIndex;
        Iterator<array_t>&myContainer;
 
        ranged_for_iterator(index_t theIndex, Iterator<array_t>&theContainer)
        : myIndex(theIndex)
        , myContainer(theContainer)
        {}
 
        bool    operator!=(const ranged_for_iterator&RFI) const
        {
                return myIndex !=RFI.myIndex;
        }
 
        void    operator++()
        {
                myIndex++;
        }
 
#ifndef NON_INDEXABLE_ITERATOR
        const ranged_for_iterator&operator*() const
        {
                return *this;
        }
 
        operator Proxy() const
        {
                return myContainer[ myIndex ];
        }
 
        element_value_t&operator[](int c) const
        {
                return myContainer.getComponent(myIndex,c);
        }
 
#else
        Proxy   operator*() const
        {
                return myContainer[ myIndex ];
        }
#endif
 
        index_t getIndex() const
        {
                return myIndex;
        }
};
 
 
template <int C, class T>
class   Iterator<Eagle::FixedArray<T, C> > : public IteratorBase<T>
{
public:
        using IteratorBase<T>::ptr;
        using IteratorBase<T>::getStride;
        using IteratorBase<T>::getOffset;
        using IteratorBase<T>::getLength;
        using IteratorBase<T>::count;
        using IteratorBase<T>::getElement;
//      using IteratorBase<T>::operator();
 
        enum { Components = C };
 
        typedef FixedArray<T, Components> array_t;
 
        typedef T element_value_t;
 
        typedef Iterator<array_t>         Iterator_t;
 
        typedef ElementProxy<Iterator_t>        Proxy;
 
        Iterator(index_t Length, FixedArray<T, C>*Ptr)
        : IteratorBase<T>(Length*C, Ptr ? Ptr->ptr(0) : 0,
                          C, // stride: size of each element
                          1) // offset: from one element to the next one is one step
        {}
 
        Iterator(index_t size, T*Ptr)
        : IteratorBase<T>(size*C, Ptr, 1, size)
        {}
 
        Iterator(index_t ishift, const Iterator&P, const Add&)
        : IteratorBase<T>(ishift, P, Add() )
        {
//              printf("Addition pointer constructor: old count %d, offset %d, new count %d; size=%d, components=%d\n",
//                     P.count(), ishift, count(),
//                     P.size(),  C);
        }
 
/*
        Iterator<Vector<C, T> > vec() const
        {
                return Iterator<Vector<C, T> >();
        }
*/
 
        friend Iterator<FixedArray<T, C> > operator+(const Iterator<FixedArray<T, C> >&P, int32_t i)
        {
                return Iterator<FixedArray<T,C> >(i, P, Add() );
        }
 
        friend Iterator<FixedArray<T,C> > operator+(int32_t i, const Iterator<FixedArray<T,C> >&P)
        {
                return Iterator<FixedArray<T,C> >(i, P, Add() );
        }
 
 
        friend Iterator<FixedArray<T,C> > operator+(const Iterator<FixedArray<T,C> >&P, int64_t i)
        {
                return Iterator<FixedArray<T,C> >(i, P, Add() );
        }
 
        friend Iterator<FixedArray<T,C> > operator+(int64_t i, const Iterator<FixedArray<T,C> >&P)
        {
                return Iterator<FixedArray<T,C> >(i, P, Add() );
        }
 
 
 
        friend Iterator<FixedArray<T, C> > operator+(const Iterator<FixedArray<T, C> >&P, uint32_t i)
        {
                return Iterator<FixedArray<T,C> >(i, P, Add() );
        }
 
        friend Iterator<FixedArray<T,C> > operator+(uint32_t i, const Iterator<FixedArray<T,C> >&P)
        {
                return Iterator<FixedArray<T,C> >(i, P, Add() );
        }
 
        friend Iterator<FixedArray<T,C> > operator+(const Iterator<FixedArray<T,C> >&P, uint64_t i)
        {
                return Iterator<FixedArray<T,C> >(i, P, Add() );
        }
 
        friend Iterator<FixedArray<T,C> > operator+(uint64_t i, const Iterator<FixedArray<T,C> >&P)
        {
                return Iterator<FixedArray<T,C> >(i, P, Add() );
        }
 
#if 0
        friend Iterator<FixedArray<T,C> > operator+(const Iterator<FixedArray<T,C> >&P, long long i)
        {
                return Iterator<FixedArray<T,C> >(i, P, Add() );
        }
 
        friend Iterator<FixedArray<T,C> > operator+(long long i, const Iterator<FixedArray<T,C> >&P)
        {
                return Iterator<FixedArray<T,C> >(i, P, Add() );
        }
#endif
 
        Iterator<T> getComponent(int i) const
        {
                return Iterator<T>(*this, i);
        }
 
 
        T&getComponent(index_t i, int c) const
        {
                assert(c<Components);
                return getElement(i,c);
        }
 
        typedef Proxy reference_t;
 
        Proxy operator[](index_t i) const
        {
                return Proxy(*this, i);
        }
 
        array_t getValue(index_t i) const
        {
        array_t retval;
                for(int c=0; c<Components; c++)
                {
                        retval[c] = getComponent(i,c);
                }
                return retval;
        }
 
 
        const_ranged_for_iterator<array_t> begin() const
        {
                return const_ranged_for_iterator<array_t>(0, *this);
        }
 
        const_ranged_for_iterator<array_t> end() const
        {
                return const_ranged_for_iterator<array_t>(count(), *this);
        }
 
        ranged_for_iterator<array_t> begin()
        {
                return ranged_for_iterator<array_t>(0, *this);
        }
 
        ranged_for_iterator<array_t> end()
        {
                return ranged_for_iterator<array_t>(count(), *this);
        }
 
        template <class S>
        T&operator[](const ranged_for_iterator<S>&I)
        {
                return (*this)[I.myIndex];
        }
 
        template <class S>
        const T&operator[](const ranged_for_iterator<S>&I) const
        {
                return (*this)[I.myIndex];
        }
 
        template <class S>
        T&operator[](const const_ranged_for_iterator<S>&I)
        {
                return (*this)[I.myIndex];
        }
 
        template <class S>
        const T&operator[](const const_ranged_for_iterator<S>&I) const
        {
                return (*this)[I.myIndex];
        }
 
};
 
template <class VectorType>
inline Iterator<typename FixedArrayTrait<typename Eagle::MetaInfo<VectorType>::element_t, Eagle::MetaInfo<VectorType>::MULTIPLICITY>::array_t >
farray_iterator( const Iterator<VectorType>&V )
{
typedef Eagle::MetaInfo<VectorType> FI;
//typedef FixedArray<typename FI::element_t, FI::MULTIPLICITY> array_t;
typedef typename FixedArrayTrait<typename FI::element_t, FI::MULTIPLICITY>::array_t array_t;
 
array_t*data = V.ptr();
 
Iterator<array_t> retval( V.getLength(), data );
        retval.setCount( V.count() );
        return retval;
}
 
template <class Type>
inline Iterator<Type> array_iterator(const Iterator<Type>&It)
{
        return It;
}
 
/*
template <int N, class Type>
inline Iterator<typename FixedArrayTrait<Type, N>::array_t > array_iterator(const Iterator<FixedArray<Type, N> >&It)
{
        return It;
}
*/
 
template <class Type>
inline Iterator<Type> array_iterator(const Iterator<FixedArray<Type, 1> >&It)
{
Type*data = It.ptr();
 
Iterator<Type> retval( It.getLength(), data );
        retval.setCount( It.count() );
        return retval;
}
 
 
 
template <int N, class Type>
inline Iterator<Eagle::Vector<Type,N> > vector_iterator(const Iterator<Eagle::VVector<N, Type> >&It)
{
        return Iterator<Eagle::Vector<Type,N> >( It, &It.ptr()->vec() );
}
 
template <class T>
inline Iterator<typename Iterator<T>::array_t> Iterator<T>::getArrayIterator() const
{
//      return array_iterator( *this );
        return array_iterator( farray_iterator( *this ) );
}
 
template <class T>
inline  Iterator<typename Iterator<T>::component_t> Iterator<T>::getComponent(int i) const
{
        return Iterator<typename Iterator<T>::component_t>( getArrayIterator(), i);
}
 
//      Iterator<component_t> getComponent(int i) const;
 
 
} /* namespace Fiber */
 
#endif /* __vector_Iterator_HPP */