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"

namespace Fiber
{
        using std::type_info;

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

template <int N>
class   MemArrayBase : virtual public MemBase
{
public:
        enum { Dims = N };

        typedef MultiIndex<N>         MIndex_t;

        MemArrayBase(const WeakPtr<CreativeArrayBase>&theCreator)
        : MemBase(theCreator)
        {}

        override int rank() const
        {
                return N;
        }

        virtual MultiIndex<N> Size() const = 0;

        virtual RefPtr<MemBase> createMemArray(const MultiIndex<N>&NewSize, const MemBase::Creator_t&C) const = 0;

        virtual RefPtr<MemBase> createSubMemArray(const MultiIndex<N>&Offset, const MultiIndex<N>&CopySize, const MemBase::Creator_t&C) const = 0;

        override RefPtr<MemBase> createSubArray(const DynamicSize&Offset, const DynamicSize&CopySize, const MemBase::Creator_t&C) const
        {
        MultiIndex<N> O, S; 
                if (Offset.get(O) && CopySize.get(S) )
                {
                        return createSubMemArray(O,S,C);
                }
                return MemCore::NullPtr();
        }

        override RefPtr<MemBase> newMemArray(const DynamicSize&newSize, const MemBase::Creator_t&C) const
        {
        MultiIndex<N> S; 
                if (newSize.get(S) )
                {
                        return createMemArray(S,C);
                }
                return MemCore::NullPtr();
        }


        override DynamicSize getSize() const
        {
                return DynamicSize( Size() );
        }

        override RefPtr<MemBase> newMemArray(const MemBase::Creator_t&C) const
        {
                return createMemArray( Size(), C);
        }

        RefPtr<ArrayInterpolator> getInterpolator() const
        {
                return findInterface( typeid(ArrayInterpolator) );
        }

        virtual RefPtr<MemBase> getSlice(index_t n, const MemBase::Creator_t&C) const = 0;
};


} /* namespace Fiber */ 

#endif /* __FIBER_MEMARRAYBASE_HPP */