Utopia::DataIO::HDFFile Class Reference

Class representing a HDF5 file. More...

#include <hdffile.hh>

Inheritance diagram for Utopia::DataIO::HDFFile:

Collaboration diagram for Utopia::DataIO::HDFFile:

Public Member Functions
void	swap (HDFFile &other)
	Function for exchanging states.
void	open (std::string path, std::string access)
	Open a file at location 'path' with access specifier 'access'. Keep in mind that if the object refers to another file, it has to be closed first before opening another.
std::shared_ptr< HDFGroup >	get_basegroup ()
	Get the basegroup object via shared ptr.
std::shared_ptr< HDFGroup >	open_group (std::string path)
	Open group at path 'path', creating all intermediate objects in the path. Separation character is: /.
std::shared_ptr< HDFDataset >	open_dataset (std::string path, std::vector< hsize_t > capacity={}, std::vector< hsize_t > chunksizes={}, std::size_t compresslevel=0)
	open dataset
void	delete_group (std::string &&path)
	deletes the group pointed to by absolute path 'path'
void	flush ()
	Initiates an immediate write to disk of the data of the file.
	HDFFile ()=default
	Construct a new default HDFFile object.
	HDFFile (HDFFile &&other)=default
	Move constructor Construct a new HDFFile object via move semantics.
HDFFile &	operator= (const HDFFile &other)=delete
	Copy assignment operator, explicitly deleted, hence cannot be used.
HDFFile &	operator= (HDFFile &&other)=default
	Move assigment operator.
	HDFFile (const HDFFile &other)=delete
	Copy constructor. Explicitly deleted, hence cannot be used.
	HDFFile (std::string path, std::string access)
	Construct a new HDFFile object.
virtual	~HDFFile ()=default
	Destroy the HDFFile object.
Public Member Functions inherited from Utopia::DataIO::HDFObject< HDFCategory::file >
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.
virtual bool	is_valid () const
	Check if the object is still valid.
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
std::shared_ptr< HDFGroup >	_base_group
	Pointer to base group of the file.

Additional Inherited Members
Static Public Attributes inherited from Utopia::DataIO::HDFObject< HDFCategory::file >
static constexpr HDFCategory	category
	Named variable for template arg.
Protected Attributes inherited from Utopia::DataIO::HDFObject< HDFCategory::file >
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 representing a HDF5 file.

Constructor & Destructor Documentation

HDFFile() [1/4]

Utopia::DataIO::HDFFile::HDFFile ( )

default

Construct a new default HDFFile object.

HDFFile() [2/4]

Utopia::DataIO::HDFFile::HDFFile ( HDFFile &&  other )

default

Move constructor Construct a new HDFFile object via move semantics.

Parameters

other

rvalue reference to HDFFile object

HDFFile() [3/4]

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

delete

Copy constructor. Explicitly deleted, hence cannot be used.

Parameters

other

Returns

HDFFile&

HDFFile() [4/4]

Utopia::DataIO::HDFFile::HDFFile ( std::string  path, std::string  access  )

inline

Construct a new HDFFile object.

Parameters

path	Path to the new file
access	Access specifier for the new file, possible values: 'r' (readonly, file must exist), 'r+' (read/write, file must exist), 'w' (create file, truncate if exists), 'x' (create file, fail if exists), or 'a' (read/write if exists, create otherwise)

                                              : HDFFile()
    {
        // init the logger here because it is needed throughout the module
        // and its existence is not guaranteed when it is initialized in `core`
        _log = init_logger(log_data_io, spdlog::level::warn, false);
        open(path, access);
    }

~HDFFile()

virtual Utopia::DataIO::HDFFile::~HDFFile ( )

virtualdefault

Destroy the HDFFile object.

Member Function Documentation

delete_group()

void Utopia::DataIO::HDFFile::delete_group ( std::string &&  path )

inline

deletes the group pointed to by absolute path 'path'

Parameters

path	absolute path to the group to be deleted

    {
        _base_group->delete_group(std::forward< std::string&& >(path));
    }

flush()

void Utopia::DataIO::HDFFile::flush ( )

inline

Initiates an immediate write to disk of the data of the file.

    {
        if (is_valid())
        {
            H5Fflush(get_C_id(), H5F_SCOPE_GLOBAL);
        }
    }

get_basegroup()

std::shared_ptr< HDFGroup > Utopia::DataIO::HDFFile::get_basegroup ( )

inline

