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 "FiberIOHDF5DllApi.h"
#include <memcore/RefPtr.hpp>
#include <memcore/typemap.hpp>
#include <field/FiberType.hpp>
#include <F5/F5Bchart.h>
#include <F5/F5F.h>
 
#include "H5Globals.hpp"
#include "F5Domain.hpp"
 
namespace Fiber
{
        using namespace MemCore;
 
class   FiberIOHDF5_API H5ID : public H5DataType, public Intercube
{
public:
        typedef typemap<string>  ChartNameMap_t;
        typedef std::map<string, TypeInfo> ChartTypeMap_t;
 
static  ChartNameMap_t&ChartMap()
        {
                return H5Globals::theGlobals().ChartMap;
        }
 
static  ChartTypeMap_t&ChartType()
        {
                return H5Globals::theGlobals().ChartType;
        }
 
static  H5Globals::TypeRegistry_t&TypeRegistry()
        {
                return H5Globals::theGlobals().TypeRegistry;
        }
 
static  RefPtr<H5ID> find(const std::type_info&);
 
static  RefPtr<H5ID> find(const FiberTypeIndex&FTI)
        {
                return TypeRegistry().find(FTI);
        }
 
static  RefPtr<H5ID> find(const RefPtr<FiberTypeBase>&FTB)
        {
                if (!FTB) return nullptr;
                return find( FTB->getFiberTypeIndex() );
        }
 
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   FiberIOHDF5_API H5NativeTypeID : public H5ID
{
public:
        H5NativeTypeID(hid_t hid)
        : H5ID(hid)
        {}
 
        ~H5NativeTypeID();
};
 
template <class Type>
struct  HDF5TypeAction
{
        typedef FiberType<Type> FiberType_t;
 
static  hid_t getId()
        {
        auto    FTI = FiberType_t::getFiberTypeIndex();
        RefPtr<H5ID> Hid = H5ID::find(FTI);
                if (!Hid)
                        return -1;
 
                return Hid->getId();
        }
 
static  bool    registerHID(hid_t type_id, const RefPtr<F5Domain>&f = NullPtr(), bool isNative = false )
        {
        RefPtr<FiberTypeBase> FTB = FiberType_t::getFiberType();
                if (!FTB)
                {
                        return false;
                }
 
        RefPtr<H5DataType>&theH5ID = H5ID::TypeRegistry()[ FTB->getFiberTypeIndex() ];
                if (theH5ID)
                {
                        Verbose(120) << "ALREADY REGISTERED TYPE "<< Typename(FTB->getType()) << " --> HDF5 ID " << type_id;
                        return true;
                }
 
                Verbose(120) << "TYPE "<< Typename(FTB->getType()) << " --> HDF5 ID " << type_id;
 
                AppVerbose("HDF5Init", 12) << "TYPE "<< Typename(FTB->getType())
                                          << " --> " << FTB->getFiberTypeIndex().description()
                                          << " --> " << FTB->description();
 
                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() );
                }
 
                if (!isNative)
                        theH5ID = new H5ID( type_id );
                else
                        theH5ID = new H5NativeTypeID( type_id );
 
                return true;
        }
 
static  bool    registerNativeHID(hid_t type_id)
        {
                return registerHID(type_id, nullptr, true);
        }
 
static  RefPtr<F5Domain> makeDomainType(const vector<std::string>&ElementNames)
        {
        RefPtr<FiberTypeBase> FTB = FiberType_t::getFiberType();
                if (!FTB) return nullptr;
 
        RefPtr<H5DataType>&theH5ID = H5ID::TypeRegistry()[ FTB->getFiberTypeIndex() ];
                if (theH5ID)
                {
                        Verbose(0) << "makeDomainType() ALREADY REGISTERED TYPE "<< Typename(FTB->getType());
                        return nullptr;
                }
 
        enum { ELEMENTS = FiberType_t::FiberInfo_t::MULTIPLICITY };
        enum { RANK     = FiberType_t::FiberInfo_t::RANK         };
 
                Assert( ELEMENTS == ElementNames.size());
 
        vector<const char*> coordnames( ELEMENTS );
                for(int i=0; i<ELEMENTS; i++)
                        coordnames[i] = ElementNames[i].c_str();
 
        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();
 
                Verbose(120)
                        << "TYPEREGISTRY: fibertype: ELEMENTS: " << ELEMENTS << " RANK: " << RANK
                        << " Domain " << Domainname << " Element Type is " << ElementType << " TODO: Create only ONCE global domain here";
 
/*
  Need to revise F5 library to produce the same tensor element names
  as the FiberLib in field/Cell.hpp and field/FiberType.cpp .
 */
        ChartDomain_IDs*CD = 0;
                switch( H5Tget_class(ElementType) )
                {
                case H5T_INTEGER:
                        Verbose(120) << "                 new integer domain ";
                        CD = F5B_new_global_int_domain(&coordnames[0], ELEMENTS, Domainname.c_str(), F5_FORTRAN_ORDER, RANK);
                        break;
 
                case H5T_FLOAT:
                        Verbose(120) << "                 new chart";
                        CD = F5B_new_global_float_chart(&coordnames[0], ELEMENTS, Domainname.c_str(), F5_FORTRAN_ORDER);
                        break;
                default:
                        printf("having type class: %d\n", H5Tget_class(ElementType));
                        puts(__FILE__ " -> stuff not supported.");
                        assert(0);
                }
 
        hsize_t ElementTypeSize = H5Tget_size(ElementType);
 
                Verbose(120) << (ElementTypeSize==8?"(double, 64bit precision)":"(single, 32bit or less precision)");
 
                if (!CD) return nullptr;
 
                AppVerbose("HDF5Init", 20)
                        << "makeDomainType() with points from "
                        << (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;
        RefPtr<H5ID> H = new H5ID( type_id );
                theH5ID = H;
 
        RefPtr<F5Domain> f = new F5Domain( CD );
                H->addInterface( f );
 
                return f;
        }
 
 
static  RefPtr<F5Domain> makeDomainType()
        {
        enum { ELEMENTS = FiberType_t::FiberInfo_t::MULTIPLICITY };
        Verbose(120) << "makeDomainType() ELEMENTS: " << ELEMENTS;
        vector<std::string>     coordnames(ELEMENTS);
                for(int i=0; i<ELEMENTS; i++)
                {
                        coordnames[i] = Type::coordinate_name(i);
                        Verbose(121) << "   " << i << " --> " << coordnames[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 */