Representation.hpp

#ifndef __FIBER_GRID_REPRESENTATION_HPP
#define __FIBER_GRID_REPRESENTATION_HPP "Created 27.02.2001 21:42:27 by werner"
 
#include "GridAPI.h"
#include <fiber/field/Field.hpp>
#include "FieldID.hpp"
#include <memcore/TypeInfo.hpp>
#include <set>
#include <list>
 
#include "FiberSpace.hpp"
#include <fiber/field/BaseSpace.hpp>
#include "RepresentationMap.hpp"
 
namespace Fiber
{
        using MemCore::WeakPtr;
        using MemCore::NullPtr;
        using std::set;
        using std::list;
 
constexpr const char FIBER_POSITIONS[] = "Positions";
 
 
class   GRID_API Representation;
 
#if     0
#define FIBER_MAP_TO_MAP
#endif
 
struct  GRID_API FieldProxy
{
        Representation&                 myRepresentation;
        const string                    myFieldname;
        RefPtr<FragmentIDCollection>    myFragmentIDCollection;
        RefPtr<MemBase>                 myFragmentTopology;
 
        RefPtr<Field>&FieldPtr;
 
        FieldProxy(const FieldProxy&FP);
 
        FieldProxy(Representation& theRepresentation,
                   const string &theFieldname,
                   const RefPtr<FragmentIDCollection>&theFragmentIDCollection,
                   RefPtr<Field>&theFieldPtr,
                   const RefPtr<MemBase>&theFragmentTopology = MemCore::NullPtr() );
 
        ~FieldProxy();
 
        FieldProxy&operator=(const RefPtr<Field>&newFieldPtr);
 
        FieldProxy&operator=(const RefPtr<MemBase>&UnfragmentedData);
 
        RefPtr<Field>&make() const;
 
        operator RefPtr<Field>&() const;
 
