hdfobject.hh

Go to the documentation of this file.

#ifndef UTOPIA_DATAIO_HDFOBJECT_HH
#define UTOPIA_DATAIO_HDFOBJECT_HH
 
#include <hdf5.h>
#include <memory>
 
#include "hdfidentifier.hh"
#include "hdfutilities.hh"
 
#include <utopia/core/logging.hh>
 
namespace Utopia
{
namespace DataIO
{
 
template < HDFCategory objectcategory >
class HDFObject
{
  protected:
    HDFIdentifier _id;
 
    std::string _path;
 
    std::shared_ptr< spdlog::logger > _log;
 
  public:
    static constexpr HDFCategory category = objectcategory;
 
    void
    swap(HDFObject& other)
    {
        using std::swap;
        swap(_id, other._id);
        swap(_path, other._path);
        swap(_log, other._log);
    }
 
    // implement open and close in a sensible way here, preferably without crtp,
    // and by employing the identifier's management abilities
 
    std::string
    get_path() const
    {
        return _path;
    }
 
    auto
    get_id_object() const
    {
        return _id;
    }
 
    auto
    get_logger() const
    {
        return _log;
    }
    hid_t
    get_C_id() const
    {
        return _id.get_id();
    }
 
    auto
    get_refcount()
    {
        return _id.get_refcount();
    }
 
    virtual bool
    is_valid() const
    {
        if (get_C_id() == -1)
        {
            return false;
        }
        else
        {
            // use check_validity to provide correct name
            return check_validity(H5Iis_valid(get_C_id()), _path);
        }
    }
 
    void
    close()
    {
 
        if (is_valid())
        {
            _id.close();
 
            _path = "";
        }
    }
 
    // README: the 'bind_to' function is not named 'open' to avoid confusion wrt
    // to 'open' functions in derived classes. The latter have vastly differing
    // arguments and hence cannot be prototyped here. Furthermore their
    // functionality is more high level than this function.
 
    void
    bind_to(hid_t                          id,
            std::function< herr_t(hid_t) > closing_func,
            std::string                    path = {})
    {
        if (is_valid())
        {
            throw std::runtime_error("Error: Cannot bind object to new "
                                     "identifier while the old is still valid");
        }
 
        if (not check_validity(H5Iis_valid(id), path))
        {
            throw std::invalid_argument(
                "Error: invalid argument! The id given "
                "for an object of " +
                generate_object_name(*this) +
                " cannot be managed by an HDFObject instance!");
        }
 
        _log->debug("Opening object of ", generate_object_name(*this));
 
        _id.open(id, closing_func);
 
        if (path.size() == 0)
        {
            // putting some stupid special treatments here because HDF5
            // cannot handle things generically
 
            // attribute has to be treated separately
            if constexpr (category == HDFCategory::attribute)
            {
                _path.resize(H5Aget_name(id, 0, NULL) + 1);
 
                H5Aget_name(id, _path.size(), _path.data());
            }
            else
            {
 
                // a preliminary call to H5Iget_name will give the needed size.
                // cumbersome, but works. The +1 is for the null terminator
                _path.resize(H5Iget_name(id, NULL, 0)+1);
 
                // then, a second call will give the full name
                H5Iget_name(id, _path.data(), _path.size());
 
            }
 
            // remove the final 0 character, as std::string does not require it
            _path.pop_back();
        }
        else
        {
            _path = path;
        }
    }
 
    HDFObject() : _id(), _path(""), _log(spdlog::get("data_io"))
    {
    }
 
    HDFObject(HDFObject&& other) :
        _id(std::move(other._id)), _path(std::move(other._path)),
        _log(std::move(other._log))
    {
        other._id.set_id(-1);
    }
 
    HDFObject(const HDFObject& other) = default;
 
    HDFObject(hid_t                          id,
              std::function< herr_t(hid_t) > closing_func,
              std::string                    path = {}) :
        _log(spdlog::get("data_io"))
    {
        bind_to(id, closing_func, path);
    }
 
    HDFObject&
    operator=(const HDFObject& other)
    {
        _id   = other._id;
        _path = other._path;
        _log  = other._log;
 
        return *this;
    }
 
    HDFObject&
    operator=(HDFObject&& other)
    {
        _id   = std::move(other._id);
        _path = std::move(other._path);
        _log  = std::move(other._log);
 
        other._id.set_id(-1);
 
        return *this;
    }
 
    virtual ~HDFObject()
    {
        close();
    }
};
 
template < HDFCategory cat >
void
swap(HDFObject< cat >& lhs, HDFObject< cat >& rhs)
{
    lhs.swap(rhs);
}
 
}
}
#endif