MemArray.hpp

#ifndef __FIBER_MEMARRAY_HPP
#define __FIBER_MEMARRAY_HPP "Created 4.07.2004 14:31:21 by bzfbenge"

#include "ReferencingMemArray.hpp"
#include <vector/MultiCopy.hpp>

namespace Fiber
{
        using std::type_info;

        using MemCore::RefPtr;
        using MemCore::ReferenceBase;
        using MemCore::Chunk;


template <int N>
        class MemArrayGetSlice;

template <int N, class T>
class   MemArray;

template <int N, class T>
class   MemArray : public ReferencingMemArray<N, T>
{
        typedef RefPtr<MemCore::TypedChunk<T> > MemChunk;

static  bool    TypeIsRegistered;

public:
        typedef typename MetaInfo<T>::element_t element_t;

        typedef MemArray<N, element_t> ComponentArray_t;

        typedef T value_type;

        typedef typename META::BaseClass<T>::result value_base_type;

        typedef MemArray<N, value_base_type> MemArrayOfBaseValues_t;

        enum
        {
                Dims = N 
        };

static  bool reg()
        {
                if (TypeIsRegistered)
                        MemBase::RegisteredTypes++;

                return TypeIsRegistered;
        }

        MemArray( const Iterator<T>&data, const MultiIndex<N>&Sz,
                  const RefPtr<MemCore::ChunkBase>&MemStorage,
                  const MemBase::Creator_t&C )
        : MemBase(C)
        , ReferencingMemArray<N,T>(data, Sz, MemStorage, C)
        {}

public:
        typedef MultiArray<N, T> MultiArray_t;

        using MultiArray_t::ptr;

        typedef MemCore::NullPtr NullPtr;

        typedef typename MultiArray_t::component_t  component_t;
        typedef typename MultiArray_t::ValueBase_t  ValueBase_t;

        typedef typename MultiArray_t::MultiArrayBase_t         MultiArrayBase_t;
        typedef typename MultiArray_t::MultiArrayComponent_t    MultiArrayComponent_t;

        typedef MemArray<N,ValueBase_t> MemArrayBase_t;
        typedef MemArray<N,component_t > MemArrayComponent_t;

        MemArray(const MultiIndex<N>&M, const MemBase::Creator_t&C = NullPtr() )
        : MemBase(C)
        , ReferencingMemArray<N, T>( new Chunk<T>( M.size() ), M, C)
        {
                reg();
        }

        MemArray(const RefPtr<Chunk<T> >&Data, const MultiIndex<N>&M, const MemBase::Creator_t&C = NullPtr() )
        : MemBase(C)
        , ReferencingMemArray<N, T>( Data, M, C)
        {
                reg();
        }

        MemArray(const MemCore::MemVector<T>&Data, const MultiIndex<N>&M, const MemBase::Creator_t&C = NullPtr() )
        : MemBase(C)
        , ReferencingMemArray<N, T>( Data, M, C)
        {
                reg();
        }

        MemArray(const RefPtr<MemCore::ChunkBase> &Data, const MultiIndex<N>&Sz, const MemBase::Creator_t&C = NullPtr() )
        : MemBase(C)
        , ReferencingMemArray<N, T>( Data, Sz, C)
        {
                reg();
        }

        MemArray(const RefPtr<MemCore::ChunkBase>&Storage, const MultiArray<N,T>&M, const MemBase::Creator_t&C = NullPtr() )
        : MemBase(C)
        , ReferencingMemArray<N,T>(Storage, M, C)
        {
                reg();
        }

/*
        RefPtr<MemArrayOfBaseValues_t> createSharedBaseArray() const
        {
                return new MemArrayOfBaseValues_t( this->StoragePtr(), Size() );
        }

        RefPtr<MemBase> createBaseArray() const
        {
                return createSharedBaseArray();
        }
*/

private:

        friend class MemArrayGetSlice<N>;
        friend class MemArrayGetSlice<N+1>;
public:

/*
        override void DeferredConstructor()
        {
                MemCore::SaveRegistry<MemArray>::addInterfaces(this);
//              addInterface( new StorageInterpolator( this ) );
        }
*/

        ~MemArray()
        {
//              printf("MemArray::~MemArray(): releasing %ld bytes\n", long(memsize()) ); 
//              this->MemChunk::speak("MemArray::~MemArray() chunk");

//              MemArrayBaseCreator::CreatorNumber += myCreatorNumber;
        }

        override RefPtr<MemBase> getSlice(index_t i, const MemBase::Creator_t&C) const;

        override MultiIndex<N> Size() const
        {
                return MultiArray_t::Size();
        }

        override RefPtr<MemBase> makeMemArray(const MemBase::Creator_t&) const
        {
                return this->self();
        }

