hdfgroup.hh

Go to the documentation of this file.

 
#ifndef UTOPIA_DATAIO_HDFGROUP_HH
#define UTOPIA_DATAIO_HDFGROUP_HH
#include <string>
#include <vector>
 
#include <hdf5.h>
#include <hdf5_hl.h>
 
#include "hdfattribute.hh"
#include "hdfdataset.hh"
#include "hdfobject.hh"
#include "hdfutilities.hh"
 
namespace Utopia
{
namespace DataIO
{
class HDFGroup final : public HDFObject< HDFCategory::group >
{
  public:
    using Base = HDFObject< HDFCategory::group >;
    template < typename Attrdata >
    void
    add_attribute(std::string name, Attrdata attribute_data)
    {
        HDFAttribute(*this, name).write(attribute_data);
    }
 
    template < HDFCategory cat >
    void
    open(HDFObject< cat >& parent, std::string path)
    {
 
        this->_log->debug(
            "Opening group with path {} at parent {}", path, parent.get_path());
        // check if given path exists in parent
        if (path_is_valid(parent.get_C_id(), path))
        {
            // manage new group using his class
            bind_to(H5Gopen(parent.get_C_id(), path.c_str(), H5P_DEFAULT),
                    &H5Gclose,
                    path);
 
            if (get_C_id() < 0)
            {
                throw std::runtime_error("Group opening for path '" + path +
                                         "' failed!");
            }
        }
        else
        { // group does not exist yet
            // create the group and intermediates
            hid_t group_plist = H5Pcreate(H5P_LINK_CREATE);
            H5Pset_create_intermediate_group(group_plist, 1);
 
            // manage new group using his class
            bind_to(H5Gcreate(parent.get_C_id(),
                              path.c_str(),
                              group_plist,
                              H5P_DEFAULT,
                              H5P_DEFAULT),
                    &H5Gclose,
                    path);
 
            H5Pclose(group_plist);
 
            if (get_C_id() < 0)
            {
                throw std::runtime_error("Group creation for path '" + path +
                                         "' failed!");
            }
        }
    }
 
    std::shared_ptr< HDFGroup >
    open_group(std::string path)
    {
        return std::make_shared< HDFGroup >(*this, 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)
    {
        return std::make_shared< HDFDataset >(
            *this, path, capacity, chunksizes, compresslevel);
    }
 
    void
    delete_group(std::string path)
    {
        this->_log->debug("Deleting group {} in {}", path, _path);
 
        // check if group exists in file. If it does, delete the link
        herr_t status = 1;
        if (is_valid())
        {
            // group exists, can be deleted
            status = H5Ldelete(get_C_id(), path.c_str(), H5P_DEFAULT);
            if (status < 0)
            {
                throw std::runtime_error("Deletion of group at path '" + path +
                                         "' failed! Wrong path?");
            }
        }
        // group does not exist, do nothing
    }
 
    HDFGroup() = default;
 
    HDFGroup(const HDFGroup& other) = default;
 
    HDFGroup(HDFGroup&& other)  = default;
    HDFGroup&
    operator=(HDFGroup&& other) = default;
    HDFGroup&
    operator=(const HDFGroup& other) = default;
    template < HDFCategory cat >
    HDFGroup(HDFObject< cat >& parent, std::string path)
    {
        open(parent, path);
    }
 
    virtual ~HDFGroup() = default;
}; // namespace Utopia
 
void
swap(HDFGroup& lhs, HDFGroup& rhs)
{
    lhs.swap(rhs);
}
 
} // namespace DataIO
} // namespace Utopia
 
#endif