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"

namespace Fiber
{
        using std::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 ];
        }
};

class   GRID_API Atlas : public ReferenceBase<Atlas>
{
public:
        typedef set<RefPtr<Chart> >     Atlas_t;
        Atlas_t                         ChartSet;
        RefPtr<GlobalCharts>            GlobalAtlas;

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 ];
        }

        
        void insertChart(const RefPtr<Chart>&newChart);


//      RefPtr<Chart> operator()(const string&) const;
        RefPtr<Chart> operator()(const RefPtr<ChartID>&) 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) ];
                }
        };
*/
};

/*
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 */