Skeleton.hpp

#ifndef __FIBER_GRID_SKELETON_HPP
#define __FIBER_GRID_SKELETON_HPP "Created 27.02.2001 21:42:27 by werner"
 
#include "GridAPI.h"
#include <fiber/field/Field.hpp>
#include <memcore/TypeInfo.hpp>
#include <unordered_set>
 
#include "FieldID.hpp"
#include <fiber/field/BaseSpace.hpp>
#include "FiberSpace.hpp"
#include "Representation.hpp"
#include "Chart.hpp"
#include "Atlas.hpp"
#include "SkeletonID.hpp"
 
namespace Fiber
{
        using MemCore::WeakPtr;
 
class   GRID_API FieldRef;
class   GRID_API SkeletonMap;
 
struct  FragmentMetaIndirector : Interface<FragmentMetaIndirector>
{
        using   MetaInfoProvider_t = std::function<bool(CreativeArrayBase&targetCAB,
                                                        CreativeArrayBase&RelativeCAB,
                                                        const RefPtr<FragmentID>&fid,
                                                        CreativeArrayBase&SourceCAB,
                                                        const string&FieldName,
                                                        const Representer&WantRep)>;
 
        MetaInfoProvider_t provideMetaInfo = {};
 
        FragmentMetaIndirector(MetaInfoProvider_t theMetaInfo)
        : provideMetaInfo( std::move( theMetaInfo) )
        {}
};
 
template <size_t NumberOfFields>
inline  auto    getCreators(const std::array<RefPtr<Field>, NumberOfFields>&Fields, const RefPtr<FragmentID>&fID)
{
std::array<RefPtr<CreativeArrayBase>, NumberOfFields> Creators;
 
        for(size_t fieldNo = 0; fieldNo < NumberOfFields; fieldNo++)
        {
                if (auto F = Fields[fieldNo])
                        Creators[ fieldNo ] = F -> getCreator(fID);
        }
 
        return  Creators;
}
 
 
 
class   GRID_API Skeleton : public Fiber::BaseSpace
                          , public Fiber::RepresentationMap
                          , public Fiber::SkeletonID
                          , public SaveableAttributes
{
        Skeleton (const SkeletonID&SID);
 
        friend class SkeletonMap;
 
protected:
        using   RepresenterList_t = std::unordered_set<Representer>;
 
        ~Skeleton();
 
        RefPtr<Field>   getFieldRecursion(const Representer&R, const string&FieldName
                                          , const RefPtr<Atlas>&myAtlas
                                          , RepresenterList_t&SkipRepresenters );
 
 
 
template <is_field_identifier firstFieldIdentifier_t, is_field_identifier... FieldIdentifiers>
        void    getFieldsRecursion(const Representer&R,
                                   RefPtr<Field>*Rit,
                                   firstFieldIdentifier_t firstFieldIdentifier,
                                   FieldIdentifiers... theFieldIdentifiers)
        {
                *Rit = getField(R, firstFieldIdentifier);
 
                if constexpr (sizeof...(FieldIdentifiers) > 0)
                {
                        Rit++;
                        this->getFieldsRecursion(R, Rit, theFieldIdentifiers...);
                }
        }
 
 
public:
 
        Skeleton() = delete;
 
        Skeleton(const Skeleton&) = delete;
 
        void    operator=(const Skeleton&) = delete;
 
        void    clear();
 
        void    extremeUnction() override;
 
        using   RepresentationMap::operator();
        using   RepresentationMap::size;
        using   RepresentationMap::Iterator;
        using   RepresentationMap::iterate;
 
        using   RepresentationMap::getFragmentIDCollection;
 
        using   FieldIterator_t = Representation::const_iterator_t;
 
        Representation&         operator[](const Representer&D);
        RefPtr<Representation>  makeRepresentation(const Representer&D);
 
        Representation&operator[](const BaseSpace&D)
        {
        const Representer&R = D.self();
                return (*this)[R];
        }
 
 
        int     Dims() const override;
 
        RefPtr<Field>   createIndirectedField(const Representer&WantRep, const RefPtr<Field>&RelativeIndices,
                                              const string&FieldName, const RefPtr<Field>&SourceField,
                                              const RefPtr<Field>&SourcePositions);
 
        RefPtr<Field>   getField(const Representer&R, const RefPtr<FieldID>&Fid
                                 , const RefPtr<Atlas>&myAtlas = nullptr
                                 , const RepresenterList_t&SkipRepresenters = {} );
 
        RefPtr<Field>   getField(const Representer&R, const std::string&FieldName
                                 , const RefPtr<Atlas>&myAtlas = nullptr
                                 , const RepresenterList_t&SkipRepresenters = {});
 
        RefPtr<Field>   getPositions(const Representer&R)
        {
                return getField(R, FIBER_POSITIONS);
        }
 
        std::string     xml() const override;
 
        friend std::string to_string(const Skeleton&);
 
        std::string Name() const override
        {
                return SkeletonID::Name();
        }
 
        using   SkeletonExcluder = unordered_set<size_t>;
 
        unsigned        iterate_fields(const FieldIterator_t&F, SkeletonExcluder&SE) const;
 
        unsigned        iterate_fields(const FieldIterator_t&F) const
        {
        SkeletonExcluder SE;
                return iterate_fields(F, SE);
        }
 
 
        using   RepresentationFieldIterator_t = std::function<bool(const Representer&theRepresenter, const Representation&R, const FieldID&, const Field&)>;
 
        unsigned        iterate_fields(const RepresentationFieldIterator_t&F, SkeletonExcluder&SE) const;
 
        unsigned        iterate_fields(const RepresentationFieldIterator_t&F) const
        {
        SkeletonExcluder SE;
                return iterate_fields(F, SE);
        }
 
 
        template <is_field_identifier... FieldIdentifiers>
                auto    getFields(const Representer&R,
                                  FieldIdentifiers... theFieldIdentifiers)
        {
        std::array<RefPtr<Field>, sizeof...(FieldIdentifiers)> ResultFields;
                getFieldsRecursion(R, ResultFields.begin(), theFieldIdentifiers...);
                return  ResultFields;
        }
 
 
        template <is_field_identifier... FieldIdentifiers>
                auto    getFieldFragmentCreators(const Representer&R, const RefPtr<FragmentID>&fID,
                                                 FieldIdentifiers... theFieldIdentifiers)
        {
        const auto&F = getFields( R, theFieldIdentifiers...);
                return  getCreators(F, fID);
        }
};
 
using Topology = Skeleton;
 
using pSkeleton = RefPtr<Skeleton>;
 
typedef WeakPtr<Skeleton> wSkeleton;
 
 
class   GRID_API FieldRef
{
        RefPtr<Skeleton>        SkelPtr;
        RefPtr<FieldID>         Id;
        RefPtr<Atlas>           myGridAtlas;
        string                  fieldname;
 
public:
        FieldRef(const RefPtr<Skeleton>&S, const RefPtr<FieldID>&fid, const RefPtr<Atlas>&GA)
        : SkelPtr(S), Id(fid), myGridAtlas(GA)
        {}
 
