TypedArray.hpp

#ifndef __FIBER_TYPEDARRAY_HPP
#define __FIBER_TYPEDARRAY_HPP

#include "MemBase.hpp"
#include <memcore/Chunk.hpp>

namespace Fiber
{

template <int N, class T>
        class   MemArray;


template <class T>
        class TypedArray : virtual public MemBase
{
public:
        typedef T       value_type;

        TypedArray(const MemBase::Creator_t&C)
        : MemBase(C)
        {}

        virtual T first() const = 0;

        virtual T last()  const = 0;

        virtual CreativeIterator<T>* creativeIterator() = 0;

        virtual const CreativeIterator<T>* creativeIterator() const = 0;

        virtual RefPtr<MemCore::TypedChunk<T> > myChunk() const = 0;


        override RefPtr<MemCore::ChunkBase> getChunk() const
        {
                return myChunk();
        }


static  RefPtr<MemBase> create(const RefPtr<MemBase>&SourceLayout,
                               const MemBase::Creator_t&C = MemCore::NullPtr(),
                               const type_info&layout = typeid(void) )
        {
                return SourceLayout->create( FiberType<T>::getFiberType().self(), C, layout);
        }

        template <class UnaryOperator>
        RefPtr<MemBase> applyOperator(const UnaryOperator&theOperator, const MemBase::Creator_t&theCreator) const
        {
        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                        return MemCore::NullPtr();

        const CreativeIterator<T>&CI = *C; 
        const Iterator<T>&It = CI;

        MemCore::MemVector<T> Result( CI.count() );
                for(index_t i=0; i<It.count(); i++)
                {
                const   T&in  = It[i];
                        T&out = Result[i];
                        out   = theOperator( in );
                }
                return createEquallySizedMemArray( Result, theCreator);
        }

        template <class BinaryOperator>
        RefPtr<MemBase> applyOperator(const BinaryOperator&theOperator, const RefPtr<MemBase>&rightValue, const MemBase::Creator_t&theCreator) const
        {
        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                        return MemCore::NullPtr();

        RefPtr<TypedArray> RightMemArray = rightValue;
                if (!RightMemArray)
                        return MemCore::NullPtr();

        const CreativeIterator<T>*CR = RightMemArray->creativeIterator();
                if (!CR)
                        return MemCore::NullPtr();

        const CreativeIterator<T>&CI = *C;
        const CreativeIterator<T>& R = *CR;

                if (CI.count() != R.count() )
                        return MemCore::NullPtr();

        MemCore::MemVector<T> Result( CI.count() );
                for(index_t i=0; i<CI.count(); i++)
                {
                const   T&in  = C[i];
                const   T&inR = R[i];
                        T&out = Result[i];
                        out   = theOperator( in, inR );
                }
                return createEquallySizedMemArray( Result, theCreator);
        }

        
        override RefPtr<MemBase> createIndirection(const DynamicSize&newSize, const std::vector<index_t>&Indirection, const MemBase::Creator_t&theCreator) const
        {
                if (Indirection.size() != newSize.nElements() )
                        return MemCore::NullPtr();

        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                        return MemCore::NullPtr();

        const CreativeIterator<T>&CI = *C;
        const Iterator<T>&It = CI;

        RefPtr<MemBase> newData = this->newMemArray(newSize, theCreator); 
                if (!newData)
                        return MemCore::NullPtr();

        RefPtr<TypedArray> dst = newData; 
                if (!dst)
                        return MemCore::NullPtr();

        const CreativeIterator<T>*Cdst = dst->creativeIterator(); 
                if (!Cdst)
                        return MemCore::NullPtr();

        const CreativeIterator<T>&CIdst = *Cdst;
        const Iterator<T>&Itdst = CIdst;

        index_t nElements = Indirection.size();
                for(index_t i=0; i<nElements; i++)
                {
                index_t src_index = Indirection[ i ];

                        Itdst[i] = It[ src_index ];
                }

                return newData;
        }

};

/* @ingroup field
   A convenience class that behaves like a (strong) reference to a TypedArray,
   but is more critical, in that it appears to be valid only if this TypedArray
   may provide a CreativeIterator.

   @author Werner Benger
 */
template <class T>
        class TypedIterator
{
        RefPtr<TypedArray<T> > SRC;
public:

        TypedIterator()
        {}

        TypedIterator(const RefPtr<MemBase>&src)
        : SRC(src)
        {}

        TypedIterator(const RefPtr<TypedArray<T> >&src)
        : SRC(src)
        {}

        bool operator=(const RefPtr<MemBase>&src)
        {
                SRC = src; 
                if (SRC) return true; 
                else     return false;
        }

        bool operator=(const RefPtr<TypedArray<T> >&src)
        {
                SRC = src; 
                if (SRC) return true; 
                else     return false;
        }

        template <int N>
        bool operator=(const RefPtr<MemArray<N, T> >&src)
        {
                SRC = src; 
                if (SRC) return true; 
                else     return false;
        }

        operator bool() const
        {
                if (!SRC)
                        return false;

        CreativeIterator<T>*C = SRC ->creativeIterator(); 
                if (!C)
                        return false; 

                return true; 
        }

        const RefPtr<TypedArray<T> >&operator()() const
        {
                return SRC;
        }

        CreativeIterator<T>&operator*() const
        {
                assert(SRC);

        CreativeIterator<T>*C = SRC ->creativeIterator();
                assert( C );
                return *C;
        }
};

} // namespace Fiber

#endif /* __FIBER_TYPEDARRAY_HPP */