MemBase.hpp

#ifndef __FIBER_MEMBASE_HPP
#define __FIBER_MEMBASE_HPP
 
#include "FieldAPI.h"
#include <memcore/RefPtr.hpp>
#include <memcore/Interface.hpp>
#include <memcore/Persistencer.hpp>
#include <memcore/Cacheable.hpp>
#include <memcore/Cache.hpp>
#include <memcore/Creator.hpp>
#include <memcore/Chunk.hpp>
 
#include <fiber/vector/MultiArray.hpp>
 
#include <typeinfo>
#include "FiberType.hpp"
#include "DynamicSize.hpp"
 
namespace Fiber
{
class FIELD_API MemBase;
 
 
// template forward declaration, defined in MemArray.hpp
template <Dims_t N, class T>
class   MemArray;
 
}
 
namespace MemCore
{
 
template <>
struct  DeferredInitializationTrait<Fiber::MemBase>
{
static  void call(Fiber::MemBase*ma);
};
 
}
 
namespace Fiber
{
        using std::type_info;
 
        using MemCore::RefPtr;
        using MemCore::ReferenceBase;
        using MemCore::Chunk;
 
 
class   FIELD_API CreativeArrayBase;
 
typedef MemCore::WeakPtr<CreativeArrayBase, MemCore::Creature>
        WeakPtrCreativeArrayBase_t;
 
 
class FIELD_API MemBase : public MemCore::Cacheable, public MemCore::Intercube
{
//      set<MemCore::WeakPtr<MemArrayBase> > > Sources;
 
        FiberTypeIndex  myFiberTypeIndex;
 
public:
        typedef WeakPtrCreativeArrayBase_t Creator_t;
 
        MemBase(const FiberTypeIndex&theFiberTypeIndex, const Creator_t&theCreator);
 
        ~MemBase();
 
        MemBase(const MemBase&) = delete;
        MemBase() = delete;
 
        MemCore::WeakPtr<MemBase> membase() const
        {
                return self();
        }
 
        virtual void DeferredConstructor() override = 0;
//      {       puts("MemArrayBase:: DeferredConstructor() called..."); }
 
        virtual Fiber::Dims_t rank() const = 0;
 
        virtual DynamicSize getSize() const = 0;
 
        virtual index_t nElements() const
        {
                return getSize().nElements();
        }
 
        auto    NumberOfElements() const
        {
                return nElements();
        }
 
        auto    getNumberOfElements() const
        {
                return nElements();
        }
 
        virtual const type_info&getType() const = 0;
 
        virtual HyperslabParameters&getHyperslabParameters() = 0;
 
        virtual std::string     getElementAsString(size_t index) const = 0;
 
 
        virtual void*getPtr() = 0;
 
        virtual RefPtr<MemCore::ChunkBase> getChunk() const = 0;
 
        virtual const void*OriginPtr() const = 0;
        virtual const void*DeltaPtr()  const = 0;
 
 
        MemCore::memsize_t memsize() const override
        {
                if (RefPtr<MemCore::ChunkBase> C = getChunk() )
                        return C->memsize();
 
                return 0;
        }
 
 
        MemCore::WeakPtr<FiberTypeBase> getFiberType() const
        {
                return FiberTypeBase::find( myFiberTypeIndex );
        }
 
        MemCore::memsize_t element_memsize() const
        {
                return  myFiberTypeIndex.mem_size;
        }
 
        virtual RefPtr<MemBase> makeMemArray(const MemBase::Creator_t&C) const = 0;
 
        virtual RefPtr<MemBase> getComponentArray(int member, const MemBase::Creator_t&C) = 0;
 
        virtual RefPtr<MemBase> createSubArray(const DynamicSize&Offset, const DynamicSize&CopySize, const MemBase::Creator_t&C) const = 0;
 
        virtual RefPtr<MemBase> createEquallySizedMemArray(const RefPtr<MemCore::ChunkBase>&Storage, const MemBase::Creator_t&C) const = 0;
 
        virtual bool    copyFrom(const RefPtr<MemCore::ChunkBase>&theChunk) = 0;
 
