Iterator.hpp

#ifndef __vector_Iterator_HPP
#define __vector_Iterator_HPP "Created 21.05.2006 12:12:12 by werner"

#include <eagle/FixedArray.hpp>
#include "VVector.hpp"
#include "Index.hpp"
#include <typeinfo>
#include "HyperslabParameters.hpp"

#include <memcore/memcore.h>

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)
        {}

        override const char*what() const throw()
        {
                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)
                {
                        std::cout << "RangeFailueAction<1>: ERROR " << funcname << ":" << i << " of " << max_i << " accessed!" << std::endl;
                        assert(i<max_i);
                }
        }

        override const char*what() const throw()
        {
                return "Range check error";
        }
};

struct  RangeException : std::exception
{
        RangeException(const char*func, index_t i, index_t max_i)
        {}

        override const char*what() const throw()
        {
                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);
                }
        } 

        override const char*what() const throw()
        {
                return "Range check error";
        }
};

template <>
struct  RangeFailureAction<3>
{
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);
                }
        } 

        override const char*what() const throw()
        {
                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)
        {}

        ElementIterator(const ElementIterator&It)
        : HyperslabParameters(It)
        , data  (It.data)
        {}

        ElementIterator(const HyperslabParameters&It, T*newData)
        : HyperslabParameters(It)
        , data  (newData)
        {}

        ElementIterator(index_t i, const ElementIterator&It, const Add&)
        : HyperslabParameters(i, It)
        , data  (It.data)
        {}


        void SetNewData(T*newData, index_t newLength) throw()
        {
                data   = newData; 
                length = newLength; 

                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&operator()(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(__func__, index, getLength() ); 
                DefaultRangeFailureAction::check(__func__, 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)
#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();

        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>
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>::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 (*this)(i,0);
        }

        const T&getValue(index_t i) const
        {
                return (*this)(i,0);
        }

        void set(const T&Value)
        {
                for(index_t i=0; i<count(); i++)
                {
                        (*this)(i,0) = Value;
                }
        }
};


#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>
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>::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<FixedArray<T, C> >(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<FixedArray<T, C> >(index_t size, T*Ptr)
        : IteratorBase<T>(size*C, Ptr, 1, size)
        {}

        Iterator<FixedArray<T, C> >(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 (*this)(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;
        }
};

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 */