CreativeIterator.hpp

#ifndef __FIBER_CREATIVEITERATOR_HPP
#define __FIBER_CREATIVEITERATOR_HPP
 
#include "fvectorAPI.h"
#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>  *myDataCreator;
public:
        using Iterator<T>::ptr;
 
        CreativeIterator(const Iterator<T>&D, DataCreator<T>*C=0)
        : Iterator<T>(D)
        , myDataCreator(C)
        {}
 
        CreativeIterator(index_t length, T*data, DataCreator<T>*C=0)
        : Iterator<T>(length, data)
        , myDataCreator(C)
        {}
 
        CreativeIterator(const CreativeIterator&CI)
        : Iterator<T>(CI)
        , myDataCreator(CI.myDataCreator)
        {}
 
        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 CreativeIterator<T> slice(int Dimension, index_t i) = 0;
 
        virtual reference_t getElement(index_t i) = 0;
};
 
 
} /* namespace Fiber */
 
#endif /* __Fiber_CREATIVEITERATOR_HPP */