RepresentationMap.hpp

#ifndef __FIBER_GRID_REPRESENTATIONMAP_HPP
#define __FIBER_GRID_REPRESENTATIONMAP_HPP "Created 16.07.2009 19:45:27 by werner"
 
#include "GridAPI.h"
#include <fiber/field/Field.hpp>
#include "FieldID.hpp"
#include <memcore/TypeInfo.hpp>
#include <set>
#include <list>
#include <mutex>
 
#include "FiberSpace.hpp"
#include <fiber/field/BaseSpace.hpp>
 
namespace Fiber
{
        using MemCore::WeakPtr;
        using MemCore::NullPtr;
        using std::set;
        using std::list;
 
typedef WeakPtr<BaseSpace> Representer;
 
class   GRID_API Representation;
 
typedef WeakPtr<Representation, typename BaseSpaceDependency::reference_domain_t> WeakPtrRepresentation_t;
typedef RefPtr<Representation , typename BaseSpaceDependency::reference_domain_t> RefPtrRepresentation_t;
 
 
class   GRID_API RepresentationMap : public FragmentIDCollectionProvider
{
        typedef map<Representer, RefPtrRepresentation_t> Representations_t;
        Representations_t       Representations;
 
mutable std::recursive_mutex    RepresentationsMutex;
 
public:
 
        RepresentationMap();
        ~RepresentationMap();
 
        void    clear();
 
        RefPtrRepresentation_t makeRepresentation(const Representer&D);
 
        Representation&operator[](const Representer&D);
 
        Representation&operator[](const BaseSpace&D)
        {
        const Representer&R = D.self();
                return (*this)[R];
        }
 
        RefPtrRepresentation_t findRepresentation(const Representer&D) const;
 
        RefPtrRepresentation_t findRepresentation(const BaseSpace&D);
 
        RefPtrRepresentation_t operator()(const Representer&D) const;
 
        RefPtrRepresentation_t operator()(const BaseSpace&D);
 
        int     DataRank() const;
 
        RefPtr<SizeInterface> getSize() const;
        RefPtr<SizeInterface> getFragmentSize(const RefPtr<FragmentID>&Fid) const;
 
 
        int     size() const;
 
        int     getNumberOfRepresentations() const
        {
                return size();
        }
 
        RefPtr<FragmentIDCollection> getFragmentIDCollection() const override;
 
        std::tuple<Representer, RefPtrRepresentation_t,	RefPtr<FragmentIDCollection>>
                getFragmentIDCollectionRepresentation() const;
 
        RefPtr<FragmentID>      findFragmentIDByName(const std::string&FragmentName) const
        {
                if (RefPtr<FragmentIDCollection> FIC = getFragmentIDCollection() )
                        return FIC->findFragmentIDByName(FragmentName);
 
                return nullptr;
        }
 
        DynamicSize getFragmentLayout() const;
 
        class   GRID_API ConstIterator
        {
        public:
                virtual ~ConstIterator();
 
                virtual bool apply(const Representer&d, const Representation&R) = 0;
        };
 
        class   GRID_API Iterator
        {
        public:
                virtual ~Iterator();
 
                virtual bool apply(const Representer&d, Representation&R) = 0;
        };
 
        int     iterate(ConstIterator&) const;
 
        int     iterate(Iterator&);
 
        int     iterate(const std::function<bool(const Representer&, const Representation&)>&F) const;
 
        int     iterate(const std::function<bool(const Representer&, Representation&)>&F);
 
        template <class Functor>
        int     iterate_representations(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
                        {
                                return f(theRepresenter,R);
                        }
                }
                mf(F);
                return iterate(mf);
        }
 
        template <class Functor>
        inline int      iterate_all(const Functor&F) const;
 
        int     getMemoryUsage(memsize_t&UsedMemory, memsize_t&WantedMemory) const;
 
 
        void    Speak(int indent=0, int maxindent=-1) const;
 
        string  xml() const;
 
 
#ifdef  __ALLOW_DEPRECATED_FUNCTIONS
 
        [[deprecated("Try to avoid code that relies on a unique representation")]]
        RefPtrRepresentation_t UniqueRepresentation() const;
 
        [[deprecated("Try to avoid relying on a first representation as the result is quite random")]]
        RefPtrRepresentation_t FirstRepresentation() const;
#endif
 
};
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_GRID_REPRESENTATIONMAP_HPP */