Atlas.hpp

#ifndef __FIBER_GRID_ATLAS_HPP
#define __FIBER_GRID_ATLAS_HPP "Created 27.02.2001 21:42:27 by werner"
 
#include "GridAPI.h"
#include "Chart.hpp"
#include "Transformation.hpp"
 
namespace Fiber
{
        using std::set;
        using std::unordered_set;
 
class   GRID_API GlobalCharts : public ReferenceBase<GlobalCharts>
                              , public Intercube
{
public:
        typedef MemCore::typemap<RefPtr<ChartIDList> > ChartDomain_t;
        ChartDomain_t ChartDomain;
 
        GlobalCharts();
 
        RefPtr<ChartIDList> operator()(const type_info&) const;
 
        ChartIDList&operator[](const type_info&);
 
        RefPtr<ChartID> mkChartID(const type_info&ti, const string&name)
        {
                return (*this)[ ti ][ name ];
        }
 
        RefPtr<ChartID> mkChartID(const type_info&ti, const string&name, uint16_t epsg_code)
        {
        RefPtr<ChartID> C = (*this)[ ti ][ name ];
                C->epsg_code = epsg_code;
                return C;
        }
 
        bool    insertSharedChartID(const type_info&ti, const RefPtr<ChartID>&ExistingChartID);
        bool    insertSharedChart(const RefPtr<Chart>&ExistingChart);
 
 
        RefPtr<ChartID> findChartID(const string&name) const;
 
        struct  GRID_API Iterator
        {
                virtual ~Iterator() = 0;
                virtual bool apply(const type_info&ti, const RefPtr<ChartID>&ExistingChartID) = 0;
        };
 
        int     iterate(Iterator&It) const;
 
        unsigned        iterate(const type_info&ti, const std::function<bool(const type_info&ti, const ChartID&)>&iterator) const;
        unsigned        type_iterate(const type_info&ti, const std::function<bool(const ChartID&)>&iterator) const;
        unsigned        epsg_iterate(uint16_t epsg_code, const std::function<bool(const ChartID&)>&iterator) const;
 
        RefPtr<ChartID> findEPSG(uint16_t epsg_code) const;
};
 
 
class   Skeleton;
class   FieldID;
 
 
class   GRID_API Transformator : public ReferenceBase<Transformator>
{
public:
        Transformator();
 
        ~Transformator();
 
        struct  FieldTransformator
        {
                RefPtr<Transformation>  TransformationCallback;
                RefPtr<Field>           Sourcefield, SourcePositions;
        };
 
        virtual FieldTransformator
                get(const ChartID&TargetChartName, const Skeleton&FieldContainer, const FieldID&Fieldname) = 0;
};
 
 
class   GRID_API Atlas : public ReferenceBase<Atlas>
{
public:
        typedef set<RefPtr<Chart> >     Atlas_t;
        Atlas_t                         ChartSet;
        RefPtr<GlobalCharts>            GlobalAtlas;
 
        using   Transformators = unordered_set<WeakPtr<Transformator>>;
 
        using   TransformationsIntoNamedChart = std::unordered_map<string, RefPtr<Transformation>>;
        using   TransformationsByName         = std::unordered_map<string, TransformationsIntoNamedChart>;
 
                TransformationsByName           LocalTransformations;
 
        struct  Globals
        {
                TransformationsByName   myTransformations;
                Transformators          myTransformators;
        };
 
 
static  Globals& myGlobals();
 
static          TransformationsByName&          GlobalTransformations()
        {
                return myGlobals().myTransformations;
        }
 
static          Transformators&         GlobalTransformators()
        {
                return myGlobals().myTransformators;
        }
 
public:
        Atlas(const RefPtr<GlobalCharts>&GA);
 
        const RefPtr<GlobalCharts>&getGlobalAtlas() const
        {
                return GlobalAtlas;
        }
 
        RefPtr<ChartIDList> operator()(const type_info&ti) const
        {
                if (!GlobalAtlas)
                        return NullPtr();
 
                return (*GlobalAtlas)( ti );
        }
 
        ChartIDList&operator[](const type_info&);
 
        RefPtr<ChartID> mkChartID(const type_info&ti, const string&name)
        {
                return (*this)[ ti ][ name ];
        }
 
        RefPtr<ChartID> mkChartID(const type_info&ti, const string&name, uint16_t epsg_code)
        {
        RefPtr<ChartID> C = (*this)[ ti ][ name ];
                C->epsg_code = epsg_code;
                return C;
        }
 
 
        void    insertChart(const RefPtr<Chart>&newChart);
 
        bool    insertSharedChart(const RefPtr<Chart>&ExistingChart);
 
 
//      RefPtr<Chart> operator()(const string&) const;
        RefPtr<Chart> operator()(const RefPtr<ChartID>&) const;
 
        RefPtr<Chart> operator()(unsigned epsg_code) const;
 
        RefPtr<Chart> operator()(const RefPtr<Chart>&C) const
        {
                if (!C)
                        return NullPtr();
 
                return (*this)( C->ID() );
        }
 
 
     // RefPtr<Chart> operator()(const type_info&) const;
 
//      RefPtr<Chart> operator[](const type_info&);
 
//      RefPtr<Chart> getGlobalChart(const type_info&, const string&);
//      RefPtr<Chart> newChart(const RefPtr<Chart>&);
 
/*
        template <class CoordinateSystem>
        struct CreateChart
        {
        static  RefPtr<Chart> global(GridAtlas&myGridAtlas)
                {
                        //      GridAtlas::inited += CoordinateMap<CoordinateSystem>::initialized;
                        return myGridAtlas[ typeid(CoordinateSystem) ];
                }
        };
*/
 
        RefPtr<Transformation>  getTransformation(const Chart&DestinationChart, const Chart&SourceChart) const;
 
        std::tuple<RefPtr<Atlas>, RefPtr<Chart>>
                getTransformation(const Chart&DestinationChart) const
        {
                return { self(), DestinationChart.self() };
        }
 
        friend RefPtr<Transformation> operator>>(const std::tuple<RefPtr<Atlas>, RefPtr<Chart>>&L, const Chart&SourceChart)
        {
                if (!std::get<0>(L)) return nullptr;
                if (!std::get<1>(L)) return nullptr;
                return std::get<0>(L)->getTransformation( *std::get<1>(L), SourceChart);
        }
 
static  RefPtr<Transformation>
                getGlobalTransformation(const Chart&DestinationChart, const Chart&SourceChart);
 
};
 
/*
template <class CoordinateSystem>
struct GridAtlas::CreateChart<CoordinateMap<CoordinateSystem> >
{
static  RefPtr<Chart> global(GridAtlas&myGridAtlas)
        {
                GridAtlas::inited += CoordinateMap<CoordinateSystem>::initialized;
                return myGridAtlas[ typeid(CoordinateSystem) ];
        }
};
*/
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_GRID_ATLAS_HPP */