SkeletonMap.hpp

#ifndef __FIBER_SKELETONMAP_HPP
#define __FIBER_SKELETONMAP_HPP "Created 14.04.2014 16:37:27 by werner"
 
#include "GridAPI.h"
#include <fiber/field/Field.hpp>
#include <memcore/TypeInfo.hpp>
 
#include "FieldID.hpp"
#include "FiberSpace.hpp"
#include "Representation.hpp"
#include "Skeleton.hpp"
 
namespace Fiber
{
        using MemCore::WeakPtr;
        using MemCore::NullPtr;
        using std::set;
        using std::list;
 
 
 
class   GRID_API ConstSkeletonIterator
{
public:
        virtual ~ConstSkeletonIterator();
 
        virtual bool apply(const SkeletonID&id, const Skeleton&S) = 0;
};
 
 
class   GRID_API SkeletonIterator
{
public:
        virtual ~SkeletonIterator();
 
        virtual bool apply(const SkeletonID&id, Skeleton&S) = 0;
};
 
 
//typedef std::pair<SkeletonID, RefPtr<Skeleton> > SkeletonInfo;
 
 
struct  SkeletonPtrHash : std::hash<Skeleton*>
{
        size_t operator()(const RefPtr<Skeleton>&S) const
        {
                return std::hash<Skeleton*>::operator()(S.rawptr());
        }
};
 
struct  SkeletonPtrEqual
{
        bool    operator()(const RefPtr<Skeleton>&A, const RefPtr<Skeleton>&B) const
        {
                if (A == B) return true;
                if (!A)     return false;
                if (!B)     return false;
 
                return *A == *B;
        }
};
 
 
class   GRID_API SkeletonMap : public OwnerOf<BaseSpace>
{
//      typedef std::unordered_set<RefPtr<Skeleton>, SkeletonPtrHash, SkeletonPtrEqual > Skeletons_t;
//      typedef std::map<SkeletonID, RefPtr<Skeleton> > Skeletons_t;
 
public:
 
        typedef std::list<RefPtr<Skeleton> > Skeletons_t;
        Skeletons_t     Skeletons;
 
        SkeletonMap();
 
protected:
        ~SkeletonMap();
 
        void extremeUnction() override;
 
public:
 
        RefPtr<Skeleton>        findVertices(int TotalRefinement = -1) const;
 
        RefPtr<Skeleton>        getVerticesInfo(int TotalRefinement = -1) const;
 
        RefPtr<Skeleton>        getEdgeInfo(int TotalRefinement = -1) const;
 
        RefPtr<Skeleton>        getFaceInfo(int TotalRefinement = -1) const;
 
        double NumberOfHoles(int TotalRefinement = -1) const;
 
        Skeleton& makeVertices(int dims);
 
 
        Skeleton        &operator[](const SkeletonID&Sid);
 
        RefPtr<Skeleton> getSkeleton(const SkeletonID&Sid) const;
 
        RefPtr<Skeleton> operator()(const SkeletonID&Sid) const
        {
                return getSkeleton(Sid);
        }
 
 
        RefPtr<Representation> CellsAsVertices(int dims) const;
 
//      RefPtr<Skeleton> getFragmentSkeleton(const SkeletonID&Sid) const;
 
//      [[deprecated("Use FragmentTopology::findHighestDimensionalRepresentation() instead")]]
//      RefPtr<Representation> getFragmentRepresentation(const SkeletonID&Sid) const;
 
//      RefPtr<Field> getFragmentTopology(const SkeletonID&Sid) const;
 
 
        int     MinLevel(int IndexDepth=0) const;
 
        int     MaxLevel(int IndexDepth=0) const;
 
        RefPtr<Skeleton> findMaxHomogenousRefinement(int IndexDepth) const;
 
        bool    replaceSkeletonID( const SkeletonID&old_id, const SkeletonID&new_id );
 
        RefPtr<Skeleton> findIsotropicRefinementFactor(int Factor, int IndexDepth) const;
 
        typedef SkeletonIterator Iterator;
 
        int     iterate(ConstSkeletonIterator&) const;
 
        int     iterate(SkeletonIterator&);
 
 
        int     iterate(std::function<bool(const SkeletonID&id,       Skeleton&S)>) const;
        int     iterate_const(std::function<bool(const SkeletonID&id, const Skeleton&S)>) const;
 
 
        template <class SkeletonFunctor>
        int     Iterate(const SkeletonFunctor&F) const
        {
                struct  I : ConstSkeletonIterator
                {
                        const SkeletonFunctor&F;
                        I(const SkeletonFunctor&pF)
                        : F(pF)
                        {}
 
                        bool apply(const SkeletonID&id, const Skeleton&S) override
                        {
                                return F(id, S);
                        }
                }
                myI(F);
                return iterate(myI);
        }
 
        template <class Functor>
        int     iterate_all(const Functor&F) const
        {
                struct  I : ConstSkeletonIterator
                {
                        const Functor&F;
                        I(const Functor&pF)
                        : F(pF)
                        {}
 
                        bool    apply(const SkeletonID&id, const Skeleton&S) override
                        {
                                S.iterate_all( [this, &S](const Representer&theRepresenter, const Representation&R,
                                                          const FieldID&theFieldID, const Field&theField,
                                                          const RefPtr<CreativeArrayBase>&CAB, const RefPtr<FragmentID>&fid)
                                {
                                        F( S, theRepresenter, R,
                                           theFieldID, theField,
                                           CAB, fid );
                                }
                                );
                                return true;
                        }
                }
                myI(F);
                return iterate(myI);
        }
 
 
        int     nSkeletons() const;
 
        int     nSkeletons(int IndexDepth) const;
 
 
 
#if 0 // method bodies not implemented
        RefPtr<Field> getField(const RefPtr<ChartID>&theChartID,
                               const string&fieldname, const RefPtr<Skeleton>&theSkeleton) const;
        RefPtr<Field> getVertexField(const RefPtr<ChartID>&theChartID,
                                     const string&fieldname) const
        {
                return getField(theChartID, fieldname, findVertices() );
        }
 
        RefPtr<Field> getPositions(const RefPtr<ChartID>&theChartID,
                                   const RefPtr<Skeleton>&theSkeleton) const;
 
 
        RefPtr<Field> getVertexPositions(const RefPtr<ChartID>&theChartID) const;
 
 
        RefPtr<Representation> getRepresentation(const RefPtr<ChartID>&theChartID,
                                                 const RefPtr<Skeleton>&theSkeleton) const;
 
        RefPtr<Representation> getVertexRepresentation(const RefPtr<ChartID>&theChartID) const
        {
                return getRepresentation(theChartID, findVertices() );
        }
 
#endif
 
        int     getMemoryUsage(memsize_t&UsedMemory, memsize_t&WantedMemory) const;
 
 
        void    Speak(int indent=0, int maxindent=-1) const;
 
 
        string  xml() const;
};
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_SKELETONMAP_HPP */