H5Utils::internal Namespace Reference

clssses to add type traits for H5 More...

Classes
struct	CheckType
struct	CheckType< 0, T, I, decltype(*begin(std::declval< T & >()), void())>
struct	CheckType< N, T, I, decltype(*begin(std::declval< T & >()), void())>
union	data_buffer_t
	data_buffer_t More...
class	DataConsumer
	implementation for variable filler More...
struct	DataFlattener
	Data flattener class: this is used by the writer to read in the elements one by one and put them in an internal buffer. More...
struct	DataFlattener< 0, F, T, M >
struct	DSParameters
	Constant parameters for the writer. More...
struct	H5Traits
	We have lots of code to get around HDF5's rather weak typing. More...
struct	H5Traits< bool >
struct	H5Traits< char >
struct	H5Traits< double >
struct	H5Traits< float >
struct	H5Traits< int >
struct	H5Traits< long >
struct	H5Traits< long long >
struct	H5Traits< short >
struct	H5Traits< unsigned char >
struct	H5Traits< unsigned int >
struct	H5Traits< unsigned long >
struct	H5Traits< unsigned long long >
struct	H5Traits< unsigned short >
class	IDataConsumer
	DataConsumer classes. More...
class	IVariableFiller
	Variable fillers. More...
class	VariableFiller
	implementation for variable filler More...

Typedefs
typedef H5::PredType	PT

Functions
H5::CompType	packed (H5::CompType in)
H5::DataSpace	getUnlimitedSpace (const std::vector< hsize_t > &max_length)
template<size_t N>
H5::DSetCreatPropList	getChunckedDatasetParams (const WriterConfiguration< N > &)
std::vector< hsize_t >	getStriding (std::vector< hsize_t > max_length)
void	throwIfExists (const std::string &name, const H5::Group &in_group)
void	printDestructorError (const std::string &msg)
H5::DataType	halfPrecisionFloat (int ebias=15)
template<typename T >
H5::DataType	getCompressedType (Compression comp)
template<typename T >
data_buffer_t	get_buffer_from_func (const std::function< T()> &func)
	Buffer element harvester. More...
template<typename I >
H5::CompType	buildType (const std::vector< SharedConsumer< I > > &consumers)
	Adapter to translate configuration info into the objects needed by the writer. More...
template<typename I >
H5::CompType	buildWriteType (const std::vector< SharedConsumer< I > > &con)
template<typename I >
std::vector< data_buffer_t >	buildDefault (const std::vector< SharedConsumer< I > > &f)
template<size_t N>
std::vector< hsize_t >	vec (std::array< hsize_t, N > a)
template<hsize_t N>
std::array< hsize_t, N >	uniform (size_t val)
H5::DataType	get_bool_type ()

Detailed Description

clssses to add type traits for H5

internal code for the Writer class

internal classes and code

Internal clssses and code.

Typedef Documentation

PT

typedef H5::PredType H5Utils::internal::PT

Definition at line 15 of file H5Traits.cxx.

Function Documentation

buildDefault()

template<typename I >

std::vector<data_buffer_t> H5Utils::internal::buildDefault

(

const std::vector< SharedConsumer< I > > &

f

)

Definition at line 315 of file Writer.h.

                                                                                  {
      std::vector<data_buffer_t> def;
      for (const SharedConsumer<I>& filler: f) {
        def.push_back(filler->getDefault());
      }
      return def;
    }

buildType()

template<typename I >

H5::CompType H5Utils::internal::buildType

(

const std::vector< SharedConsumer< I > > &

consumers

)

Adapter to translate configuration info into the objects needed by the writer.

Definition at line 264 of file Writer.h.

                                                                         {
      if (consumers.size() < 1) {
        throw std::logic_error(
          "you must specify at least one consumer when initializing the HDF5"
          "writer");
      }
 
      H5::CompType type(consumers.size() * sizeof(data_buffer_t));
      size_t dt_offset = 0;
      for (const SharedConsumer<I>& filler: consumers) {
        type.insertMember(filler->name(), dt_offset, filler->getType());
        dt_offset += sizeof(data_buffer_t);
      }
      return type;
    }

buildWriteType()

template<typename I >

H5::CompType H5Utils::internal::buildWriteType

(

const std::vector< SharedConsumer< I > > &

con

)

Definition at line 280 of file Writer.h.

                                                                        {
      H5::CompType type(con.size() * sizeof(data_buffer_t));
      size_t dt_offset = 0;
      for (const SharedConsumer<I>& filler: con) {
        type.insertMember(filler->name(), dt_offset, filler->getWriteType());
        dt_offset += sizeof(data_buffer_t);
      }
      type.pack();
      return type;
    }

get_bool_type()

H5::DataType H5Utils::internal::get_bool_type

(

)