Get the basegroup object via shared ptr.

Returns

std::shared_ptr<HDFGroup>

    {
        return _base_group;
    }

open()

void Utopia::DataIO::HDFFile::open ( std::string  path, std::string  access  )

inline

Open a file at location 'path' with access specifier 'access'. Keep in mind that if the object refers to another file, it has to be closed first before opening another.

Parameters

path	Path to open the file at
access	Access specifier for the new file, possible values: 'r' (readonly, file must exist), 'r+' (read/write, file must exist), 'w' (create file, truncate if exists), 'x' (create file, fail if exists), or 'a' (read/write if exists, create otherwise)

    {
        this->_log->info(
            "Opening file at {} with access specifier {}", path, access);
        if (is_valid())
        {
            throw std::runtime_error(
                "File still bound to another HDF5 file when trying to call "
                "'open'. Close first.");
        }
 
        // create file access property list
        hid_t fapl = H5Pcreate(H5P_FILE_ACCESS);
 
        // set driver to stdio and close strongly, i.e., close all resources
        // with the file
        H5Pset_fapl_stdio(fapl);
        H5Pset_fclose_degree(fapl, H5F_CLOSE_STRONG);
 
        if (access == "w")
        {
            bind_to(H5Fcreate(path.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, fapl),
                    &H5Fclose,
                    path);
        }
        else if (access == "r")
        {
            bind_to(
                H5Fopen(path.c_str(), H5F_ACC_RDONLY, fapl), &H5Fclose, path);
        }
        else if (access == "r+")
        {
            bind_to(H5Fopen(path.c_str(), H5F_ACC_RDWR, fapl), &H5Fclose);
        }
        else if (access == "x")
        {
            bind_to(H5Fcreate(path.c_str(), H5F_ACC_EXCL, H5P_DEFAULT, fapl),
                    &H5Fclose,
                    path);
        }
        else if (access == "a")
        {
            hid_t file_test = H5Fopen(path.c_str(), H5F_ACC_RDWR, fapl);
 
            if (file_test < 0)
            {
                file_test =
                    H5Fcreate(path.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
            }
 
            bind_to(file_test, &H5Fclose);
        }
        else
        {
            throw std::invalid_argument("wrong type of access specifier, "
                                        "see documentation for allowed "
                                        "values");
        }
 
        _base_group = std::make_shared< HDFGroup >(*this, "/");
    }

open_dataset()

std::shared_ptr< HDFDataset > Utopia::DataIO::HDFFile::open_dataset ( std::string  path, std::vector< hsize_t >  capacity = {}, std::vector< hsize_t >  chunksizes = {}, std::size_t  compresslevel = 0  )

inline

open dataset

Parameters

path	The path to the dataset

Returns

std::shared_ptr<HDFDataset>

                                                      {},
                 std::vector< hsize_t > chunksizes    = {},
                 std::size_t            compresslevel = 0)
    {
        // this removes the '/' at the beginning, because this is
        // reserved for the basegroup
        if (path[0] == '/')
        {
            path = path.substr(1, path.size() - 1);
        }
 
        return _base_group->open_dataset(
            path, capacity, chunksizes, compresslevel);
    }

open_group()

std::shared_ptr< HDFGroup > Utopia::DataIO::HDFFile::open_group ( std::string  path )

inline

Open group at path 'path', creating all intermediate objects in the path. Separation character is: /.

Parameters

path	The path to the group

Returns

std::shared_ptr<HDFGroup>

    {
        // this removes the '/' at the beginning, because this is
        // reserved for the basegroup
        if (path[0] == '/')
        {
            path = path.substr(1, path.size() - 1);
        }
 
        return _base_group->open_group(path);
    }

operator=() [1/2]

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

delete

Copy assignment operator, explicitly deleted, hence cannot be used.

Parameters

other

Returns

HDFFile&

operator=() [2/2]

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

default

Move assigment operator.

Parameters

other

reference to HDFFile object

Returns

HDFFile&

swap()

void Utopia::DataIO::HDFFile::swap ( HDFFile &  other )

inline

Function for exchanging states.

Parameters

other

The other

    {
        using std::swap;
        using Utopia::DataIO::swap;
        swap(_base_group, other._base_group);
    }

Member Data Documentation

_base_group

std::shared_ptr< HDFGroup > Utopia::DataIO::HDFFile::_base_group

private

Pointer to base group of the file.

---

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

• include/utopia/data_io/hdffile.hh