MemArray.hpp

 
#ifndef __FIBER_MEMARRAY_HPP
#define __FIBER_MEMARRAY_HPP
 
#ifndef DONT_USE_PRAGMA_ONCE
#pragma once
#endif
 
#include "ReferencingMemArray.hpp"
#include <fiber/vector/MultiCopy.hpp>
 
namespace Fiber
{
        using std::type_info;
 
        using MemCore::RefPtr;
        using MemCore::ReferenceBase;
        using MemCore::Chunk;
 
 
template <Dims_t N>
        class MemArrayGetSlice;
 
template <Dims_t N, class T>
class   MemArray;
 
template <Dims_t N, class T>
class   MemArray : public ReferencingMemArray<N, T>
{
        typedef RefPtr<MemCore::TypedChunk<T> > MemChunk;
 
static  bool    TypeIsRegistered;
 
protected:
 
 
public:
 
        ~MemArray()
        {
#ifdef  VERBOSE_MEMARRAY
                printf("MemArray::~MemArray(): releasing %ld bytes\n", long(memsize()) );
                this->MemChunk::speak("MemArray::~MemArray() chunk");
#endif
        }
 
        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(FiberType<T>::getFiberType()->getFiberTypeIndex() , 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(FiberType<T>::getFiberType()->getFiberTypeIndex() , C)
        , ReferencingMemArray<N, T>( new Chunk<T>( M.size() ), M, C)
        {
                reg();
        }
 
        MemArray(const MemCore::MemVector<T>&Data, const MultiIndex<N>&M, const MemBase::Creator_t&C = nullptr )
        : MemBase(FiberType<T>::getFiberType()->getFiberTypeIndex() , 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(FiberType<T>::getFiberType()->getFiberTypeIndex() , 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(FiberType<T>::getFiberType()->getFiberTypeIndex() , 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();
        }
*/
 
        friend class MemArrayGetSlice<N>;
        friend class MemArrayGetSlice<N+1>;
 
/*
        void DeferredConstructor()
        {
                MemCore::SaveRegistry<MemArray>::addInterfaces(this) override;
//              addInterface( new StorageInterpolator( this ) );
        }
*/
 
public:
 
        RefPtr<MemBase> getSlice(index_t i, const MemBase::Creator_t&C) const override;
 
        MultiIndex<N> Size() const override
        {
                return MultiArray_t::Size();
        }
 
        RefPtr<MemBase> makeMemArray(const MemBase::Creator_t&) const override
        {
                return this->self();
        }
 
        RefPtr<MemBase> newMemArraynD(const MultiIndex<N>&NewSize, const MemBase::Creator_t&C) const override
        {
                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 );
        }
 
        RefPtr<MemBase> createEquallySizedMemArray(const RefPtr<MemCore::ChunkBase>&Storage, const MemBase::Creator_t&C) const override
        {
                return createMemArray(Storage, C);
        }
 
        RefPtr<MemBase> copy(const MemBase::Creator_t&C = nullptr) const override
        {
                if (!this->myStorage)
                        return nullptr;
 
                return new MemArray(this->myStorage->copy(), Size(), C );
        }
 
 
        RefPtr<MemBase> createSubMemArray(const MultiIndex<N>&Offset, const MultiIndex<N>&CopySize, const MemBase::Creator_t&C) const override
        {
        RefPtr<MemArray> Result = new MemArray( CopySize, C);
        MultiArray_t&Dest = *Result;
 
                CopySubset(CopySize, Dest, MultiIndex<N>(0), *this, Offset, ::Fiber::PlainCopyConvert() );
 
                return Result;
        }
 
        RefPtr<MemBase> getComponentArray(int member, const MemBase::Creator_t&C) override
        {
                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->myStorage, C );
        }
 
/*
        RefPtr<MemBase> computeNthDerivative(int N)
        {
                DeriveArray<Interpol, Dims>::computeNthDerivative(result, this, N);
        }
*/
};
 
 
template <class T>
inline RefPtr<TypedArray<T>> newMemArray(const DynamicSize&DS,
                                         const MemBase::Creator_t&C = nullptr )
{
        switch(DS.getRank())
        {
        default: return nullptr;
 
        case 1:  return new MemArray<1, T>( DS.getSize<1>(), C );
 
        case 2:  return new MemArray<2, T>( DS.getSize<2>(), C );
 
        case 3:  return new MemArray<3, T>( DS.getSize<3>(), C );
 
        case 4:  return new MemArray<4, T>( DS.getSize<4>(), C );
        }
}
 
 
 
template <class T>
inline RefPtr<MemBase> MemArrayAllocator<T>::create(const DynamicSize&DS) const
{
        return newMemArray<T>(DS);
/*
        switch(DS.getRank())
        {
        default: return MemCore::NullPtr();
 
        case 1:  return new MemArray<1, T>( DS.getSize<1>() );
 
        case 2:  return new MemArray<2, T>( DS.getSize<2>() );
 
        case 3:  return new MemArray<3, T>( DS.getSize<3>() );
 
        case 4:  return new MemArray<4, T>( DS.getSize<4>() );
        }
*/
}
 
template <Dims_t N, class T>
bool    MemArray<N,T>::TypeIsRegistered = MemArrayAllocator<T>::isRegistered();
 
 
 
 
 
 
template <Dims_t 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 <Dims_t 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<MemArray<1, T>> makeMemArray1D(const RefPtr<MemCore::TypedChunk<T> >&DataChunk,
                                             const MemBase::Creator_t&C = MemCore::NullPtr() )
{
        if (!DataChunk)
                return ::MemCore::NullPtr();
 
        return new MemArray<1, T>( DataChunk, MIndex(DataChunk->elements() ), C);
}
 
template <class T>
inline RefPtr<MemArray<1, T>> makeMemArray1D(const RefPtr<MemCore::Chunk<T> >&DataChunk, const MemBase::Creator_t&C = MemCore::NullPtr() )
{
        if (!DataChunk)
                return ::MemCore::NullPtr();
 
        return new MemArray<1, T>( DataChunk, MIndex(DataChunk->size() ), C);
}
 
 
} /* namespace Fiber */
 
 
#endif /* __FIBER_MEMARRAY_HPP */