        bool    copyFrom(const RefPtr<MemBase>&Mb)
        {
                if (!Mb) return false;
                return copyFrom( Mb->getChunk() );
        }
 
        virtual RefPtr<MemBase> copy(const MemBase::Creator_t&C = nullptr) const = 0;
 
#ifdef  HAVE_OLD_MEMARRAY
        /*
          Create new array of the same type as the current one, but with the specified dimensions.
          No initializations are performed here.
         */
        virtual RefPtr<MemBase> newMemArray(const DynamicSize&newSize, const MemBase::Creator_t&C) const = 0;
 
        RefPtr<MemBase> newMemArray(const MemBase::Creator_t&C) const
        {
                return newMemArray( getSize(), C);
        }
#endif
 
#ifdef  HAVE_MEMARRAY_INDIRECTION
        virtual RefPtr<MemBase> createIndirection(const DynamicSize&newSize,
                                                  const RefPtr<MemCore::ChunkBase>&Indirection,
                                                  const MemBase::Creator_t&theCreator) const = 0;
#endif
 
//      virtual RefPtr<MemBase> createIndirection(const DynamicSize&newSize,
//                                                const std::vector<unsigned int>&Indirection,
//                                                const MemBase::Creator_t&theCreator) const = 0;
 
        class FIELD_API Allocator : public MemCore::Interface<Allocator>
        {
        public:
                Allocator();
                ~Allocator();
 
                virtual RefPtr<MemBase> create(const DynamicSize&) const = 0;
        };
 
 
static  RefPtr<MemBase> create(const RefPtr<FiberTypeBase>&FT,
                               const DynamicSize&DS,
                               const type_info&layout = typeid(void) );
 
        RefPtr<MemBase> create(const RefPtr<FiberTypeBase>&FT,
                               const type_info&layout = typeid(void) ) const
        {
                return create(FT, getSize(), layout);
        }
 
        template <class T>
        RefPtr<MemBase> create(const type_info&layout = typeid(void) ) const
        {
        const RefPtr<FiberTypeBase>&FT = FiberType<T>::getFiberType();
                return create(FT, getSize(), layout);
        }
 
        RefPtr<MemBase> create(const DynamicSize&DS,
                               const type_info&layout = typeid(void) ) const;
 
        RefPtr<MemBase> create(const type_info&layout = typeid(void) ) const;
 
 
static  bool registerCreator(const RefPtr<Allocator>&A,
                             const RefPtr<FiberTypeBase>&FT);
 
static  /*FIELD_API*/ int  RegisteredTypes;
 
};
 
 
inline RefPtr<MemCore::ChunkBase> getChunk(const MemCore::WeakPtr<MemBase>&MemData)
{
        if (MemData)
                return MemData->getChunk();
 
        return MemCore::NullPtr();
}
 
template <class T>
class   MemArrayAllocator : public MemBase::Allocator
{
public:
        RefPtr<MemBase> create(const DynamicSize&DS) const override;
 
static  MemCore::WeakPtr<FiberTypeBase> getFiberType()
        {
                return FiberType<T>::getFiberType();
        }
 
static  bool    registerMe()
        {
        RefPtr<MemBase::Allocator> A = new MemArrayAllocator();
#ifdef  VERBOSE
                printf("MemArrayAllocator<%s>::registerMe()\n", typeid(T).name() );
#endif
                return MemBase::registerCreator( A, getFiberType() );
        }
 
static  bool    isRegistered()
        {
        static  bool b = registerMe();
#ifdef  VERBOSE
                printf(b?"isRegistered is TRUE\n":"isRegistered is FALSE\n");
#endif
                return b||true;
        }
};
 
 
inline RefPtr<MemCore::ChunkBase> operator-(const RefPtr<MemBase>&Mem)
{
        return getChunk( Mem );
}
 
 
} // namespace Fiber
 
namespace MemCore
{
inline  void DeferredInitializationTrait<Fiber::MemBase>::call(Fiber::MemBase*ma)
        {
                ma->DeferredConstructor();
        }
}
 
#endif /* __FIBER_MEMARRAY_HPP */