Field.hpp

#ifndef __FIBER_FIELD_HPP
#define __FIBER_FIELD_HPP "Created 27.02.2001 21:42:27 by werner"

#include "FieldAPI.h"
#include <memcore/RefPtr.hpp>
#include <memcore/Creator.hpp>
#include <memcore/Interface.hpp>
#include <memcore/Ageable.hpp>
#include <string>
#include "MemArray.hpp"
#include "CreativeArray.hpp"
#include <map>

#include "FragmentSelector.hpp"
#include "FragmentID.hpp"
#include "Attributes.hpp"
#include "MemArrayProperties.hpp"


namespace Fiber
{
        using MemCore::ReferenceBase;
        using MemCore::Intercube;
        using MemCore::Interface;
        using MemCore::interface_cast;
        using MemCore::StrongPtr;
        using MemCore::NullPtr;
        using std::string;
        using std::map;
        using MemCore::memsize_t;

class   FIELD_API FieldContainer : public ReferenceBase<FieldContainer>
{
public:
        FieldContainer();

        ~FieldContainer();
};


class   FIELD_API Field : public ReferenceBase<Field>, public Intercube, public MemCore::Ageable, public Attributes
{
        /*TODO:
          Restructure. Not use a map from fragment ID's to arrays,
          but a vector of arrays, plus a reference to a FragmentProperties entry
          which is a vector of FragmentID's with reverse lookup.
         */

        typedef map< RefPtr<FragmentID>, RefPtr<CreativeArrayBase>, CompareFragmentIDs > fragments_t; 

//      typedef map< index_t, RefPtr<CreativeArrayBase>, CompareFragmentIDs > Nfragments_t;

        fragments_t fragments;

public:
        Field();

        Field(const RefPtr<CreativeArrayBase>&FFC);

        Field(const RefPtr<MemBase>&Mb);

        Field(const RefPtr<MemBase>&Mb, const RefPtr<MemCore::Cache>&Cache);

        template <class T, int N>
        Field(const MemCore::Ref<MemArray<N, T> >&MemRefPtr)
        : ReferenceBase<Field>(this)
        {
                MemCore::SaveRegistry<Field>::addInterfaces(this); 
        RefPtr<MemBase> MembasePtr = MemRefPtr;
                setPersistentData(MembasePtr);
        }

        bool setDiscardableData(const RefPtr<MemBase>&Mb, 
                                const RefPtr<MemCore::Cache>&Cache = MemCore::Cache::MemCache(), 
                                const RefPtr<FragmentID>& =NullPtr() ); 


        bool hasData(const RefPtr<FragmentID>&FID=NullPtr() ) const
        {
        RefPtr<CreativeArrayBase> CA = getCreator(FID);
                if (!CA)
                        return false; 

                return CA->hasData();
        } 


        bool setPersistentData( const RefPtr<MemBase>&Mb, const RefPtr<FragmentID>& =NullPtr(), 
                                const RefPtr<MemCore::Cache>&Cache = MemCore::Cache::MemCache() );


        template <class T, int N>
        bool setPersistentData( const MemCore::RefPtr<Chunk<T> >&Mb, const MultiIndex<N>&Dimensions,
                                const RefPtr<FragmentID>&FragID =NullPtr(), 
                                const RefPtr<MemCore::Cache>&Cache = MemCore::Cache::MemCache() )
        {
                return setPersistentData( new MemArray<N,T>(Mb, Dimensions), FragID, Cache);
        }
        template <class T>
        bool setPersistentData1D(const MemCore::RefPtr<Chunk<T> >&data,
                                 const RefPtr<FragmentID>&FragID =NullPtr(), 
                                 const RefPtr<MemCore::Cache>&Cache = MemCore::Cache::MemCache() )
        {
                if (!data)
                        return false;

                return setPersistentData( data, MIndex(data->size() ), FragID, Cache);
        }

        ~Field();

        RefPtr<MemArrayProperties> getProperties() const;

        const type_info&getFieldStorageType() const;

        const type_info&getElementType() const
        {
                if (RefPtr<MemArrayProperties> MP = getProperties() )
                {
                        return MP->myElementType();
                }
                else
                        return typeid(void);
        }

        MemCore::WeakPtr<FiberTypeBase> getElementFiberType() const
        {
                if (RefPtr<MemArrayProperties> MP = getProperties() )
                        return MP->getFiberType().self(); 

                return NullPtr();       
        } 

        int     getMemoryUsage(memsize_t&UsedMemory, memsize_t&WantedMemory) const;

        bool    isType(const TypeList_t&TL) const
        {
                return containsType(TL, getElementType() );
        }

        const FiberTypeBase&getFiberType() const
        {
                if (RefPtr<MemArrayProperties> MP = getProperties() )
                {
                        return MP->getFiberType();
                }
                else
                        return FiberType<void>::getFiberType();
        }

        bool addFiberType(TypeList_t&TypeList) const
        {
                if (RefPtr<MemArrayProperties> MP = getProperties() )
                {
                        TypeList.insert(  MP->getFiberType().self() ); 
                        return true;
                } 
                return false;
        }

        void setCreator(const RefPtr<CreativeArrayBase>&FFC, const RefPtr<FragmentID>& =NullPtr() );

        size_t nFragments() const
        {
                return fragments.size();
        } 

        RefPtr<FragmentID> getFragmentID(const string&FragmentName) const;

        RefPtr<CreativeArrayBase> getCreator(const RefPtr<FragmentID>& =NullPtr() ) const; 

        RefPtr<CreativeArrayBase> getCreator(const string&FragmentName) const;

        RefPtr<CreativeArrayBase> getCompatibleCreator(const RefPtr<FragmentID>&F =NullPtr() ) const
        {
                if (!F) return getCreator();
        RefPtr<CreativeArrayBase> CAB = getCreator(F); 
                if (CAB) return CAB; 
                return getCreator( F->Name() );
        }


        RefPtr<MemBase> getData(const RefPtr<FragmentID>&FID=NullPtr() ) const
        {
                if (RefPtr<CreativeArrayBase> CA = getCreator(FID) )
                        return CA->create();

                return NullPtr();
        } 

        RefPtr<MemCore::ChunkBase> getChunk(const RefPtr<FragmentID>&FID=NullPtr() ) const
        {
                if (RefPtr<MemBase> Mb = getData( FID ) )
                        return Mb->getChunk();

                return NullPtr();
        }

        RefPtr<MemBase> getCompatibleData(const RefPtr<FragmentID>&F =NullPtr() ) const
        {
        RefPtr<CreativeArrayBase> CA = getCompatibleCreator(F);
                if (!CA)
                        return NullPtr();

                return CA->create();
        } 

        typedef FragmentIterator Iterator;

        int     iterate(FragmentIterator&, const MemCore::WeakPtr<FragmentSelector>&FS = NullPtr() );

        int rank() const; 

        RefPtr<SizeInterface> getSize() const; 

        void    Speak(int indent=0, int maxindent=-1) const;
};

} /* namespace Fiber */

#endif /* __FIBER_FIELD_HPP */