Field.hpp

#ifndef __FIBER_FIELD_HPP
#define __FIBER_FIELD_HPP "Created 27.02.2001 21:42:27 by werner"
 
#include <memcore/defines.hpp>
 
#include "FieldAPI.h"
#include <memcore/RefPtr.hpp>
#include <memcore/RefMap.hpp>
#include <memcore/Creator.hpp>
#include <memcore/Interface.hpp>
#include <memcore/Ageable.hpp>
#include <memcore/Attributes.hpp>
 
#include <string>
#include <memcore/shared_mutex.hpp>
 
#if __has_include(<flat_map>)
#include <flat_map>
#endif
 
#include "MemArray.hpp"
#include "CreativeArrayBase.hpp"
 
#include "FragmentSelector.hpp"
#include "FragmentID.hpp"
#include "MemArrayProperties.hpp"
#include "FragmentIDCollection.hpp"
#include "Iterator.hpp"
#include "FunctionalCreator.hpp"
 
namespace Fiber
{
        using MemCore::ReferenceBase;
        using MemCore::Intercube;
        using MemCore::Interface;
        using MemCore::interface_cast;
        using MemCore::StrongPtr;
        using std::string;
        using MemCore::memsize_t;
 
 
template <typename Key, typename Value>
class   FlatMap
{
        using   Pair = std::pair<Key, Value>;
        std::vector<Pair> data;
 
public:
        using   Container = std::vector<Pair>;
        using   iterator = typename Container::iterator;
        using   const_iterator = typename Container::const_iterator;
        using   value_type = Pair;
 
        // Inline comparison function
static  inline bool compare(const Pair& a, const Pair& b)
        {
                return a.first < b.first;
        }
 
        // Insert a key-value pair
        std::pair<typename Container::iterator, bool>
        insert(const Pair& pair)
        {
                // Perform a binary search to find the appropriate position
        auto it = std::lower_bound(data.begin(), data.end(), pair, compare);
                // Check if the key already exists
                if (it == data.end() || it->first != pair.first)
                {
                        // update the iterator because insertion will invalidate all iterators
                        it = data.insert(it, pair); // Insert the new pair
                        return { it, true };        // Indicate successful insertion
                }
 
                // Key exists; update the value
                it->second = pair.second;
                return { it, false };           // Indicate that the key was already present
        }
 
        // Erase a key-value pair by key
        bool    erase(const Key& key)
        {
        auto it = std::lower_bound(data.begin(), data.end(), Pair{key, Value{}}, compare);
                if (it != data.end() && it->first == key)
                {
                        data.erase(it); // Remove the element
                        return true;    // Indicate successful removal
                }
                return false;        // Indicate key not found
        }
 
        // Find a value by key
        const_iterator find(const Key& key) const
        {
        auto    it =  std::lower_bound(data.begin(), data.end(), Pair{key, Value{}}, compare);
                if (it != data.end() && it->first == key)
                        return  it;
 
                return  data.end();
        }
 
        // Find a value by key
        iterator find(const Key& key)
        {
        auto    it =  std::lower_bound(data.begin(), data.end(), Pair{key, Value{}}, compare);
                if (it != data.end() && it->first == key)
                        return  it;
 
                return  data.end();
        }
 
        // Iterator support for ranged-for loops
        iterator begin()                {       return data.begin();    }
        iterator end()                  {       return data.end();      }
        const_iterator begin()  const   {       return data.begin();    }
        const_iterator end()    const   {       return data.end();      }
        const_iterator cbegin() const   {       return data.cbegin();   }
        const_iterator cend()   const   {       return data.cend();     }
 
        void    reserve(std::size_t size)
        {
                data.reserve(size);
        }
 
        auto    size() const
        {
                return  data.size();
        }
 
        void    clear()
        {
                data.clear();
        }
 
        bool    empty() const
        {
                return data.empty();
        }
};
 
 
 
 
class   FIELD_API FragmentIndexIterator
{
public:
        virtual ~FragmentIndexIterator();
 
