Chart.hpp

#ifndef __FIBER_GRID_CHART_HPP
#define __FIBER_GRID_CHART_HPP "Created 27.02.2001 21:42:27 by werner"

#include "GridAPI.h"
//#include <field/MemArrayRegistry.hpp>
#include "BaseSpace.hpp"
#include "Transformation.hpp"
#include "ChartID.hpp"

namespace Fiber
{
        using MemCore::WeakPtr;
        using MemCore::NullPtr;
        using std::set;
        using std::list;

        class   GRID_API Chart;

        class   GRID_API ChartCreatorBase;

typedef WeakPtr<Chart, BaseSpace>  ChartPtr;

class   Tensortype
{
public:
        enum type
        {
                SCALAR,
                POSITIONS,
                TENSOR,
                CHRISTOFFELS,
                PSEUDOSCALAR
        };
        int     upper, lower;
};


class   GRID_API ChartCreatorBase : public ReferenceBase<ChartCreatorBase>
{
public: const int dims;
        const char*domain_name;
        const char**component_names;

        ChartCreatorBase(int dims,
                         const char*domain_name,
                         const char**component_names,
                         const type_info&);

        ~ChartCreatorBase();

        virtual RefPtr<Chart> create(const RefPtr<ChartID>&mID) = 0;
};


class   GRID_API Chart : public BaseSpace
{
        map<ChartPtr, RefPtr<Transformation> > Transformations;

        RefPtr<ChartID> myID;

        WeakPtr<ChartCreatorBase> myCreator;

public:

        Chart(const WeakPtr<ChartCreatorBase>&MyCreator, const RefPtr<ChartID>&mID)
        : myID( mID )
        , myCreator( MyCreator )
        {}

        ~Chart();

        RefPtr<ChartID> ID() const
        {
                return myID;
        }

        string Name() const
        {
                if (myID)
                        return myID->Name(); 

                return string();
        }

        int dims() const 
        {
                if (!myCreator) return 0;
                return myCreator->dims;
        }

        override int Dims() const 
        {
                return dims();
        }

        const char*component_name(int i) const
        {
                if (i<0) return 0; 
                if (i>=dims() ) return 0; 
                if (!myCreator) return 0;

                return myCreator->component_names[i];
        }

        const char*domain_name() const 
        {
                if (!myCreator) return 0;
                return myCreator->domain_name;
        }


        RefPtr<Chart> create(const RefPtr<ChartID>&mID) 
        {
                return myCreator->create( mID );
        }

static  RefPtr<Chart> create(const type_info&chart_type, const RefPtr<ChartID>&mID);

        virtual RefPtr<Field> makeField(const type_info&base_type, const Tensortype&t) = 0;
};



template <class ChartType>
class   ChartCreator : public ChartCreatorBase
{
public:
        ChartCreator(int dims,
                     const char*domain_name,
                     const char**component_names)
        : ChartCreatorBase(dims, domain_name, component_names, typeid(ChartType) )
        {}

        override RefPtr<Chart> create(const RefPtr<ChartID>&ID)
        {
                return new ChartType( self(), ID );
        }
};


} /* namespace Fiber */ 

#endif /* __FIBER_GRID_CHART_HPP */