hdffile.hh

Go to the documentation of this file.

#ifndef UTOPIA_DATAIO_HDFFILE_HH
#define UTOPIA_DATAIO_HDFFILE_HH
 
#include <sstream>
#include <stdexcept>
#include <string>
#include <unordered_map>
 
#include <hdf5.h>
#include <hdf5_hl.h>
 
#include "hdfdataset.hh"
#include "hdfgroup.hh"
#include "utopia/data_io/hdfobject.hh"
#include "utopia/data_io/hdfutilities.hh"
 
namespace Utopia
{
namespace DataIO
{
 
// Doxygen group for dataIO backend
// ++++++++++++++++++++++++++++++++++++++++++++++
class HDFFile final : public HDFObject< HDFCategory::file >
{
  private:
    std::shared_ptr< HDFGroup > _base_group;
 
  public:
    void
    swap(HDFFile& other)
    {
        using std::swap;
        using Utopia::DataIO::swap;
        swap(_base_group, other._base_group);
    }
 
    void
    open(std::string path, std::string access)
    {
        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, "/");
    }
 
    std::shared_ptr< HDFGroup >
    get_basegroup()
    {
        return _base_group;
    }
 
    std::shared_ptr< HDFGroup >
    open_group(std::string path)
    {
        // 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);
    }
 
    std::shared_ptr< HDFDataset >
    open_dataset(std::string            path,
                 std::vector< hsize_t > capacity      = {},
                 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);
    }
 
    void
    delete_group(std::string&& path)
    {
        _base_group->delete_group(std::forward< std::string&& >(path));
    }
 
    void
    flush()
    {
        if (is_valid())
        {
            H5Fflush(get_C_id(), H5F_SCOPE_GLOBAL);
        }
    }
 
    HDFFile() = default;
 
    HDFFile(HDFFile&& other) = default;
 
    HDFFile&
    operator=(const HDFFile& other) = delete;
 
    HDFFile&
    operator=(HDFFile&& other) = default;
 
    HDFFile(const HDFFile& other) = delete;
 
    HDFFile(std::string path, std::string access) : 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);
    }
 
    virtual ~HDFFile() = default;
};
 
 
} // namespace DataIO
} // namespace Utopia
#endif