        const RefPtr<Field>&operator->() const;
 
 
        operator bool() const
        {
                return FieldPtr.valid();
        }
};
 
 
 
class   GRID_API Representation : public FiberMap<RefPtr<FieldID> >
                                , public Intercube
                                , public FragmentIDCollectionProvider
#ifdef   FIBER_MAP_TO_MAP
                                , public RepresentationMap
#endif
{
public: typedef FiberMap<RefPtr<FieldID> > Base_t;
        using FiberMap<RefPtr<FieldID> >::operator[];
        using FiberMap<RefPtr<FieldID> >::operator();
 
#ifdef  FIBER_MAP_TO_MAP
        using RepresentationMap::operator[];
        using RepresentationMap::makeRepresentation;
        using RepresentationMap::operator();
#endif
 
        unsigned long   RenameOperations = 0, RemovalOperations = 0;
 
static  constexpr unsigned long MaxOperations = -22U;
 
        Representation();
 
        Representation(const Representation&) = delete;
 
        void    operator=(const Representation&) = delete;
 
        ~Representation();
 
        void    extremeUnction() override;
 
        RefPtr<FieldID> makeFieldID(const string&name);
 
        RefPtr<FieldID> findFieldID(const string&name) const;
 
        bool            removeField(const string&name);
        bool            removeField(const RefPtr<FieldID>&FID);
 
        RefPtr<FieldID> renameField(const string&OldName, const string&NewName);
 
        RefPtr<FieldID> insertSharedFieldID(const Representation&R, const string&name);
 
        RefPtr<FieldID> createSharedFieldID(Representation&Carrier, const string&name);
 
 
        RefPtr<Field>   &getField(const RefPtr<FieldID>&f);
 
        const RefPtr<Field>&findField(const RefPtr<FieldID>&f) const;
 
        const RefPtr<Field>&findField(const FieldID&f) const;
 
        bool    checkIfFieldSizeIsIncompatible(const RefPtr<Field>&FieldPtr);
 
private:
        bool    AdjustAndCheckSkeletonSize(Field&P, const string&FieldName);
 
        friend struct FieldProxy;
 
public:
 
        FieldProxy      makeField(const WeakPtr<FieldID>&rf,
                                  const RefPtr<FragmentIDCollection>&ExistingFragmentIDCollection = NullPtr(),
                                  const RefPtr<MemBase>&theFragmentTopology = MemCore::NullPtr() );
 
        Field          &makeField(const FieldID&f);
 
        void    own(Field&) const;
 
        Field        &operator[](const FieldID&f)
        {
                return makeField(f);
        }
 
        FieldProxy operator[](const RefPtr<FieldID>&f)
        {
                return makeField(f);
        }
 
        FieldProxy operator[](const string&name)
        {
                return makeField( makeFieldID(name) );
        }
 
#ifdef  FIBER_MAP_TO_MAP
        Representation&operator[](const BaseSpace&D);
#endif
 
        const RefPtr<Field>&findField(const string&name) const
        {
        RefPtr<FieldID> fid = findFieldID(name);
                if (!fid)
                        return Field::NullPtrField();
 
                return findField( fid );
        }
 
        const RefPtr<Field>&findField(const char*name) const
        {
                return findField( string(name) );
        }
 
        template <class FieldNameContainer>
        const RefPtr<Field>&findField(const FieldNameContainer&FieldNames) const
        {
                for(const auto&f : FieldNames)
                {
                        if (const auto&F = findField(f) )
                                return F;
                }
                return Field::NullPtrField();
        }
 
        const RefPtr<Field>&operator()(const string&name) const
        {
                return findField( name );
        }
 
        const RefPtr<Field>&operator()(const char*name) const
        {
                return findField( name );
        }
 
        const RefPtr<Field>&operator()(const FieldID&fid) const
        {
                return findField( fid );
        }
 
        const RefPtr<Field>&operator()(const RefPtr<FieldID>&f) const;
 
        template <class FieldNameContainer>
        const RefPtr<Field>&operator()(const FieldNameContainer&FieldNames) const
        {
                return findField( FieldNames );
        }
 
        RefPtr<CreativeArrayBase> operator()(const string&name, const RefPtr<FragmentID>&f)
        {
        RefPtr<Field>   F = findField(name);
                if (!F)
                        return NullPtr();
 
                return F->getCreator(f);
        }
 
        RefPtr<CreativeArrayBase> operator()(const string&name, const string&FragmentName)
        {
        RefPtr<Field>   F = findField(name);
                if (!F)
                        return NullPtr();
 
                return F->getCreatorByName(FragmentName);
        }
 
        const RefPtr<Field>&Positions() const
        {
        RefPtr<FieldID> PositionsName = findFieldID( FIBER_POSITIONS );
                if (!PositionsName)
                        return Field::NullPtrField();
 
                return findField( PositionsName );
        }
 
        const RefPtr<Field>&getPositions() const
        {
                return Positions();
        }
 
 
//      const RefPtr<Field>&getFirstField() const;
 
        RefPtr<SizeInterface> getSize() const;
 
        RefPtr<SizeInterface> getFragmentSize(const RefPtr<FragmentID>&Fid) const;
 
        bool    setField(const string&Fieldname, const RefPtr<Field>&P);
 
        bool    setPositions(const RefPtr<Field>&P);
 
        template <class Data, Dims_t Dims>
        bool    setPositions(const Data&D, const MultiIndex<Dims>&Size,
                             const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
        {
                return setPositions(new Field(D, Size, theFragmentIDCollection));
        }
 
        template <class T, Dims_t N>
        bool    setPositions(const MemCore::WeakPtr<MemArray<N, T> >&MemRefPtr,
                             const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
        {
                return setPositions(new Field(MemRefPtr, theFragmentIDCollection));
        }
 
        bool    setPositions(const MemCore::RefPtr<MemBase>&MemRefPtr,
                             const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
        {
                return setPositions(new Field(MemRefPtr, theFragmentIDCollection));
        }
 
        bool    setPositions(const MemCore::RefPtr<CreativeArrayBase>&CrecRefPtr,
                             const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
        {
                return setPositions(new Field(CrecRefPtr, theFragmentIDCollection));
        }
 
        template <class Data, Dims_t Dims>
        bool    setField(const string&Fieldname, const Data&D, const MultiIndex<Dims>&Size,
                             const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
        {
                return setField(Fieldname, new Field(D, Size, theFragmentIDCollection) );
        }
 
        template <class T, Dims_t N>
        bool    setField(const string&Fieldname, const MemCore::WeakPtr<MemArray<N, T> >&MemRefPtr,
                         const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
 
        {
                return setField(Fieldname, new Field(MemRefPtr, theFragmentIDCollection) );
        }
 
        bool    setField(const string&Fieldname, const MemCore::RefPtr<MemBase>&MemRefPtr,
                         const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
 
        {
                return setField(Fieldname, new Field(MemRefPtr, theFragmentIDCollection) );
        }
 
 
        bool    setField(const string&Fieldname, const MemCore::RefPtr<CreativeArrayBase>&CrecPtr,
                         const RefPtr<FragmentIDCollection>&theFragmentIDCollection = nullptr)
 
        {
                return setField(Fieldname, new Field(CrecPtr, theFragmentIDCollection) );
        }
 
 
        [[deprecated("Use modern version with lambda functions instead.")]]
        int     iterate(FieldIterator&FI) const;
 
        using   const_iterator_t = std::function<bool(const FieldID&, const Field&)>;
        using   iterator_t = std::function<bool(const FieldID&, Field&)>;
 
 
        int     iterate_fields(const iterator_t&F) const;
 
        int     iterate_const_fields(const const_iterator_t&F) const
        {
                return iterate_fields(F);
        }
 
        int     iterate(const iterator_t&F) const
        {
                return iterate_fields(F);
        }
 
 
        [[deprecated("Just use iterate().")]]
        int     iterate_m(const iterator_t&F) const
        {
                return  iterate_fields(F);
        }
 
        typedef FieldIterator Iterator;
 
        using iterate_all_t = std::function<bool(const FieldID&d, Field&F, const RefPtr<CreativeArrayBase>&CAB, const RefPtr<FragmentID>&fid)>;
 
 
        int     iterate_all(const iterate_all_t&f) const
        {
                return  iterate( [&f](const FieldID&theFieldID, Field&theField) -> bool
                {
                        theField.iterate( [&f,&theFieldID,&theField](const RefPtr<FragmentID>&fid,
                                                                     const RefPtr<CreativeArrayBase>&CAB)
                        {
                                return f( theFieldID, theField, CAB, fid);
                        }
                        );
                        return true;
                }
                );
        }
 
        int     iterate(const iterate_all_t&f) const
        {
                return  iterate_all(f);
        }
 
 
        template <class Functor>
        [[deprecated("Use iterate_all() with functor instead")]]
        int     Iterate_all(const Functor&F) const
        {
/*
                struct  MyF : Iterator
                {
                        const Functor&f;
                        MyF(const Functor&F)
                        : f(F)
                        {}
 
                        bool    apply(const FieldID&theFieldID, const Field&theField) override
                        {
                                theField.iterate_fragments( [this, &theFieldID,&theField](const RefPtr<FragmentID>&fid,
                                                                                          const RefPtr<CreativeArrayBase>&CAB)
                                {
                                        f( theFieldID, theField, CAB, fid);
                                        return true;
                                }
                                );
                                return true;
                        }
                }
                mf(F);
                return iterate(mf);
*/
                return  iterate( [&F](const FieldID&theFieldID, const Field&theField)
                        {
                                theField.iterate( [&F,&theFieldID,&theField](const RefPtr<FragmentID>&fid,
                                                                             const RefPtr<CreativeArrayBase>&CAB)
                                {
                                        return F( theFieldID, theField, CAB, fid);
                                }
                                );
                                return true;
                        }
                        );
        }
 
 
        Dims_t  Dims() const;
 
        DEPRECATED("Use Dims() or getSize() instead",
                   Dims_t rank() const)
        {
                return Dims();
        }
 
 
        RefPtr<FragmentIDCollection> getFragmentIDCollection() const override;
 
        memsize_t getMemoryUsage(memsize_t&UsedMemory, memsize_t&WantedMemory) const;
 
 
        void    Speak(int indent=0, int maxindent=-1) const;
 
        string  xml() const;
 
        void createLinkedFields( const Representation& linked_from );
};
 
 
extern  GRID_API
int     pullFragments(Representation&Dst, const RefPtr<FragmentID>&DstID,
                      const Representation&src, const RefPtr<FragmentID>&SrcID,
                      const RefPtr<MemCore::ChunkBase>&Indirection,
                      const DynamicSize&DestSize);
 
 
 
template <>
class   Iterator<Field> : public Representation::Iterator
{
};
 
 
template <class Functor>
inline int      RepresentationMap::iterate_all(const Functor&F) const
{
        struct  MyF : ConstIterator
        {
                const Functor&f;
                MyF(const Functor&F)
                : f(F)
                {}
 
                bool    apply(const Representer&theRepresenter, const Representation&R) override
                {
                        R.iterate_all( [this, &theRepresenter, &R]
                                       (const FieldID&theFieldID, const Field&F,
                                        const RefPtr<CreativeArrayBase>&CAB, const RefPtr<FragmentID>&fid)
                        {
                                f(theRepresenter,R, theFieldID, F, CAB, fid);
                                return true;
                        }
                        );
                        return true;
                }
        }
        mf(F);
        return iterate(mf);
}
 
template <class Functor>
inline int operator<<=(const Representation&R, const Functor&F)
{
        return R.iterate(F);
}
 
template <class Functor>
inline int operator<<=(const RefPtr<Representation>&R, const Functor&F)
{
        if (!R)
                return 0;
 
        return R->iterate(F);
}
 
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_GRID_REPRESENTATION_HPP */