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 <vector/MultiArray.hpp>

#include <typeinfo>
#include "FiberType.hpp"
#include "DynamicSize.hpp"

namespace Fiber
{
class FIELD_API MemBase;
}

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 MemBase : public MemCore::Cacheable, public MemCore::Intercube
{
//      set<MemCore::WeakPtr<MemArrayBase> > > Sources;
public:
        typedef MemCore::WeakPtr<MemCore::CreatorBase<MemBase> > Creator_t;

        MemBase(const Creator_t&theCreator);

        ~MemBase();

        virtual void DeferredConstructor() = 0;
//      {       puts("MemArrayBase:: DeferredConstructor() called..."); }

        virtual int rank() const = 0; 

        virtual DynamicSize getSize() const = 0; 

        virtual index_t nElements() const
        {
                return getSize().nElements();
        } 

        virtual const type_info&getType() const = 0;

        virtual HyperslabParameters&getHyperslabParameters() = 0; 



        virtual void*getPtr() = 0; 

        virtual RefPtr<MemCore::ChunkBase> getChunk() const = 0; 

        virtual const void*OriginPtr() const = 0; 
        virtual const void*DeltaPtr()  const = 0; 


        virtual const FiberTypeBase&getFiberType() const = 0; 

        virtual RefPtr<MemBase> makeMemArray(const MemBase::Creator_t&C) const = 0;

        virtual RefPtr<MemBase> newMemArray(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; 

        /*
          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;

        virtual RefPtr<MemBase> createIndirection(const DynamicSize&newSize,
                                                  const std::vector<index_t>&Indirection, 
                                                  const MemBase::Creator_t&theCreator) const = 0;

        class FIELD_API Allocator : public MemCore::Interface<Allocator>
        {
        public:
                Allocator();
                ~Allocator(); 

                virtual RefPtr<MemBase> create(int rank, const index_t dims[], const Creator_t&) const = 0;
        };


static  RefPtr<MemBase> create(const RefPtr<FiberTypeBase>&FT,
                               int rank, const index_t dims[], 
                               const Creator_t&C,
                               const type_info&layout = typeid(void) );

        RefPtr<MemBase> create(const RefPtr<FiberTypeBase>&FT, 
                               const Creator_t&C,
                               const type_info&layout = typeid(void) )
        {
                return create(FT, getSize().size(),
                              getSize().dims_ptr(),
                              C, layout);
        }

static  bool registerCreator(const RefPtr<Allocator>&A,
                             const RefPtr<FiberTypeBase>&FT);

static  FIELD_API int  RegisteredTypes;
static  FIELD_API int  StandardTypes;

};

typedef MemCore::CreatorBase<MemBase> CreativeArrayBase;


inline RefPtr<MemCore::ChunkBase> getChunk(const MemCore::WeakPtr<MemBase>&MemData)
{
        if (MemData) 
                return MemData->getChunk(); 

        return MemCore::NullPtr();
}

inline RefPtr<MemCore::ChunkBase> getChunk(const MemCore::WeakPtr<CreativeArrayBase>&MemDataCreator)
{
        if (MemDataCreator) 
                return getChunk(MemDataCreator->create() ); 

        return MemCore::NullPtr();
}



template <class T>
class   MemArrayAllocator : public MemBase::Allocator
{
public:
        override RefPtr<MemBase> create(int rank, const index_t dims[], const MemCore::WeakPtr<CreativeArrayBase>&) const;

static  const FiberTypeBase&getFiberType()
        {
                return FiberType<T>::getFiberType();
        }

static  bool    registerMe()//const type_info&layout = typeid(void) )
        {
        RefPtr<MemBase::Allocator> A = new MemArrayAllocator(); 
//              printf("MemArrayAllocator<%s>::registerMe()\n", typeid(T).name() );
                return MemBase::registerCreator( A, getFiberType().self());
        }

static  bool    isRegistered()
        {
        static  bool b = registerMe(); 
//              printf(b?"isRegistered is TRUE":"isRegistered is FALSE");
                return b||true;
        }
};

} // namespace Fiber

namespace MemCore
{
inline  void DeferredInitializationTrait<Fiber::MemBase>::call(Fiber::MemBase*ma)
        {
                ma->DeferredConstructor();
        }
}

#endif /* __FIBER_MEMARRAY_HPP */