ReferencingMemArray.hpp

#ifndef __FIBER_REFERENCINGMEMARRAY_HPP
#define __FIBER_REFERENCINGMEMARRAY_HPP "Created 3.12.2007"
 
#include "FieldAPI.h"
#include "MemArrayBase.hpp"
#include <fiber/vector/MultiArray.hpp>
#include "TypedArray.hpp"
 
#include <memcore/Verbose.hpp>
 
namespace Fiber
{
 
template <class T>
inline  std::string     element_to_string(const T&element)
{
        return std::to_string(element);
}
 
template <>
inline  std::string     element_to_string(const std::string&element)
{
        return "\"" + element + "\"";
}
 
 
template<>
inline  std::string     element_to_string(const std::vector<unsigned short>&EdgeList)
{
std::string     retval = "{(" + std::to_string(EdgeList.size()) + ") ";
 
        if (EdgeList.size()>0)
                retval += std::to_string(EdgeList[0]);
 
        for(size_t i = 1; i<EdgeList.size(); i++)
        {
                retval += ", " + std::to_string(EdgeList[i]);
        }
 
        return retval + " }";
}
 
template<>
inline  std::string     element_to_string(const std::vector<unsigned int>&EdgeList)
{
std::string     retval = "{(" + std::to_string(EdgeList.size()) + ") ";
 
        if (EdgeList.size()>0)
                retval += std::to_string(EdgeList[0]);
 
        for(size_t i = 1; i<EdgeList.size(); i++)
        {
                retval += ", " + std::to_string(EdgeList[i]);
        }
 
        return retval + " }";
}
 
template<>
inline  std::string     element_to_string(const std::vector<unsigned long>&EdgeList)
{
std::string     retval = "{(" + std::to_string(EdgeList.size()) + ") ";
 
        if (EdgeList.size()>0)
                retval += std::to_string(EdgeList[0]);
 
        for(size_t i = 1; i<EdgeList.size(); i++)
        {
                retval += ", " + std::to_string(EdgeList[i]);
        }
 
        return retval + " }";
}
 
 
template<>
inline  std::string     element_to_string(const std::vector<unsigned long long>&EdgeList)
{
std::string     retval = "{(" + std::to_string(EdgeList.size()) + ") ";
 
        if (EdgeList.size()>0)
                retval += std::to_string(EdgeList[0]);
 
        for(size_t i = 1; i<EdgeList.size(); i++)
        {
                retval += ", " + std::to_string(EdgeList[i]);
        }
 
        return retval + " }";
}
 
 
 
 
 
template <Dims_t N, class T>
class   ReferencingMemArray : public MemArrayBase<N>, public MultiArray<N, T>,
                              public TypedArray<T>
{
protected:
//      RefPtr<MemCore::ChunkBase>      myStorage;
        RefPtr<MemCore::TypedChunk<T> > myStorage;
 
public:
        typedef RefPtr<MemCore::Chunk<T> > MemChunk;
        typedef MultiArray<N, T> MultiArray_t;
 
 
        using MultiArray<N, T>::begin;
        using MultiArray<N, T>::end;
 
 
        ReferencingMemArray( const Iterator<T>&data, const MultiIndex<N>&Sz,
                             const RefPtr<MemCore::ChunkBase>&theStorage,
                             const WeakPtr<CreativeArrayBase>&theCreator)
        : MemBase(FiberType<T>::getFiberType()->getFiberTypeIndex(), theCreator)
        , MemArrayBase<N>(FiberType<T>::getFiberType()->getFiberTypeIndex(), theCreator)
        , MultiArray<N, T>(data, Sz)
        , TypedArray<T>(theCreator)
        , myStorage(theStorage)
        {
                if (!myStorage)
                        Verbose(0) << " Warning: ReferencingMemArray<"<<typeid(T)<<"> constructed with NO storage provided, storage=" << theStorage;
        }
 
        ReferencingMemArray( const RefPtr<Chunk<T> > &data, const MultiIndex<N>&Sz, const WeakPtr<CreativeArrayBase>&theCreator)
        : MemBase(FiberType<T>::getFiberType()->getFiberTypeIndex(), theCreator)
        , MemArrayBase<N>(FiberType<T>::getFiberType()->getFiberTypeIndex(), theCreator)
        , MultiArray<N, T>( Iterator<T>( data?data->size():0, data?(*data)():0), Sz)
        , TypedArray<T>(theCreator)
        , myStorage(data)
        {
                if (!myStorage)
                        Verbose(0) << " Warning: ReferencingMemArray<"<<typeid(T)<<">() constructed with NO data provided, data =" << data;
        }
 
        ReferencingMemArray(const RefPtr<MemCore::ChunkBase>&theStorage, const MultiArray<N,T>&M, const WeakPtr<CreativeArrayBase>&theCreator)
        : MemBase(FiberType<T>::getFiberType()->getFiberTypeIndex(), theCreator)
        , MemArrayBase<N>(FiberType<T>::getFiberType()->getFiberTypeIndex(), theCreator)
        , MultiArray<N, T>( M )
        , TypedArray<T>(theCreator)
        , myStorage(theStorage)
        {
                if (!myStorage)
                        Verbose(0) << " Warning: ReferencingMemArray<"<<typeid(T)<<">() constructed with NO storage data provided, data =" <<theStorage;
        }
 
        ReferencingMemArray(const ReferencingMemArray&RMA)
        : MemBase(FiberType<T>::getFiberType()->getFiberTypeIndex(), RMA.myCreator() )
        , MemArrayBase<N>(FiberType<T>::getFiberType()->getFiberTypeIndex(), RMA.myCreator() )
        , MultiArray<N, T>( RMA )
        , TypedArray<T>(RMA.myCreator() )
        , myStorage(RMA.myStorage)
        {
                if (!myStorage)
                        Verbose(0) << " Warning: ReferencingMemArray<"<<typeid(T)<<"> Copy constructo NO storage provided, storage=" << myStorage;
        }
 
protected:
        ~ReferencingMemArray()
        {}
public:
 
 
        bool    copyFrom(const RefPtr<MemCore::ChunkBase>&theChunk) override
        {
        RefPtr<MemCore::TypedChunk<T> > mine = myChunk();
                if (!mine) return false;
 
        RefPtr<MemCore::TypedChunk<T> > compatibleChunk = theChunk;
                if (!compatibleChunk) return false;
                if (compatibleChunk->nElements() != mine->nElements())
                        return false;
 
                mine->get_vector() = compatibleChunk->get_vector();
 
                return true;
        }
 
 
        RefPtr<MemCore::TypedChunk<T> > myChunk() const override
        {
                return this->StoragePtr();
        }
 
        MemCore::memsize_t memsize() const override
        {
                if( myStorage )
                        return myStorage->memsize();
 
                Verbose(0) << "ReferencingMemArray:memsize() NullPtr for Storage!";
                return 0;
 
        }
 
        index_t nElements() const override
        {
                return MultiArray<N, T>::nElements();
        }
 
        std::string     getElementAsString(size_t index) const override
        {
                if (!this->myStorage)
                        return {};
 
                if (index >= this->myStorage->nElements() )
                        return {};
 
        const auto&Datum = this->myStorage->get_vector()[index];
 
                return  Fiber::element_to_string(Datum);
        }
 
 
        void    DeferredConstructor() override
        {
                MemCore::SaveRegistry<MemBase>::addInterfaces(this);
        }
 
        const type_info&getType() const override
        {
                return typeid(T);
        }
 
        //TODO: was marked as override, but doesn't
        const type_info&getBaseType() const
        {
                return typeid(typename MemCore::TypedChunk<T>::base_vector_type::value_type);
        }
 
        HyperslabParameters&getHyperslabParameters() override
        {
                return *this;
        }
 
        void*getPtr()  override
        {
                return this->ptr(); // from Iterator<>
        }
 
        const void*OriginPtr() const override
        {
                return 0;
        }
 
        const void*DeltaPtr()  const override
        {
                return 0;
        }
 
        T first() const override
        {
                return MultiArray_t::first();
        }
 
        T last() const override
        {
                return MultiArray_t::last();
        }
 
        CreativeIterator<T>* creativeIterator() override
        {
                return this;
        }
 
        const CreativeIterator<T>* creativeIterator() const override
        {
                return this;
        }
 
        const RefPtr<MemCore::TypedChunk<T> >&StoragePtr() const
        //      const RefPtr<MemCore::ChunkBase> StoragePtr() const
        {
                return myStorage;
        }
 
 
        const RefPtr<MemCore::TypedChunk<T> >&getStorage() const
//      const RefPtr<MemCore::ChunkBase> getStorage() const
        {
                return myStorage;
        }
 
        const RefPtr<MemCore::TypedChunk<T> >&getTypedStorage() const
        {
                return myStorage;
        }
 
        MultiIndex<N> Size() const override
        {
                return MultiArray_t::Size();
        }
};
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_REFERENCINGMEMARRAY_HPP */