Definition at line 31 of file H5Traits.cxx.

                               {
      bool TRUE = true;
      bool FALSE = false;
      H5::EnumType btype(sizeof(bool));
      btype.insert("TRUE", &TRUE);
      btype.insert("FALSE", &FALSE);
      return btype;
    }

get_buffer_from_func()

template<typename T >

data_buffer_t H5Utils::internal::get_buffer_from_func

(

const std::function< T()> &

func

)

Buffer element harvester.

This is used to buld the unions we use to build the hdf5 memory buffer. Together with the get_type templates it gives us a strongly typed HDF5 writer.

Definition at line 42 of file HdfTuple.h.

                                                                     {
      data_buffer_t buffer;
      H5Traits<T>::ref(buffer) = func();
      return buffer;
    }

getChunckedDatasetParams()

template<size_t N>

H5::DSetCreatPropList H5Utils::internal::getChunckedDatasetParams

(

const WriterConfiguration< N > &

)

getCompressedType()

template<typename T >

H5::DataType H5Utils::internal::getCompressedType

(

Compression

comp

)

Definition at line 23 of file CompressedTypes.h.

                                                   {
      if constexpr (std::is_floating_point<T>::value) {
        switch (comp) {
          case Compression::STANDARD: return H5Traits<T>::type;
          case Compression::HALF_PRECISION: return halfPrecisionFloat();
          case Compression::HALF_PRECISION_LARGE: return halfPrecisionFloat(5);
          default: throw std::logic_error("unknown float compression");
        }
      }
      if (comp != Compression::STANDARD) {
        throw std::logic_error("compression not supported for this type");
      }
      return H5Traits<T>::type;
    }

getStriding()

std::vector< hsize_t > H5Utils::internal::getStriding

(

std::vector< hsize_t >

max_length

)

Definition at line 38 of file common.cxx.

                                                              {
      // calculate striding
      extent.push_back(1);
      for (size_t iii = extent.size(); iii - 1 != 0; iii--) {
        extent.at(iii-2) = extent.at(iii-2) * extent.at(iii-1);
      }
      return extent;
    }

getUnlimitedSpace()

H5::DataSpace H5Utils::internal::getUnlimitedSpace

(

const std::vector< hsize_t > &

max_length

)

Definition at line 31 of file common.cxx.

                                                                    {
      std::vector<hsize_t> initial{0};
      initial.insert(initial.end(), extent.begin(), extent.end());
      std::vector<hsize_t> eventual{H5S_UNLIMITED};
      eventual.insert(eventual.end(), extent.begin(), extent.end());
      return H5::DataSpace(eventual.size(), initial.data(), eventual.data());
    }

halfPrecisionFloat()

H5::DataType H5Utils::internal::halfPrecisionFloat

(

int

ebias = 15

)

Definition at line 14 of file CompressedTypes.cxx.

                                             {
      // start with native float
      H5::FloatType type(H5Tcopy(H5::PredType::NATIVE_FLOAT.getId()));
 
      // These definitions are copied from h5py, see:
      //
      //  https://github.com/h5py/h5py/blob/596748d52c351258c851bb56c8df1c25d3673110/h5py/h5t.pyx#L212-L217
      //
      type.setFields(15, 10, 5, 0, 10);
      type.setSize(2);
      type.setEbias(ebias);
      return type;
    }

packed()

H5::CompType H5Utils::internal::packed

(

H5::CompType

in

)

Definition at line 16 of file common.cxx.

                                     {
      // TODO: Figure out why a normal copy constructor doesn't work here.
      //       The normal one seems to create shallow copies.
      H5::CompType out(H5Tcopy(in.getId()));
      out.pack();
      return out;
    }

printDestructorError()

void H5Utils::internal::printDestructorError

(

const std::string &

msg

)

Definition at line 24 of file common.cxx.

                                                    {
      std::cerr << "ERROR: an exception was thrown in the destructor of an "
        "HDF5 file, the output buffer may be corrupted";
      std::cerr << " (error message: " << msg << ")" << std::endl;
    }

throwIfExists()

void H5Utils::internal::throwIfExists	(	const std::string &	name,
		const H5::Group &	in_group
	)

Definition at line 46 of file common.cxx.

                                                                       {
      if (H5Lexists(in_group.getLocId(), name.c_str(), H5P_DEFAULT)) {
        throw std::logic_error("tried to overwrite '" + name + "'");
      }
    }

uniform()

template<hsize_t N>

std::array<hsize_t, N> H5Utils::internal::uniform

(

size_t

val

)

Definition at line 331 of file Writer.h.

                                             {
      std::array<hsize_t, N> ar;
      ar.fill(val);
      return ar;
    }

vec()

template<size_t N>

std::vector<hsize_t> H5Utils::internal::vec

(

std::array< hsize_t, N >

a

)

Definition at line 325 of file Writer.h.

                                                  {
      return std::vector<hsize_t>(a.begin(),a.end());
    }