Utopia::DataIO::HDFType Class Reference

Class which handles the conversion of C-types into hdf5types. More...

#include <hdftype.hh>

Inheritance diagram for Utopia::DataIO::HDFType:

Collaboration diagram for Utopia::DataIO::HDFType:

Public Types
using	Base = HDFObject< HDFCategory::datatype >
using	Variant = std::variant< float, double, long double, int, short int, long int, long long int, unsigned int, unsigned short int, std::size_t, unsigned long long, bool, char, std::vector< float >, std::vector< double >, std::vector< long double >, std::vector< int >, std::vector< short int >, std::vector< long int >, std::vector< long long int >, std::vector< unsigned int >, std::vector< unsigned short int >, std::vector< std::size_t >, std::vector< unsigned long long >, std::vector< char >, std::vector< std::string >, std::string, const char * >

Public Member Functions
bool	is_mutable () const
	Get if the type is mutable or not.
auto	type_category () const
	Get the type category of the held type, i.e., scala, string, varlen,...
std::size_t	size () const
	Size of the type held in bytes.
template<typename T >
void	open (T &&object)
	Open the HDF5 type associated with an HDFObject, i.e., a dataset or an attribute.
template<typename T >
void	open (std::string name, hsize_t typesize)
	Create an HDF datatype corresponding to the C datatype given as template argument.
void	close ()
	Construct close from the given arguments.
virtual bool	is_valid () const override
	Check if the held type identifier is still valid. Primitive types are valid by definition, because we have no control over them and hence they cannot be invalidated.
	HDFType (HDFType &&other)
	Construct HDFType from the given arguments by move, deleted, because apparently incompatible with HDF5 C backend.
HDFType &	operator= (HDFType &&other)
	Move assign the type.
	HDFType (const HDFType &other)=default
	Construct HDFType from the given arguments by copy.
HDFType &	operator= (const HDFType &other)=default
	Copy assign type.
virtual	~HDFType ()
	Destroy the HDFType object.
	HDFType ()
	Construct HDFType from by default.
template<typename T >
	HDFType (T &&object_or_size, std::enable_if_t< not std::is_same_v< HDFType, std::decay_t< T > >, int >=0)
	Construct HDFType from the given arguments.
Public Member Functions inherited from Utopia::DataIO::HDFObject< HDFCategory::datatype >
void	swap (HDFObject &other)
	swap the state of the caller with the state of the argument
std::string	get_path () const
	Get the name or path object.
auto	get_id_object () const
	Get the id object.
auto	get_logger () const
	Get the logger object.
hid_t	get_C_id () const
	Get the C id object.
auto	get_refcount ()
	Get the reference count of object.
void	close ()
	Close function which takes care of correctly closing the object and managing the reference counter.
void	bind_to (hid_t id, std::function< herr_t(hid_t) > closing_func, std::string path={})
	Open the object and bind it to a HDF5 object identified by 'id' with name 'path'. Object should be created beforehand.
	HDFObject ()
	Construct HDFObject from the given arguments.
	HDFObject (HDFObject &&other)
	Construct HDFObject by moving.
	HDFObject (const HDFObject &other)=default
	Construct HDFObject by copying another object.
	HDFObject (hid_t id, std::function< herr_t(hid_t) > closing_func, std::string path={})
	Construct HDFObject from the given argument.
HDFObject &	operator= (const HDFObject &other)
	Copy assignment operator.
HDFObject &	operator= (HDFObject &&other)
	move assignment operator
virtual	~HDFObject ()
	Destroy the HDFObject object. Has to be implemented in subclass!

Private Attributes
bool	_mutable = false
H5T_class_t	_classid

Additional Inherited Members
Static Public Attributes inherited from Utopia::DataIO::HDFObject< HDFCategory::datatype >
static constexpr HDFCategory	category
	Named variable for template arg.
Protected Attributes inherited from Utopia::DataIO::HDFObject< HDFCategory::datatype >
HDFIdentifier	_id
	Identifier object that binds an instance of this class to an HDF5 object.
std::string	_path
	Name of the object.
std::shared_ptr< spdlog::logger >	_log
	pointer to the logger for dataio

Detailed Description

Class which handles the conversion of C-types into hdf5types.

Member Typedef Documentation

Base

using Utopia::DataIO::HDFType::Base = HDFObject< HDFCategory::datatype >

Variant

using Utopia::DataIO::HDFType::Variant = std::variant< float, double, long double, int, short int, long int, long long int, unsigned int, unsigned short int, std::size_t, unsigned long long, bool, char, std::vector< float >, std::vector< double >, std::vector< long double >, std::vector< int >, std::vector< short int >, std::vector< long int >, std::vector< long long int >, std::vector< unsigned int >, std::vector< unsigned short int >, std::vector< std::size_t >, std::vector< unsigned long long >, std::vector< char >, std::vector< std::string >, std::string, const char* >

Constructor & Destructor Documentation

HDFType() [1/4]

Utopia::DataIO::HDFType::HDFType ( HDFType &&  other )

inline

Construct HDFType from the given arguments by move, deleted, because apparently incompatible with HDF5 C backend.

                             : Base(static_cast< Base&& >(other))
    {
        _mutable = std::move(other._mutable);
        _classid = std::move(other._classid);
 
        other._mutable = false;
        other._classid = H5T_NO_CLASS;
    }

HDFType() [2/4]

Utopia::DataIO::HDFType::HDFType ( const HDFType &  other )

default

Construct HDFType from the given arguments by copy.

~HDFType()

virtual Utopia::DataIO::HDFType::~HDFType ( )

inlinevirtual

Destroy the HDFType object.

    {
        close();
    }

HDFType() [3/4]

Utopia::DataIO::HDFType::HDFType ( )

