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;
 
        typedef typename MultiArray_t::reference_t reference_t;
 
        const MemCore::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() = delete;
 
        ArrayRef(const ArrayRef&AF)
        : myMemArray(AF.myMemArray)
        , Data( *myMemArray )
        , DataStorage( getTypedStorage()->get_vector() )
        {}
 
        ArrayRef(const MultiIndex<N>&NumberOfElements, const MemBase::Creator_t&C = MemCore::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() );
        }
 
        reference_t operator[](const index_t&i)
        {
                Assert( i < DataStorage.size() );
                return DataStorage[i];
        }
 
        const reference_t operator[](const index_t&i) const
        {
                return DataStorage[i];
        }
 
        reference_t operator[](const MultiIndex<N>&I)
        {
                return Data[I];
        }
 
        const reference_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();
        }
 
        MultiArray<N,T>     &operator*()
        {
                return Data;
        }
 
        const MultiArray<N,T>&operator*() const
        {
                return Data;
        }
 
        operator RefPtr<MemBase> () const
        {
                return myMemArray;
        }
 
        RefPtr<MemBase> operator->() const
        {
                return myMemArray;
        }
};
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_ARRAYREF_HPP */