HDF5Field.hpp

 
//
// $Id: HDF5Field.hpp,v 1.4 2007/09/17 21:48:54 werner Exp $
//
#ifndef __FIBER_HDF5FIELD_HPP
#define __FIBER_HDF5FIELD_HPP "Created 27.02.2001 21:42:27 by werner"
 
#include "HDF5Bundle.hpp"
#include "HDF5MemArrayStorage.hpp"
 
#include <F5/F5private.h>
 
#include <vecal/CartesianCoordinates.hpp>
#include <vecal/CartesianChart.hpp>
#include <vecal/ipol/ViewMultiArray.hpp>
#include <vecal/ipol/STLMultiArray.hpp>
#include <field/ArrayList.hpp>
 
namespace Fiber
{
        using VecAl::ViewPtr;
 
 
/*
template <class T>
        void HDF5print(const T&);
 
template <>
inline  void HDF5print(const double&d)
{
        printf("%lg", d);
}
 
template <>
inline  void HDF5print(const float&d)
{
        printf("%g", d);
}
 
template <int N, class Value>
inline  void HDF5print(const FixedArray<N, Value>&FA)
{
        for(int i=0; i<N; i++)
        {
                HDF5print( FA[i] );
                printf(" ");
        }
}
 
template <int N, class Value>
inline  void HDF5print(const Vector<N, Value>&V)
{
        HDF5print( V.fixed_array() );
}
 
template <int N, class Value>
inline  void HDF5print(const VVector<N, Value>&V)
{
        HDF5print( V.vec() );
}
 
template <int C, class value>
inline  void HDF5print(const Row<C, value>&R)
{
        HDF5print(R.vvec());
}
 
 
template <class ChartType, class TensorType>
inline  void HDF5print(const Tensor<ChartType, TensorType>&d)
{
        HDF5print(d.base() );
}
 
template <class ChartType, class ScalarType>
inline  void HDF5print(const Point<ChartType, ScalarType>&d)
{
        HDF5print(d.vec() );
}
*/
 
 
template <int N, class T, class Storage>
class   HDF5BUNDLE_API HDF5SaverCreator<MemArrayStorage<N, T, Storage> > : public SaveInterfaceCreator<MemArrayStorage<N, T, Storage> >
{
        bool addSaveInterface(MemArrayStorage<N, T, Storage>*M) override
        {
                M->addInterface( new HDF5Saver<MemArrayStorage<N, T, Storage> >(M);
                return false;
        }
};
 
template <class MemArrayStorageType>
        struct HDF5FieldSaverInit
{
static  int init()
        {
                SaveRegistry<MemArrayStorageType>::getCreator( typeid(HDF5) ) = new HDF5SaverCreator<MemArrayStorageType>();
                return 1;
        }
};
 
template <int Dims, class Type>
        struct HDF5FieldSaverStorageIterator
{
static  int init()
        {
                return  HDF5FieldSaverInit<MemArrayStorage<Dims, Type, Type*> >::init()
                +       HDF5FieldSaverInit<MemArrayStorage<Dims, Type, ViewPtr<Type> > >::init()
                +       HDF5FieldSaverInit<MemArrayStorage<Dims, Type, const Type*> >::init()
                +       HDF5FieldSaverInit<MemArrayStorage<Dims, Type, vector<Type> > >::init()
                +       HDF5FieldSaverInit<MemArrayStorage<Dims, Type, vector<Type*> > >::init()
                +       HDF5FieldSaverInit<MemArrayStorage<Dims, Type, vector<const Type*> > >::init();
        }
};
 
 
template <class Type, int Dims>
struct HDF5DimensionalFieldSaverStorageIterator;
 
template <class Type>
struct  HDF5DimensionalFieldSaverStorageIterator<Type, 1>
{
static  int init()
        {
                return  HDF5FieldSaverStorageIterator<1, Type>::init();
        }
};
 
template <class Type, int Dims=4>
struct  HDF5DimensionalFieldSaverStorageIterator
{
static  int init()
        {
                return  HDF5FieldSaverStorageIterator<Dims, Type>::init()
                        +
                        HDF5FieldSaverStorageIterator<Dims-1, Type>::init();
        }
};
 
 
 
} /* namespace Fiber */
 
#endif // __FIBER_HDF5FIELD_HPP