hdfutilities.hh

Go to the documentation of this file.

 
#ifndef UTOPIA_DATAIO_HDFUTILITIES_HH
#define UTOPIA_DATAIO_HDFUTILITIES_HH
 
#include <array>
#include <cmath>
#include <iostream>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
#include <hdf5.h>
#include <hdf5_hl.h>
 
#include <utopia/core/type_traits.hh>
 
// Functions for determining if a type is an STL-container are provided here.
// This is used if we wish to make hdf5 types for storing such data in an
// hdf5 dataset.
namespace Utopia
{
namespace DataIO
{
bool
check_validity(htri_t valid, const std::string_view object_name)
{
    if (valid > 0)
    {
        return true;
    }
 
    else if (valid < 0)
    {
        throw std::runtime_error("Object " + std::string(object_name) + ": " +
                                 "Error in validity check");
        return false;
    }
    else
    {
        return false;
    }
}
 
 
htri_t
path_exists(hid_t       loc_id,
            std::string path,
            hid_t       link_property_list = H5P_DEFAULT)
{
    // Position of the segment cursor; all characters before are checked
    // For absolute paths, search always needs to start behind index 1
    std::size_t seg_pos = (path.find("/") == 0) ? 1 : 0;
 
    // A buffer for the return value of H5Lexists
    htri_t rv;
 
    // Go over all segments until the whole string is
    while (seg_pos != std::string::npos)
    {
        // Find the position of the next "/", strictly after the current
        // cursor position
        seg_pos = path.find("/", seg_pos + 1);
 
        // Check for existence of the subpath. If seg_pos is string::npos,
        // the substring is the full path and this is the last loop iteration.
        rv = H5Lexists(
            loc_id, path.substr(0, seg_pos).c_str(), link_property_list);
 
        // If this segment does not exists, need to return already
        if (rv <= 0)
        {
            return rv;
        }
    }
 
    // Checked the full path. Can return the last return value now:
    return rv;
}
 
auto
path_is_valid(hid_t id, std::string path)
{
    auto test = H5LTpath_valid(id, path.c_str(), true);
    if (test > 0)
    {
        return true;
    }
    else if (test == 0)
    {
        return false;
    }
    else
    {
        throw std::runtime_error("Error when checking path " + path);
        return false;
    }
}
 
enum struct HDFCategory
{
    file      = H5I_FILE,
    group     = H5I_GROUP,
    datatype  = H5I_DATATYPE,
    dataspace = H5I_DATASPACE,
    dataset   = H5I_DATASET,
    attribute = H5I_ATTR
};
 
template < HDFCategory category >
std::string
category_to_string()
{
    switch (category)
    {
        case HDFCategory::file:
            return "file";
        case HDFCategory::group:
            return "group";
        case HDFCategory::datatype:
            return "datatype";
        case HDFCategory::dataspace:
            return "dataspace";
        case HDFCategory::dataset:
            return "dataset";
        case HDFCategory::attribute:
            return "attribute";
    }
}
 
template < class Object >
std::string
generate_object_name(const Object& object)
{
    return "category " + category_to_string< Object::category >() + " at '" +
           object.get_path() + "'";
}
 
template < typename Object >
hid_t
open_dataspace(Object&& object)
{
    if constexpr (std::decay_t< Object >::category == HDFCategory::dataset)
    {
        return H5Dget_space(object.get_C_id());
    }
    else if constexpr (std::decay_t< Object >::category ==
                       HDFCategory::attribute)
    {
        return H5Aget_space(object.get_C_id());
    }
    else
    {
        return -1;
    }
}
 
template < typename Object >
hid_t
open_type(Object&& object)
{
    if constexpr (std::decay_t< Object >::category == HDFCategory::dataset)
    {
        return H5Dget_type(object.get_C_id());
    }
    else if constexpr (std::decay_t< Object >::category ==
                       HDFCategory::attribute)
    {
        return H5Aget_type(object.get_C_id());
    }
    else
    {
        return -1;
    }
}
 
 
} // namespace DataIO
} // namespace Utopia
#endif