MemArrayBase.hpp

#ifndef __FIBER_MEMARRAYBASE_HPP
#define __FIBER_MEMARRAYBASE_HPP "Created 4.07.2004 14:31:21 by bzfbenge"
 
#include "FieldAPI.h"
 
#include <typeinfo>
#include "FiberType.hpp"
#include "DynamicSize.hpp"
#include "MemBase.hpp"
#include "ArrayInterpolator.hpp"
#include "CreativeArrayBase.hpp"
 
 
namespace Fiber
{
        using std::type_info;
 
        using MemCore::RefPtr;
        using MemCore::ReferenceBase;
        using MemCore::Chunk;
        using MemCore::WeakPtr;
 
template <Dims_t N>
class   MemArrayBase : virtual public MemBase
{
protected:
 
        ~MemArrayBase()
        {}
 
public:
        enum Dims_t { Dims = N };
 
        typedef MultiIndex<N>         MIndex_t;
 
        MemArrayBase(const FiberTypeIndex&theFiberTypeIndex, const WeakPtr<CreativeArrayBase>&theCreator)
        : MemBase(theFiberTypeIndex, theCreator)
        {}
 
        MemArrayBase(const MemArrayBase<N>&) = delete;
        void operator=(const MemArrayBase<N>&) = delete;
 
        Fiber::Dims_t rank() const override
        {
                return N;
        }
 
        virtual MultiIndex<N> Size() const = 0;
 
        virtual RefPtr<MemBase> newMemArraynD(const MultiIndex<N>&NewSize, const MemBase::Creator_t&C) const = 0;
 
#if     0
        RefPtr<MemBase> newMemArray(const DynamicSize&newSize, const MemBase::Creator_t&C) const override
        {
        MultiIndex<N> S;
                if (newSize.get(S) )
                {
                        return newMemArraynD(S,C);
                }
                return MemCore::NullPtr();
        }
#endif
 
        virtual RefPtr<MemBase> createSubMemArray(const MultiIndex<N>&Offset, const MultiIndex<N>&CopySize, const MemBase::Creator_t&C) const = 0;
 
        RefPtr<MemBase> createSubArray(const DynamicSize&Offset, const DynamicSize&CopySize, const MemBase::Creator_t&C) const override
        {
        MultiIndex<N> O, S;
                if (Offset.get(O) && CopySize.get(S) )
                {
                        return createSubMemArray(O,S,C);
                }
                return MemCore::NullPtr();
        }
 
        DynamicSize getSize() const override
        {
                return DynamicSize( Size() );
        }
 
        RefPtr<ArrayInterpolator> getInterpolator() const
        {
                return findInterface( typeid(ArrayInterpolator) );
        }
 
        virtual RefPtr<MemBase> getSlice(index_t n, const MemBase::Creator_t&C) const = 0;
};
 
template <Dims_t N>
struct setDimensions
{
static  bool setSizeInterface(const RefPtr<CreativeArrayBase>&DC)
        {
                if (!DC)
                        return false;
 
        RefPtr<MemBase> MemData = DC->create();
                if (!MemData)
                        return false;
 
        RefPtr<MemArrayBase<N> > MemDataN = MemData;
                if (!MemDataN)
                        return false;
 
        MultiIndex<N> Dims = MemDataN->Size();
                ::Fiber::setSizeInterface( DC, Dims );
 
                return true;
        }
};
 
template <Dims_t N>
inline  bool makeSizeInterface(MultiIndex<N>&Dims, const RefPtr<CreativeArrayBase>&DC)
{
        if (!DC)
                return false;
 
RefPtr<MemBase> MemData = DC->create();
        if (!MemData)
                return false;
 
RefPtr<MemArrayBase<N> > MemDataN = MemData;
        if (!MemDataN)
                return false;
 
        Dims = MemDataN->Size();
        setSizeInterface( DC, Dims );
 
        return true;
}
 
template <Dims_t N>
inline bool makeDimensions(MultiIndex<N>&Dims, const RefPtr<CreativeArrayBase>&DC)
{
        if (!DC)
                return false;
 
        if (getDimensions(Dims, DC) )
                //{
                //printf("makeDimensions::getDimensions()\n");fflush(stdout);
                return true;
                //}
        //printf("makeDimensions::makeSizeInterface()");fflush(stdout);
        return makeSizeInterface(Dims, DC);
}
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_MEMARRAYBASE_HPP */