TypeRegistry.hpp

//
// $Id: TypeRegistry.hpp,v 1.19 2008/03/19 21:21:45 werner Exp $
//
#ifndef __FIBER_HDF5_TYPEREGISTRY_HPP
#define __FIBER_HDF5_TYPEREGISTRY_HPP "Created 27.02.2001 21:42:27 by werner"

#include "FBhdf5API.h"
#include "init.hpp"
#include <memcore/RefPtr.hpp>
#include <memcore/typemap.hpp>
#include <field/FiberType.hpp>
#include <F5/F5Bchart.h>
#include <F5/F5F.h>

namespace Fiber
{
        using namespace MemCore;

class HDF5BUNDLE_API H5ID : public Interface<H5ID>
{
        hid_t   hid;

public:
        typedef typemap<string>  ChartNameMap_t;
        typedef std::map<string, TypeInfo> ChartTypeMap_t;

static  ChartNameMap_t&ChartMap();
static  ChartTypeMap_t&ChartType();

static  void insert(const char*chartname, const type_info&charttype)
        {
                ChartMap() [ charttype ] = chartname;
                ChartType().insert(
                        ChartTypeMap_t::value_type(chartname,
                                                   TypeInfo(charttype) ) );
        }

template <class ChartDomain>
        struct  Domain
        {
        static  void associate(const char*chartname)
                {
                        insert(chartname, typeid(ChartDomain) );
                }

        static  string name()
                {
                ChartNameMap_t::const_iterator cit = ChartMap().find( typeid(ChartDomain) ); 
                        if (cit == ChartMap().end() )
                                return "void"; 

                        return cit->second;
                }
        };



static  TypeInfo getChartType(hid_t type_id);

        H5ID(hid_t hid);
        ~H5ID();

        hid_t getId() const
        {
                return hid;
        } 

static  RefPtr<FiberTypeBase> find(hid_t type_id);

static  RefPtr<FiberTypeBase> find(F5Path*field);


static  RefPtr<H5ID> retrieve(const RefPtr<FiberTypeBase>&FTB); 


static  void printTypeInfo(hid_t id);

};


class HDF5BUNDLE_API F5Domain : public Interface<F5Domain>
{
public:
        ChartDomain_IDs*ChartDomain;