        virtual bool apply(int FragmentIndex, const RefPtr<CreativeArrayBase>&) = 0;
};
 
class   FIELD_API Field : public OwnerOf<CreativeArrayBase, CreativeArrayBaseContainerBase>
                        , public Ownable<Field>
                        , public Intercube
                        , public FragmentIDCollectionProvider
                        , public MemCore::Ageable
                        , public SaveableAttributes
{
        RefPtr<FragmentIDCollection>            myFragmentIDCollection;
 
        bool processOwnership(MemCore::Intercube&Output,
                              const MemCore::Intercube&Input) const override
        {
                return Ownable<Field>::processOwnership(Output, Input);
        }
 
public:
 
#if __has_include(<flat_map>)
        using   fragment_map_t = std::flat_map<FragmentIndex_t, MemCore::RefPtr<CreativeArrayBase> >;
        using   fragments_t = MemCore::RefMap<FragmentIndex_t, CreativeArrayBase, fragment_map_t>;
 
static  constexpr bool use_std__flat_map_for_fragments = true;
#else
//      using   fragments_t = MemCore::RefMap<FragmentIndex_t, CreativeArrayBase>;
 
        using   fragments_t = FlatMap<FragmentIndex_t, RefPtr<CreativeArrayBase>>;
 
static  constexpr bool use_std__flat_map_for_fragments = false;
#endif
 
        using   fragment_mutex_t = MemCore::shared_mutex;
 
protected:
 
        mutable MemCore::shared_mutex   fragment_mutex;
        fragments_t                     fragments;
 
        const RefPtr<CreativeArrayBase>&setCreatorViaFragmentIndex(FragmentIndex_t FI, const RefPtr<CreativeArrayBase>&CAB);
 
public:
        void    reserve_fragments(size_t N);
 
        void    extremeUnction() override;
 
        ListRelativeToBinder<WeakPtr<CreativeArrayBase>> UnsavedCreators;
 
        using   CAB_t = RefPtr<CreativeArrayBase>;
 
static  const CAB_t&CreativeArrayNullPtr();
 
 
        void    clear();
 
        FragmentIndex_t getNumericalID(const RefPtr<FragmentID>&fid);
 
        FragmentIndex_t findNumericalID(const RefPtr<FragmentID>&fid) const;
 
        FragmentIndex_t findNumericalIDByName(const string&FragmentName) const;
 
        RefPtr<FragmentID>&makeFragmentID( const string&fragmentname );
 
        RefPtr<FragmentID>&operator[]( const string&fragmentname )
        {
                return makeFragmentID( fragmentname );
        }
 
        RefPtr<FragmentIDCollection> getFragmentIDCollection() const override;
 
        DynamicSize getFragmentLayout() const
        {
                if (RefPtr<FragmentIDCollection>  FIC = getFragmentIDCollection() )
                        return FIC->getFragmentLayout();
 
                return {};
        }
 
        const FragmentIDCollection::FragmentIDs_t&getFragmentIDs() const;
 
        bool    validate(FragmentIndex_t FragmentNumber) const;
 
 
#ifdef  __NO_FIBER_FIELD_DEFAULT_CONSTRUCTOR
private:
#endif
 
        Field();
 
public:
 
        Field(const RefPtr<FragmentIDCollection>&theFragmentIDCollection);
 
        typedef WeakPtr<Field, Field::reference_domain_t> WeakFieldPtr_t;
 
        explicit Field(const WeakPtr<Field>&SimilarField);
 
        explicit Field(const FragmentIDCollectionProvider&FICP);
 
        explicit Field(const RefPtr<CreativeArrayBase>&FFC, const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr );
 
        explicit Field(const RefPtr<MemBase>&Mb, const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr);
 
        Field(const RefPtr<CreativeArrayBase>&FFC, const WeakPtr<Field>&SimilarField);
 
        Field(const RefPtr<MemBase>&MAb, const WeakPtr<Field>&SimilarField);
 
        Field(const RefPtr<CreativeArrayBase>&FFC, const FragmentIDCollectionProvider&FICP);
 
        Field(const RefPtr<MemBase>&MAb, const FragmentIDCollectionProvider&FICP);
 
 
        Field(const RefPtr<MemBase>&Mb, const RefPtr<MemCore::Cache>&Cache, const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr);
 
        template <Dims_t DIMS>
        Field(const MultiIndex<DIMS>&NumberOfFragments, const string&FragmentNamePrefix)
        : myFragmentIDCollection( new FragmentIDCollection( NumberOfFragments, FragmentNamePrefix) )
        {
                reserve_fragments( NumberOfFragments.size() );
        }
 
        template <Dims_t DIMS>
        bool    setFragmentLayout(const MultiIndex<DIMS>&NumberOfFragments, const string&FragmentNamePrefix)
        {
                reserve_fragments( NumberOfFragments.size() );
 
                if (!myFragmentIDCollection)
                {
                        myFragmentIDCollection = new FragmentIDCollection( NumberOfFragments, FragmentNamePrefix);
                        return true;
                }
 
                return myFragmentIDCollection -> setFragmentLayout( NumberOfFragments, FragmentNamePrefix);
        }
 
        RefPtr<MemBase> newFragmentationArray() const;
 
        template <class T, Dims_t N>
        Field(const MemCore::Ref<MemArray<N, T> >&MemRefPtr, const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
        : myFragmentIDCollection( theFragmentIDCollection )
        {
                MemCore::SaveRegistry<Field>::addInterfaces(this);
        RefPtr<MemBase> MembasePtr = MemRefPtr;
                setPersistentData(MembasePtr);
        }
 
        template <class T, Dims_t N>
        Field(const MemCore::RefPtr<MemArray<N, T> >&MemRefPtr, const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
        : myFragmentIDCollection( theFragmentIDCollection )
        {
                MemCore::SaveRegistry<Field>::addInterfaces(this);
        RefPtr<MemBase> MembasePtr = MemRefPtr;
                setPersistentData(MembasePtr);
        }
 
        template <class T, Dims_t N>
        Field(const MemCore::WeakPtr<MemArray<N, T> >&MemRefPtr, const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
        : myFragmentIDCollection( theFragmentIDCollection )
        {
                MemCore::SaveRegistry<Field>::addInterfaces(this);
        RefPtr<MemBase> MembasePtr = MemRefPtr;
                setPersistentData(MembasePtr);
        }
 
        template <class T, Dims_t N>
        Field(const MemCore::MemVector<T>&Data, const MultiIndex<N>&Size, const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
        : Field( new MemArray<N,T>(Data, Size), theFragmentIDCollection)
        {}
 
        template <class T, Dims_t N>
        Field(const MemCore::RefPtr<MemCore::TypedChunk<T>>&Data, const MultiIndex<N>&Size, const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
        : Field( new MemArray<N,T>(Data, Size), theFragmentIDCollection)
        {}
 
        void    own(CreativeArrayBase&CAB)
        {
                CAB.addOwner( this, *this );
                Ageable::update(CAB);
        }
 
        void    own(const RefPtr<CreativeArrayBase>&CAB)
        {
                if (CAB) own(*CAB);
        }
 
        RefPtr<CreativeArrayBase>
                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();
        }
 
 
        const CAB_t&setPersistentData( const RefPtr<MemBase>&Mb, const RefPtr<FragmentID>& = nullptr ,
                                       const RefPtr<MemCore::Cache>&Cache = MemCore::Cache::MemCache(),
                                       const string&ProvenanceInfo = {});
 
        const CAB_t&setPersistentData( const RefPtr<MemBase>&Mb, const RefPtr<FragmentID>&fID,
                                       const string&ProvenanceInfo)
        {
                return setPersistentData(Mb, fID, MemCore::Cache::MemCache(), ProvenanceInfo);
        }
 
        const CAB_t&setPersistentDataByName( const RefPtr<MemBase>&Mb, const string&FragmentName,
                                       const RefPtr<MemCore::Cache>&Cache = MemCore::Cache::MemCache() )
        {
        RefPtr<FragmentID> Fid = makeFragmentID( FragmentName );
                return setPersistentData( Mb, Fid, Cache );
        }
 
        template <class T, Dims_t N>
        const CAB_t&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, Dims_t N>
        const CAB_t&setPersistentData( 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>
        const CAB_t&setPersistentData1D(const MemCore::RefPtr<Chunk<T> >&data,
                                        const RefPtr<FragmentID>&FragID = nullptr,
                                        const RefPtr<MemCore::Cache>&Cache = MemCore::Cache::MemCache() )
        {
                if (!data)
                        return CreativeArrayNullPtr();
 
                return setPersistentData( data, MIndex(data->size() ), FragID, Cache);
        }
 
protected:
        ~Field();
 
public:
        RefPtr<MemArrayProperties> getProperties() const;
 
        const type_info&getFieldStorageType() const;
 
        const type_info&getElementType() const;
 
        MemCore::WeakPtr<FiberTypeBase> getElementFiberType() const;
 
        [[deprecated("Old version, use getElementFiberType() instead.")]]
        MemCore::WeakPtr<FiberTypeBase> getFiberType() const
        {
                return getElementFiberType();
        }
 
        int     getMemoryUsage(memsize_t&UsedMemory, memsize_t&WantedMemory) const;
 
        bool    isType(const TypeList_t&TL) const
        {
                return containsType(TL, getElementType() );
        }
 
        FiberTypeIndex  getFiberTypeIndex() const
        {
                if (RefPtr<FiberTypeBase> FTB = getElementFiberType())
                        return FTB->getFiberTypeIndex();
 
                return {};
        }
 
        bool addFiberType(TypeList_t&TypeList) const
        {
                if (RefPtr<MemArrayProperties> MP = getProperties() )
                {
                        TypeList.insert(  MP->getFiberType() );
                        return true;
                }
                return false;
        }
 
        const RefPtr<CreativeArrayBase>&setCreator(const RefPtr<CreativeArrayBase>&FFC, const RefPtr<FragmentID>& = nullptr );
 
        const RefPtr<CreativeArrayBase>&setCreatorByName(const RefPtr<CreativeArrayBase>&FFC, const string&FragmentName)
        {
        RefPtr<FragmentID>&Fid = makeFragmentID( FragmentName );
 
                return setCreator( FFC, Fid );
        }
 
        const RefPtr<CreativeArrayBase>&setCompatibleCreator(const RefPtr<CreativeArrayBase>&CAB, const RefPtr<FragmentID>&fid = nullptr )
        {
                if (fid)
                {
                RefPtr<FragmentID>&Fid = makeFragmentID( fid->Name() );
                        return setCreator( CAB, Fid );
                }
                return setCreator(CAB);
        }
 
 
        FunctionalCreator&setLambda(const FunctionalCreator::Functor&F, const RefPtr<FragmentID>&fid=nullptr )
        {
        RefPtr<FunctionalCreator> FC = new FunctionalCreator(F);
                setCreator( FC, fid);
                return *FC;
        }
 
        FunctionalCreator&setLambda(const RefPtr<FragmentID>&fid, const FunctionalCreator::Functor&F)
        {
        RefPtr<FunctionalCreator> FC = new FunctionalCreator(F);
                setCreator( FC, fid);
                return *FC;
        }
 
        FunctionalCreator&setCompatibleLambda(const FunctionalCreator::Functor&F, const RefPtr<FragmentID>&fid=nullptr )
        {
        RefPtr<FunctionalCreator> FC = new FunctionalCreator(F);
                setCompatibleCreator( FC, fid);
                return *FC;
        }
 
        const RefPtr<CreativeArrayBase>&setFunctionalCreator(const FunctionalCreator::Functor&F, const RefPtr<FragmentID>&fid=nullptr )
        {
        RefPtr<FunctionalCreator> FC = newFunctionalCreator(F);
                return setCreator( FC, fid);
        }
 
 
        template <class Functor>
//      FunctionalCreator<Functor>&setFunctor(const Functor&F, const RefPtr<FragmentID>&fid= nullptr )
        FunctionalCreator&setFunctor(const Functor&F, const RefPtr<FragmentID>&fid=nullptr )
        {
                return setLambda( F, fid);
        }
 
        template <class Functor>
//      FunctionalCreator<Functor>&setFunctor(const RefPtr<FragmentID>&fid, const Functor&F)
        FunctionalCreator&setFunctor(const RefPtr<FragmentID>&fid, const Functor&F)
        {
                return setLambda( F, fid);
        }
 
 
 
        size_t  nFragments() const
        {
                return fragments.size();
        }
 
        size_t  NumberOfFragments() const
        {
                return fragments.size();
        }
 
        bool    isUnfragmented() const;
 
        bool    isFragmented() const
        {
                return !isUnfragmented();
        }
 
        RefPtr<FragmentID> getFragmentID(const string&FragmentName) const;
 
        RefPtr<FragmentID> operator()(const string&FragmentName) const
        {
                return getFragmentID( FragmentName );
        }
 
        RefPtr<CreativeArrayBase> getCreator(const RefPtr<FragmentID>& = nullptr ) const;
 
 
        RefPtr<CreativeArrayBase> operator()(const RefPtr<FragmentID>&FID = nullptr ) const
        {
                return getCreator( FID );
        }
 
        RefPtr<CreativeArrayBase> getCreatorByName(const string&FragmentName) const;
 
        using NamedFragment = std::pair<RefPtr<CreativeArrayBase>, RefPtr<FragmentID>>;
 
        NamedFragment   getCreatorByNameF(const string&FragmentName) const;
 
        RefPtr<CreativeArrayBase> getCreatorByNumericalID(FragmentIndex_t NumericalID) const;
        RefPtr<CreativeArrayBase>&getCreatorReferenceViaFragmentIndex(FragmentIndex_t NumericalID);
 
        [[deprecated("Use function getCreatorNumericalID() instead")]]
                   RefPtr<CreativeArrayBase> getCreator(FragmentIndex_t NumericalID) const
           {
                   return getCreatorByNumericalID(NumericalID);
           }
 
        RefPtr<CreativeArrayBase> getCompatibleCreator(const RefPtr<FragmentID>&F = nullptr ) const
        {
                if (!F) return getCreator();
        RefPtr<CreativeArrayBase> CAB = getCreator(F);
                if (CAB) return CAB;
                return getCreatorByName( F->Name() );
        }
 
        NamedFragment getCompatibleCreatorF(const RefPtr<FragmentID>&F = nullptr ) const;
 
        RefPtr<MemBase> getData(const RefPtr<FragmentID>&FID = nullptr ) const;
 
 
 
        RefPtr<MemBase> getDataByNumericalID(FragmentIndex_t NumericalID) const;
 
        DEPRECATED("Use function getDataByNumericalID() instead",
                   RefPtr<MemBase> getData(FragmentIndex_t NumericalID) const)
        {
                return getDataByNumericalID(NumericalID);
        }
 
        [[deprecated("Avoid using this function because of its random results; use with care.")]]
        RefPtr<MemBase> getFirstData() const;
 
        [[deprecated("Avoid using this function because of its random results; use with care.")]]
        RefPtr<CreativeArrayBase> getFirstCreator() const;
 
        [[deprecated("Avoid using this function because of its random results; use with care.")]]
        RefPtr<FragmentID>      getFirstFragmentID() const;
 
        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();
        }
 
        using  Iterator = FragmentIterator;
 
        [[deprecated("Use iterate() via std::function instead")]]
        unsigned        iterate(FragmentIterator&, const MemCore::WeakPtr<FragmentSelector>&FS = nullptr ) const;
 
 
        template <class T>
        [[deprecated("Use iterate() via std::function instead")]]
        unsigned        Iterate(const T&t, const MemCore::WeakPtr<FragmentSelector>&FS = nullptr ) const
        {
        FragmentFunctor<T> myFunctor(t);
                return iterate(myFunctor, FS);
        }
 
        template <class T>
        [[deprecated("Use iterate() via std::function instead")]]
        unsigned        iterate_fragments(const T&t, const MemCore::WeakPtr<FragmentSelector>&FS = nullptr ) const
        {
        FragmentFunctor<T> myFunctor(t);
                return iterate(myFunctor, FS);
        }
 
        using FragmentIterator_t = std::function<bool(const RefPtr<FragmentID>&, const RefPtr<CreativeArrayBase>&)>;
 
        Ageable getMostRecentCreatorAge() const;
        Ageable getMostRecentAttributeAge() const;
 
        bool    hasFragmentsNewerThan(const Ageable&A) const;
 
 
        unsigned        iterate(const FragmentIterator_t&FI, bool parallel = false, bool copy_map_internally = false ) const;
 
        unsigned        iterate(bool parallel, const FragmentIterator_t&FI, bool copy_map_internally = false ) const
        {
                return iterate(FI, parallel, copy_map_internally);
        }
 
        unsigned        iterate_parallel(const FragmentIterator_t&FI, bool copy_map_internally = false) const
        {
                return iterate(FI, true, copy_map_internally);
        }
 
 
        unsigned        iterate(FragmentIndexIterator&FFI, const WeakPtr<FragmentSelector>&FS = nullptr, bool copy_map_internally = false ) const;
 
         Dims_t Dims() const;
 
        RefPtr<SizeInterface> getSize() const;
 
 
        bool    isCompatible(const Field&F);
 
        void    Speak(int indent=0, int maxindent=-1) const;
 
        string  xml() const;
 
 
        enum    class CreationFailAlternative
        {
                Fail,
                Persistent,
                Discardable
        };
 
 
        RefPtr<CreativeArrayBase> createCreator(const RefPtr<MemBase>&Data,
                                                const RefPtr<FragmentID>& = nullptr,
                                                CreationFailAlternative = CreationFailAlternative::Persistent,
                                                const WeakPtr<MemCore::Cache>&theCache = MemCore::Cache::MemCache() );
 
        RefPtr<CreativeArrayBase> createCreator(const RefPtr<MemBase>&Data,
                                                const string&FragmentName,
                                                CreationFailAlternative = CreationFailAlternative::Persistent,
                                                const WeakPtr<MemCore::Cache>&theCache = MemCore::Cache::MemCache() );
 
        template <Dims_t N, class T>
        std::pair< RefPtr<MemArray<N,T>>, RefPtr<CreativeArrayBase>>
                createData(const MultiIndex<N>&Size,
                           const RefPtr<FragmentID>&fid = nullptr,
                           Field::CreationFailAlternative FailMode = Field::CreationFailAlternative::Persistent,
                           const WeakPtr<MemCore::Cache>&theCache = MemCore::Cache::MemCache() )
        {
        RefPtr<MemArray<N,T>> myMemArray = new MemArray<N,T>( Size);
 
                return { myMemArray, createCreator(myMemArray, fid, FailMode, theCache) };
        }
 
 
        template <Dims_t N, class T>
        std::pair< RefPtr<MemArray<N,T>>, RefPtr<CreativeArrayBase>>
                createData(const MultiIndex<N>&Size,
                           const string&fragmentname,
                           Field::CreationFailAlternative FailMode = Field::CreationFailAlternative::Persistent,
                           const WeakPtr<MemCore::Cache>&theCache = MemCore::Cache::MemCache() )
        {
        RefPtr<MemArray<N,T>> myMemArray = new MemArray<N,T>( Size);
 
                return { myMemArray, createCreator(myMemArray, fragmentname, FailMode, theCache) };
        }
 
 
        template <Dims_t Dims>
        MultiIndex<Dims>&setFragmentOffset(const string&FragmentName, const MultiIndex<Dims>&Offset)
        {
        RefPtr<FragmentID>&FID = makeFragmentID( FragmentName );
 
                return ::Fiber::setFragmentOffset( *FID, Offset);
        }
 
static  const RefPtr<Field>&NullPtrField();
 
};
 
 
using   FieldFragment = std::pair<RefPtr<Field>, RefPtr<FragmentID>>;
 
inline  FieldFragment operator<<(const RefPtr<Field>&F, const RefPtr<FragmentID>&Fid)
{
        return { F, Fid };
}
 
 
inline  FieldFragment operator<<(const RefPtr<Field>&F, const string&FragmentName)
{
        if (!F)
                return {nullptr, nullptr};
 
        return  { F, F->makeFragmentID(FragmentName) };
}
 
inline  RefPtr<CreativeArrayBase> operator<<(const FieldFragment&FF, const RefPtr<MemBase>&Mb)
{
        if ( FF.first )
                return  FF.first->setPersistentData(Mb, FF.second );
 
        return  nullptr;
}
 
inline  RefPtr<CreativeArrayBase> operator>>(const FieldFragment&FF, Field::CAB_t&Result)
{
        if (FF.first)
                return  Result = FF.first->getCreator( FF.second );
 
        Result = nullptr;
        return  nullptr;
}
 
inline  RefPtr<CreativeArrayBase> operator<<(const FieldFragment&&FF, const Field::CAB_t&theCreator)
{
        if (FF.first)
                return  FF.first->setCreator(theCreator, FF.second );
 
        return  nullptr;
}
 
 
 
using   FieldFragmentRef = std::pair<Field&, RefPtr<FragmentID>>;
 
inline  FieldFragmentRef operator<<(Field&F, const RefPtr<FragmentID>&Fid)
{
        return { F, Fid };
}
 
inline  FieldFragmentRef operator<<(Field&F, const string&FragmentName)
{
        return  { F, F.makeFragmentID(FragmentName) };
}
 
inline  RefPtr<CreativeArrayBase> operator<<(const FieldFragmentRef&FF, const RefPtr<MemBase>&Mb)
{
        return  FF.first.setPersistentData(Mb, FF.second );
}
 
inline  RefPtr<CreativeArrayBase> operator<<(const FieldFragmentRef&&FF, const Field::CAB_t&theCreator)
{
        return  FF.first.setCreator(theCreator, FF.second );
}
 
inline  RefPtr<CreativeArrayBase> operator>>(const FieldFragmentRef&FF, Field::CAB_t&Result)
{
        return  Result = FF.first.getCreator( FF.second );
}
 
 
 
 
 
template <>
class   FIELD_API Iterator<FragmentID> : public Field::Iterator
{
};
 
 
template <class Functor>
inline FunctionalCreator&operator+=(const FieldFragmentRef&FieldFragment,
                                    const Functor&Lambda)
{
        return FieldFragment.first.setFunctor( Lambda, FieldFragment.second);
}
 
template <class Functor>
inline FunctionalCreator&operator+=(const Field&F, const Functor&Lambda)
{
        return F.setFunctor( Lambda );
}
 
 
inline  RefPtr<CreativeArrayBase> operator<<(const FieldFragment&FF,
                                             const FunctionalCreator::Functor&F)
{
        if (FF.first)
                return  FF.first->setFunctionalCreator(F, FF.second );
 
        return  nullptr;
}
 
inline  RefPtr<CreativeArrayBase> operator<<(const FieldFragmentRef&FF,
                                             const FunctionalCreator::Functor&F)
{
        return  FF.first.setFunctionalCreator(F, FF.second );
}
 
 
template <class T>
inline int      operator<<=(const Field&F, const T&t)
{
        return F.iterate_fragments(t);
}
 
template <class T>
inline int      operator<<=(const RefPtr<Field>&F, const T&t)
{
        if (!F) return 0;
        return F->iterate_fragments(t);
}
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_FIELD_HPP */