        override RefPtr<MemBase> createMemArray(const MultiIndex<N>&NewSize, const MemBase::Creator_t&C) const
        {
                return new MemArray( NewSize, C );
        }

        RefPtr<MemArray> createMemArray(const MemCore::MemVector<T>&Data, const MemBase::Creator_t&C) const
        {
                if (!Data) return MemCore::NullPtr(); 
                if (Data->size() != Size().size() )
                        return MemCore::NullPtr(); 

                return new MemArray(Data, Size(), C);
        }

        RefPtr<MemArray> createMemArray(const RefPtr<MemCore::ChunkBase>&Data, const MemBase::Creator_t&C) const
        {
                if (!Data) return MemCore::NullPtr(); 
                if (Data->elements() != Size().size() )
                        return MemCore::NullPtr(); 

                return new MemArray(Data, Size(), C );
        }

        override RefPtr<MemBase> createEquallySizedMemArray(const RefPtr<MemCore::ChunkBase>&Storage, const MemBase::Creator_t&C) const
        {
                return createMemArray(Storage, C);
        }


        override RefPtr<MemBase> createSubMemArray(const MultiIndex<N>&Offset, const MultiIndex<N>&CopySize, const MemBase::Creator_t&C) const
        {
        RefPtr<MemArray> Result = new MemArray( CopySize, C);
        MultiArray_t&Dest = *Result; 

                CopySubset(CopySize, Dest, MultiIndex<N>(0), *this, Offset, ::Fiber::PlainCopyConvert() ); 

                return Result;
        }

        override RefPtr<MemBase> getComponentArray(int member, const MemBase::Creator_t&C)
        {
                if (member >= MetaInfo<T>::MULTIPLICITY)
                        return MemCore::NullPtr();

        Iterator<T>         &me = *this;
        Iterator<element_t> component_ptr = me.getComponent(member); 

                return new ComponentArray_t( component_ptr, MultiArray_t::Size(), this->Storage, C );
        }

        override const type_info&getType() const
        {
                return typeid(T);
        }

        override const FiberTypeBase&getFiberType() const
        {
                return MemArrayAllocator<T>::getFiberType();
        }

/*
        RefPtr<MemBase> computeNthDerivative(int N)
        {
                DeriveArray<Interpol, Dims>::computeNthDerivative(result, this, N);
        }
*/
};



template <class T>
inline RefPtr<MemBase> MemArrayAllocator<T>::create(int rank, const index_t dims[], const WeakPtr<CreativeArrayBase>&theCreator) const
{
        switch(rank)
        {
        default: return MemCore::NullPtr(); 

        case 1:  return new MemArray<1, T>(MIndex(dims[0]), theCreator ) ;
                        
        case 2:  return new MemArray<2, T>(MIndex(dims[0], dims[1]),theCreator ) ; 
                        
        case 3:  return new MemArray<3, T>(MIndex(dims[0], dims[1], dims[2]), theCreator ) ;

        case 4:  return new MemArray<4, T>(MIndex(dims[0], dims[1], dims[2], dims[3]),theCreator ) ;
        }
}

template <int N, class T>
bool    MemArray<N,T>::TypeIsRegistered = MemArrayAllocator<T>::isRegistered();






template <int N>
class MemArrayGetSlice
{
public:
        template <class T>
static  RefPtr<MemArray<N-1, T> > getSlice(const MemArray<N,T>&M, index_t i, const MemBase::Creator_t&C)
        {
                return new MemArray<N-1,T>(M.StoragePtr(), M[i], C );
        }
};


template <>
class MemArrayGetSlice<1>
{
public:
        template <class T>
static  MemCore::NullPtr getSlice(const MemArray<1,T>&, index_t i, const MemBase::Creator_t&C)
        {
                return MemCore::NullPtr();
        }
};


template <int N, class T>
inline RefPtr<MemBase> MemArray<N,T>::getSlice(index_t i, const MemBase::Creator_t&C) const
{
        return MemArrayGetSlice<N>::getSlice(*this, i, C);
}

template <class T>
inline RefPtr<MemBase> makeMemArray1D(const RefPtr<MemCore::TypedChunk<T> >&DataChunk, const MemBase::Creator_t&C)
{
        if (!DataChunk)
                return ::MemCore::NullPtr(); 

        return new MemArray<1, T>( DataChunk, MIndex(DataChunk->size() ), C);
}

template <class T>
inline RefPtr<MemBase> makeMemArray1D(const RefPtr<MemCore::Chunk<T> >&DataChunk, const MemBase::Creator_t&C)
{
        if (!DataChunk)
                return ::MemCore::NullPtr(); 

        return new MemArray<1, T>( DataChunk, MIndex(DataChunk->size() ), C);
}


} /* namespace Fiber */ 

#endif /* __FIBER_MEMARRAY_HPP */