ArrayRef.hpp

#ifndef __FIBER_ARRAYREF_HPP
#define __FIBER_ARRAYREF_HPP

#include "MemArray.hpp"

namespace Fiber
{

template <class T, int N=1>
class   ArrayRef
{
public:
        typedef MemArray<N,T>   MemArray_t;
        typedef MultiArray<N,T> MultiArray_t;
        typedef std::vector<T>  Storage_t;

        const Ref<MemArray<N,T> > myMemArray;

        MultiArray<N,T>     &Data;

        Storage_t           &DataStorage;

        typedef typename std::vector<T>::iterator       iterator;

        typedef typename std::vector<T>::const_iterator const_iterator;

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

        ArrayRef(const MultiIndex<N>&NumberOfElements, const MemBase::Creator_t&C = NullPtr() )
        : myMemArray(NumberOfElements, C)
        , Data(*myMemArray )
        , DataStorage( getTypedStorage()->get_vector() )
        {
                assert( NumberOfElements.size() == size() );
                assert( DataStorage.size() == myMemArray->nElements() ); 
                assert( DataStorage.size() == Data.nElements() ); 
                assert( DataStorage.size() == size() );
        }

        T & operator[](const index_t&i)
        {
                assert( i < DataStorage.size() );
                return DataStorage[i];
        }

        const T & operator[](const index_t&i) const
        {
                return DataStorage[i];
        }

        T & operator[](const MultiIndex<N>&I)
        {
                return Data[I];
        }

        const T & operator[](const MultiIndex<N>&I) const
        {
                return Data[I];
        }


        iterator        begin()         { return DataStorage.begin(); }
        iterator        end  ()         { return DataStorage.end  (); }
        const_iterator  begin() const   { return DataStorage.begin(); }
        const_iterator  end  () const   { return DataStorage.end  (); }


        const MultiIndex<N>&Size() const
        {
                return Data.Size();
        }

        size_t size() const
        {
                return DataStorage.size();
        }

        operator RefPtr<MemBase> () const
        {
                return myMemArray;
        }
};


} /* namespace Fiber */

#endif /* __FIBER_ARRAYREF_HPP */