hdfidentifier.hh

Go to the documentation of this file.

#ifndef UTOPIA_DATAIO_HDFIDENTIFIER_HH
#define UTOPIA_DATAIO_HDFIDENTIFIER_HH
 
#include <functional>
 
#include <hdf5.h>
 
#include "hdfutilities.hh"
 
namespace Utopia
{
namespace DataIO
{
 
class HDFIdentifier final
{
    hid_t                          _id = -1;
    std::function< herr_t(hid_t) > _closing_func;
 
  public:
    void
    swap(HDFIdentifier& other)
    {
        using std::swap;
        swap(_id, other._id);
        swap(_closing_func, other._closing_func);
    }
 
    hid_t
    get_id() const
    {
        return _id;
    }
 
    void
    set_id(hid_t id)
    {
        _id = id;
    }
 
    bool
    is_valid() const
    {
        return check_validity(H5Iis_valid(_id), "identifier");
    }
 
    auto
    get_refcount() const
    {
        if (is_valid())
        {
            return H5Iget_ref(_id);
        }
        else
        {
            return -1;
        }
    }
 
    void
    increment_refcount()
    {
        if (is_valid())
        {
            H5Iinc_ref(_id);
        }
    }
 
    void
    decrement_refcount()
    {
        if (is_valid())
        {
            H5Idec_ref(_id);
        }
    }
 
    void
    close()
    {
        if (is_valid())
        {
            if (H5Iget_ref(_id) > 1)
            {
                decrement_refcount();
            }
            else
            {
                _closing_func(_id);
            }
        }
        _id = -1;
    }
 
    void
    open(hid_t id, std::function< herr_t(hid_t) > closing_func)
    {
        if (is_valid())
        {
            throw std::runtime_error(
                "Error, HDFIdentifier cannot bind to new identifier while "
                "still being valid. Close first.");
        }
        _id           = id;
        _closing_func = closing_func;
    }
 
    HDFIdentifier(hid_t id, std::function< herr_t(hid_t) > closing_func)
    {
        open(id, closing_func);
    }
 
    HDFIdentifier() : _id(-1), _closing_func([](hid_t) -> herr_t { return 0; })
    {
    }
 
    HDFIdentifier(const HDFIdentifier& other) :
        _id(other._id), _closing_func(other._closing_func)
    {
        increment_refcount();
 
    }
 
    HDFIdentifier(HDFIdentifier&& other) :
        _id(std::move(other._id)), _closing_func(std::move(other._closing_func))
    {
        other._id = -1;
    }
 
    HDFIdentifier&
    operator=(const HDFIdentifier& other)
    {
        _id           = other._id;
        _closing_func = other._closing_func;
 
        increment_refcount();
        return *this;
    }
 
    HDFIdentifier&
    operator=(HDFIdentifier&& other)
    {
        _id       = std::move(other._id);
        other._id = -1;
        return *this;
    }
 
    ~HDFIdentifier()
    {
        close();
    }
};
 
// comparison operators
 
bool
operator==(const HDFIdentifier& lhs, const HDFIdentifier& rhs)
{
    return rhs.get_id() == lhs.get_id();
}
 
bool
operator!=(const HDFIdentifier& lhs, const HDFIdentifier& rhs)
{
    return not(lhs == rhs);
}
 
void
swap(HDFIdentifier& lhs, HDFIdentifier& rhs)
{
    lhs.swap(rhs);
}
 
 
}
}
 
#endif