inline

Construct HDFType from by default.

              : Base(), _mutable(false), _classid(H5T_NO_CLASS)
    {
    }

HDFType() [4/4]

template<typename T >

Utopia::DataIO::HDFType::HDFType ( T &&  object_or_size, std::enable_if_t< not std::is_same_v< HDFType, std::decay_t< T > >, int >  = 0  )

inline

Construct HDFType from the given arguments.

Parameters

size	Size of the type underlying the type to be created, or an HDFdataset or attribute to determine the held datatype of

                                                                                    :
    HDFType()
    {
        open(object_or_size);
    }

Member Function Documentation

close()

void Utopia::DataIO::HDFType::close ( )

inline

Construct close from the given arguments.

    {
 
        // everything that is obtained via H5Tcopy, H5Topen or H5Tcreate
        // needs to be released explicitly. This is given by the _mutable
        // flag
        Base::close();
        _mutable = false;
        _classid = H5T_NO_CLASS;
    }

is_mutable()

bool Utopia::DataIO::HDFType::is_mutable ( ) const

inline

Get if the type is mutable or not.

Returns

true

false

    {
        return _mutable;
    }

is_valid()

virtual bool Utopia::DataIO::HDFType::is_valid ( ) const

inlineoverridevirtual

Check if the held type identifier is still valid. Primitive types are valid by definition, because we have no control over them and hence they cannot be invalidated.

Returns

true

false

Reimplemented from Utopia::DataIO::HDFObject< HDFCategory::datatype >.

    {
        // this distinction is important because identifiers are not always
        // checkable via H5Iis_valid
        if (not(_classid == H5T_VLEN or _classid == H5T_ARRAY or
                _classid == H5T_STRING) and
            not(get_C_id() == -1))
        {
            return true;
        }
        else
        {
            return Base::is_valid();
        }
    }

open() [1/2]

template<typename T >

void Utopia::DataIO::HDFType::open ( std::string  name, hsize_t  typesize  )

inline

Create an HDF datatype corresponding to the C datatype given as template argument.

Template Parameters

T

Parameters

object_or_size

size of the datatype in bytes, if not given, automatically determined: containers and strings become variable length size, everything else becomes scalar

    {
        this->_log->debug("Opening HDFType from scratch");
 
        if (is_valid())
        {
            throw std::runtime_error(
                "Error, cannot open HDFType '" + name + "' while it's still bound "
                "to another valid type object! Close it first.");
        }
 
        // include const char* which is a  c-string
        if constexpr (Utils::is_container_v< T >)
        {
            if (typesize == 0ul)
            {
                bind_to(H5Tvlen_create(
                            Detail::get_type< typename T::value_type >()),
                        &H5Tclose,
                        name);
            }
            else
            {
                hsize_t dim[1] = { typesize };
                bind_to(
                    H5Tarray_create(
                        Detail::get_type< typename T::value_type >(), 1, dim),
                    &H5Tclose,
                    name);
            }
            _mutable = true;
        }
        else if constexpr (Utils::is_string_v< T >)
        {
            hid_t type = H5Tcopy(H5T_C_S1);
 
            if (typesize == 0)
            {
                H5Tset_size(type, H5T_VARIABLE);
            }
            else
            {
                H5Tset_size(type, typesize);
            }
            bind_to(std::move(type), &H5Tclose, name);
 
            _mutable = true;
        }
        else
        {
            // native type objects like H5T_NATIVE_INT are interpreted as
            // invalid by H5Iis_valid, hence at this point the `bind_to`
            // function is not used, because it checks validity
            _id.open(Detail::get_type< T >(),
                     [](hid_t) -> herr_t { return 0; });
            _path    = name;
            _mutable = false;
        }
 
        _classid = H5Tget_class(get_C_id());
    }

open() [2/2]

template<typename T >

void Utopia::DataIO::HDFType::open ( T &&  object )

inline

Open the HDF5 type associated with an HDFObject, i.e., a dataset or an attribute.

Template Parameters

T

Parameters

object

    {
        this->_log->debug("Opening HDFType from existing object {}",
                          object.get_path());
 
        if (is_valid())
        {
            throw std::runtime_error(
                "Error, cannot open HDFType while it's still bound to another "
                "valid type object, close it first");
        }
 
        bind_to(open_type(object),
                &H5Tclose, // we lock the type, hence no H5Tclose needed
                "datatype of " + object.get_path());
 
        _mutable = true;
        _classid = H5Tget_class(get_C_id());
    }

operator=() [1/2]

HDFType & Utopia::DataIO::HDFType::operator= ( const HDFType &  other )

default

Copy assign type.

Returns

HDFType&

operator=() [2/2]

HDFType & Utopia::DataIO::HDFType::operator= ( HDFType &&  other )

inline

Move assign the type.

Returns

HDFType&

    {
        static_cast<Base&>(*this) = static_cast< Base&& >(other);
        _mutable = std::move(other._mutable);
        _classid = std::move(other._classid);
 
        other._mutable = false;
        other._classid = H5T_NO_CLASS;
 
        return *this;
    }

size()

std::size_t Utopia::DataIO::HDFType::size ( ) const

inline

Size of the type held in bytes.

Returns

std::size_t

    {
        return H5Tget_size(get_C_id());
    }

type_category()

auto Utopia::DataIO::HDFType::type_category ( ) const

inline

Get the type category of the held type, i.e., scala, string, varlen,...

Returns

auto type category of held type

    {
        return _classid;
    }

Member Data Documentation

_classid

H5T_class_t Utopia::DataIO::HDFType::_classid

private

_mutable

bool Utopia::DataIO::HDFType::_mutable = false

private

---

The documentation for this class was generated from the following file:

• include/utopia/data_io/hdftype.hh