CreativeIterator.hpp

#ifndef __FIBER_CREATIVEITERATOR_HPP
#define __FIBER_CREATIVEITERATOR_HPP

#include "MultiIndex.hpp"
#include "Iterator.hpp"
#include "Expression.hpp"
#include <meta/IF.hpp>
#include <eagle/Vector.hpp>

#include <vector>

namespace Fiber
{
        using Eagle::MetaInfo;


template <class T>
        struct  DataCreator;

template <class T>
class   CreativeIterator : public Iterator<T>
{
protected:
        DataCreator<T>  *myCreator;
public:
        using Iterator<T>::ptr;

        CreativeIterator(const Iterator<T>&D, DataCreator<T>*C=0)
        : Iterator<T>(D)
        , myCreator(C)
        {}

        CreativeIterator(index_t length, T*data, DataCreator<T>*C=0)
        : Iterator<T>(length, data)
        , myCreator(C)
        {}

        CreativeIterator(const CreativeIterator&CI)
        : Iterator<T>(CI)
        , myCreator(CI.myCreator)
        {}

        typedef typename MetaInfo<T>::element_t component_t;

        typedef FixedArray< component_t,
                            MetaInfo<T>::MULTIPLICITY> FixedArray_t;

        typedef typename META::IF< MetaInfo<T>::MULTIPLICITY == 1,
                                   component_t, FixedArray_t>::result ValueBase_t;


        typedef typename META::IF< MetaInfo<T>::MULTIPLICITY == 1,
                                   void, FixedArray_t>::result FixedArrayBase_t;

        typedef Eagle::Vector< component_t,
                            MetaInfo<T>::MULTIPLICITY> VectorArray_t;

        typedef typename META::IF< MetaInfo<T>::RANK == 0,
                                   void, VectorArray_t>::result VectorArrayBase_t;
};

template <class T>
struct  DataCreator
{
        typedef typename Iterator<T>::reference_t reference_t;

        virtual ~DataCreator() = 0;

        virtual CreativeIterator<T> slice(int Dimension, index_t i) = 0;

        virtual reference_t getElement(index_t i) = 0;
};


} /* namespace Fiber */

#endif /* __Fiber_CREATIVEITERATOR_HPP */