        F5Domain(ChartDomain_IDs*CD)
        : ChartDomain(CD)
        {}
};


template <class Type>
struct  HDF5TypeAction : TypeAction
{
        typedef FiberType<Type> FiberType_t;

static  hid_t getId()
        {
        const FiberTypeBase&FTB = FiberType_t::getFiberType(); 
        RefPtr<TypeAction> TA = find( FTB.self() );
                if (!TA)
                        return -1; 

        RefPtr<H5ID> Hid = interface_cast<H5ID>(TA); 
                if (!Hid)
                        return -1; 

                return Hid->getId(); 
        }

static  bool    registerHID(hid_t type_id, const RefPtr<F5Domain>&f = NullPtr() )
        {
        const FiberTypeBase&FTB = FiberType_t::getFiberType(); 

        RefPtr<TypeAction> TA = TypeAction::create( FTB.self() );

                if (!TA)
                        return false; 

                printf("TYPE %s --> HDF5 ID %d\n", Typename(FTB.getType()).c_str(), type_id); 
                assert(type_id>0); 
                if ( H5Tget_size(type_id) != FTB.mem_size() )
                {
                        printf("HDF5TypeAction<>::registerHID() ERROR ==> HDF5 is %d bytes, memory is %d bytes, %s\n", 
                               (int)H5Tget_size(type_id), (int) FTB.mem_size(), FTB.description().c_str() ); 
                        assert ( H5Tget_size(type_id) == FTB.mem_size() );
                }


                TA->addInterface( new H5ID( type_id ) ); 

                if (f)
                        TA->addInterface( f ); 

                return true;
        }

static  RefPtr<F5Domain> makeDomainType(const char*coordnames[])
        {
        const FiberTypeBase&FTB = FiberType_t::getFiberType(); 

        RefPtr<TypeAction> TA = TypeAction::create( FTB.self() );

                if (!TA)
                        return NullPtr();

        enum { ELEMENTS = FiberType_t::FiberInfo_t::MULTIPLICITY }; 
        enum { RANK     = FiberType_t::FiberInfo_t::RANK         }; 

        typedef typename FiberType_t::FiberInfo_t::Chart_t DomainType;

        typedef typename FiberType_t::element_t element_t; 

        hid_t   ElementType = HDF5TypeAction<element_t>::getId(); 

        string Domainname = H5ID::Domain<DomainType>::name(); 

printf("TYPEREGISTRY: Domain [%s] Element Type is %x TODO: Create only ONCE global domain here\n", Domainname.c_str(), (int)ElementType); 

        ChartDomain_IDs*CD;
                switch( H5Tget_class(ElementType) )
                {
                case H5T_INTEGER:
                        printf("                 new integer domain ");
                        CD = F5B_new_global_int_domain(coordnames, ELEMENTS, Domainname.c_str(), F5_FORTRAN_ORDER, RANK); 
                        break;

                case H5T_FLOAT:
                        printf("                 new chart ");
                        CD = F5B_new_global_float_chart(coordnames, ELEMENTS, Domainname.c_str(), F5_FORTRAN_ORDER); 
                        break;
                default:
                        puts(__FILE__ "stuff not supported."); 
                        assert(0);
                }

        hsize_t ElementTypeSize = H5Tget_size(ElementType);

                puts(ElementTypeSize==8?"(double, 64bit precision)":"(single, 32bit or less precision)");

        hid_t   type_id  = (ElementTypeSize==8)?CD->DoublePrecision.Point_hid_t:CD->SinglePrecision.Point_hid_t;
                TA->addInterface( new H5ID( type_id ) ); 


        RefPtr<F5Domain> f = new F5Domain( CD ); 
                TA->addInterface( f );

                return f;
        }


static  RefPtr<F5Domain> makeDomainType()
        {
        enum { ELEMENTS = FiberType_t::FiberInfo_t::MULTIPLICITY }; 

        const char*coordnames[ELEMENTS]; 
                for(int i=0; i<ELEMENTS; i++)
                {
                        coordnames[i] = Type::coordinate_name(i);
                }
                return makeDomainType(coordnames);
        }

static  bool    registerCellType(const char*F5DomainName)
        {
                H5ID::Domain<Type>::associate( F5DomainName ); 
                return makeDomainType();
        }
};



/*
template <class PointType>
struct  HDF5DomainAction : TypeAction
{
        typedef FiberType<PointType> FiberPointType_t;

        typedef typename PointType::Base_t Coordinates_t;

        typedef typename Coordinates_t::Metric Metric_t;


static  RefPtr<F5Domain> makeDomainType(const char*coordnames[])
        {
        const FiberTypeBase&FTB = FiberPointType_t::getFiberType(); 

        RefPtr<TypeAction> TA = TypeAction::create( FTB.self() );

                if (!TA)
                        return NullPtr();

        enum { ELEMENTS = FiberPointType_t::FiberInfo_t::MULTIPLICITY }; 
        enum { RANK     = FiberPointType_t::FiberInfo_t::RANK         }; 

        typedef typename FiberPointType_t::FiberInfo_t::Chart_t DomainType;

        typedef typename FiberPointType_t::element_t element_t; 

        hid_t   ElementType = HDF5TypeAction<element_t>::getId(); 

        string Domainname = H5ID::Domain<DomainType>::name(); 

//printf("TYPEREGISTRY: Domain [%s] Element Type is %x\n", Domainname.c_str(), (int)ElementType);

        ChartDomain_IDs*CD = F5B_new_global_domain(coordnames, ELEMENTS, ElementType, Domainname.c_str(), F5_FORTRAN_ORDER, RANK); 

        hid_t   type_id  = CD->Point_hid_t;
                TA->addInterface( new H5ID( type_id ) ); 

        RefPtr<F5Domain> f = new F5Domain( CD ); 
                TA->addInterface( f ); 

                return f;
        }


static  RefPtr<F5Domain> makeDomainType()
        {
        enum { ELEMENTS = FiberPointType_t::FiberInfo_t::MULTIPLICITY }; 

        const char*coordnames[ELEMENTS]; 
                for(int i=0; i<ELEMENTS; i++)
                {
                        coordnames[i] = PointType::coordinate_name(i);
                }
                return makeDomainType(coordnames);
        }
};
*/



} /* namespace Fiber */ 

#endif /* __FIBER_HDF5_TYPEREGISTRY_HPP */