        FieldRef(const RefPtr<Skeleton>&S, const string&fname, const RefPtr<Atlas>&GA)
        : SkelPtr(S), myGridAtlas(GA), fieldname(fname)
        {}
 
        ~FieldRef();
 
/*
        template <class CoordinateSystem, class TensorType>
                void operator=(const Tensor<CoordinateSystem, TensorType>&Value)
        {
        typedef Tensor<CoordinateSystem, TensorType> value_type;
        typedef MemArrayStorage<1, value_type, vector<value_type> > array_type;
 
        array_type*Data = new array_type(1);
                Data->myArray()[0] = Value;
 
        RefPtr<Field> myField = new Field();
                myField->setCreator( new MemCreativeArray(Data) );
 
//      RefPtr<Chart> C = CreateChart<CoordinateSystem>::global( (*myGridAtlas) );
//      Representation&Rep = (*SkelPtr)[C];
 
        Representation&Rep = SkeletonRepresentation<CoordinateSystem>::makeDefaultRepresentation(SkelPtr, myGridAtlas);
                if (!Id)
                {
                FieldID&Fid = Rep[fieldname];
                        Id = &Fid;
                }
 
                Rep[ Id ] = myField;
        }
*/
 
#if 0
        bool operator=(const double&Value)
        {
        typedef double value_type;
        typedef MemArrayStorage<1, value_type, vector<value_type> > array_type;
 
        array_type*Data = new array_type( MIndex(1) );
                Data->myArray()[0] = Value;
 
        RefPtr<Representation> Rep = SkelPtr->DefaultRepresentation();
                if (!Rep)
                        return false;
 
        RefPtr<Field> myField = new Field();
                myField->setCreator( new MemCreativeArray(Data) );
 
                if (!Id)
                {
                FieldID&Fid = (*Rep)[fieldname];
                        Id = &Fid;
                }
 
                (*Rep)[ Id ] = myField;
 
                return true;
        }
#endif
 
 
/*
        template <class CoordinateSystem, class real>
        void operator=(const Point<CoordinateSystem, real>&Vertex)
        {
        typedef Point<CoordinateSystem, real> value_type;
        typedef MemArrayStorage<1, value_type, vector<value_type> > array_type;
 
//      RefPtr<Chart> C = CreateChart<CoordinateSystem>::global( (*myGridAtlas) );
 
//              printf("Got chart named '%s' for storing points as %s (of %s)...\n", C->ID().c_str(), typeid(real).name(), typeid(Vertex).name() );
 
//      Representation&Rep = (*SkelPtr)[C];
 
        Representation&Rep = SkeletonRepresentation<CoordinateSystem>::makeDefaultRepresentation(SkelPtr, myGridAtlas);
 
        array_type*Data = new array_type( MIndex(1) );
                Data->myArray()[0] = Vertex;
 
        RefPtr<Field> myField = new Field();
                myField->setCreator( new MemCreativeArray(Data) );
 
                if (!Id)
                {
                FieldID&Fid = Rep[fieldname];
                        Id = &Fid;
                }
 
                Rep[ Id ] = myField;
        }
*/
};
 
 
template <>
class   Iterator<Representation> : public Skeleton::RepresentationMap::Iterator
{
};
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_GRID_SKELETON_HPP */