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 <fiber/field/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::reference_domain_t>  ChartPtr;
typedef RefPtr <Chart, BaseSpace::reference_domain_t>  ChartRefPtr;
 
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 ChartRefPtr create(const RefPtr<ChartID>&mID) = 0;
        virtual const type_info&getChartType() const = 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();
 
        const RefPtr<ChartID>&ID() const throw()
        {
                return myID;
        }
 
        const RefPtr<ChartID>&getId() const throw()
        {
                return ID();
        }
 
        string Name() const override
        {
                if (myID)
                        return myID->Name();
 
                return string();
        }
 
        string getName() const
        {
                return Name();
        }
 
        int dims() const
        {
                if (!myCreator) return 0;
                return myCreator->dims;
        }
 
        int Dims() const override
        {
                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)
        {
                if (!myCreator) return NullPtr();
                return myCreator->create( mID );
        }
 
        const type_info&getChartType() const
        {
                if (!myCreator) return typeid(void);
                return myCreator->getChartType();
        }
 
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;
 
 
        string xml() const override
        {
        string  retval;
                retval += "         <CHART>\n";
                retval += "          <NAME>" + Name() + "</NAME>\n";
 
                if (domain_name() )
                {
                        retval += "          <DOMAIN>";
                        retval += domain_name();
                        retval += "</DOMAIN>\n";
                }
 
        int     d = Dims();
                for(int i = 0; i<d; i++)
                {
                        retval += "          <COMPONENT>";
                        retval += component_name(i);
                        retval += "</COMPONENT>\n";
                }
 
                retval += "         </CHART>\n";
                return retval;
        }
 
};
 
 
 
template <class ChartType>
class   ChartCreator : public ChartCreatorBase
{
public:
        ChartCreator(int theDims,
                     const char*theDomain_name,
                     const char**theComponent_names)
        : ChartCreatorBase(theDims, theDomain_name, theComponent_names, typeid(ChartType) )
        {}
 
        RefPtr<Chart> create(const RefPtr<ChartID>&ID) override
        {
                return new ChartType( self(), ID );
        }
 
        const type_info&getChartType() const override
        {
                return typeid(ChartType);
        }
};
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_GRID_CHART_HPP */