ReferencingMemArray.hpp

#ifndef __FIBER_REFERENCINGMEMARRAY_HPP
#define __FIBER_REFERENCINGMEMARRAY_HPP "Created 3.12.2007"

#include "FieldAPI.h"
#include "MemArrayBase.hpp"
#include "TypedArray.hpp"

namespace Fiber
{

template <int N, class T>
class   ReferencingMemArray : public MemArrayBase<N>, public MultiArray<N, T>,
                              public TypedArray<T>
{
protected:
        RefPtr<MemCore::ChunkBase>      Storage;

public:
        typedef RefPtr<MemCore::Chunk<T> > MemChunk;
        typedef MultiArray<N, T> MultiArray_t;

        ReferencingMemArray( const Iterator<T>&data, const MultiIndex<N>&Sz, 
                             const RefPtr<MemCore::ChunkBase>&MemStorage,
                             const WeakPtr<CreativeArrayBase>&theCreator)
        : MemBase(theCreator)
        , MemArrayBase<N>(theCreator)
        , MultiArray<N, T>(data, Sz)
        , TypedArray<T>(theCreator)
        , Storage(MemStorage)
        {}

        ReferencingMemArray( const RefPtr<Chunk<T> > &data, const MultiIndex<N>&Sz, const WeakPtr<CreativeArrayBase>&theCreator)
        : MemBase(theCreator)
        , MemArrayBase<N>(theCreator)
        , MultiArray<N, T>( Iterator<T>( data?data->size():0, data?(*data)():0), Sz)
        , TypedArray<T>(theCreator)
        , Storage(data)
        {}

        ReferencingMemArray(const RefPtr<MemCore::ChunkBase>&Storage, const MultiArray<N,T>&M, const WeakPtr<CreativeArrayBase>&theCreator)
        : MemBase(theCreator)
        , MemArrayBase<N>(theCreator)
        , MultiArray<N, T>( M )
        , TypedArray<T>(theCreator)
        , Storage(Storage)
        {}

        ~ReferencingMemArray()
        {}

        override RefPtr<MemCore::TypedChunk<T> > myChunk() const
        {
                return this->StoragePtr();
        }

        override MemCore::memsize_t memsize() const
        {
                return Storage->memsize();
        }

        override index_t nElements() const
        {
                return MultiArray<N, T>::nElements();
        }

        override void DeferredConstructor()
        {
                MemCore::SaveRegistry<MemBase>::addInterfaces(this); 
        }

        override const type_info&getType() const
        {
                return typeid(T);
        }

        override const type_info&getBaseType() const
        {
                return typeid(typename MemCore::TypedChunk<T>::base_vector_type::value_type);
        }

        override const FiberTypeBase&getFiberType() const
        {
                return MemArrayAllocator<T>::getFiberType();
        }

        override HyperslabParameters&getHyperslabParameters() 
        {
                return *this;
        }

        override void*getPtr() 
        {
                return this->ptr(); // from Iterator<>
        }

        override const void*OriginPtr() const
        {
                return 0;
        }

        override const void*DeltaPtr()  const
        {
                return 0;
        }

        override T first() const
        {
                return MultiArray_t::first();
        }

        override T last() const
        {
                return MultiArray_t::last();
        }

        override CreativeIterator<T>* creativeIterator()
        {
                return this;
        }

        override const CreativeIterator<T>* creativeIterator() const
        {
                return this;
        }

        const RefPtr<MemCore::ChunkBase>&StoragePtr() const
        {
                return Storage;
        }


        const RefPtr<MemCore::ChunkBase>&getStorage() const
        {
                return Storage;
        }

        RefPtr<MemCore::TypedChunk<T> > getTypedStorage() const
        {
                return Storage;
        }
};


} /* namespace Fiber */ 

#endif /* __FIBER_REFERENCINGMEMARRAY_HPP */