UniqueID.h

Go to the documentation of this file.

#pragma once
 
#include "MantidNexus/DllConfig.h"
#include "MantidNexus/NexusFile_fwd.h"
#include <atomic>
 
// Forward declarations for needed HDF5 functions
// NOTE declare extern "C" to prevent conflict with actual declaration
// NOTE use MYH5DLL, set to match HDF5's H5_DLL, to allow Windows build
#if defined(_MSC_VER) // on Windows builds
#define MYH5DLL __declspec(dllimport)
#else
#define MYH5DLL // gcc and clang do not need a DLL specifier
#endif
extern "C" {
MYH5DLL herr_t H5Iis_valid(hid_t);
MYH5DLL herr_t H5Fclose(hid_t);
MYH5DLL herr_t H5garbage_collect();
}
 
namespace Mantid::Nexus {
 
constexpr hid_t INVALID_HID{-1};
 
template <herr_t (*const D)(hid_t)> class Hdf5ID {
protected:
  hid_t m_id;
 
  void close();
 
public:
  // constructors
  Hdf5ID() noexcept : m_id(INVALID_HID) {}
  Hdf5ID(hid_t const id) noexcept : m_id(id) {}
 
  // comparators
  bool operator==(hid_t const id) const { return m_id == id; }
  bool operator!=(hid_t const id) const { return m_id != id; }
  bool operator<=(hid_t const id) const { return m_id <= id; }
  bool operator<(hid_t const id) const { return m_id < id; }
 
  hid_t get() const { return m_id; }
  operator hid_t() const { return m_id; }
  bool isValid() const {
    // fail early condition
    if (m_id <= 0) {
      return false;
    } else {
      return H5Iis_valid(m_id) > 0;
    }
  }
};
 
template <herr_t (*const closer)(hid_t)> inline void Hdf5ID<closer>::close() {
  if (this->isValid()) {
    closer(this->m_id);
    this->m_id = INVALID_HID;
  }
}
 
template <> inline void Hdf5ID<&H5Fclose>::close() {
  if (this->isValid()) {
    H5Fclose(this->m_id);
    this->m_id = INVALID_HID;
    // call garbage collection to close any and all open objects on this file
    H5garbage_collect();
  }
}
 
// ******************************************************************
// UNIQUE ID
// ******************************************************************
 
template <herr_t (*const D)(hid_t)> class UniqueID : public Hdf5ID<D> {
private:
  // prohibit copying a unique ID
  UniqueID(UniqueID<D> const &) = delete;
  UniqueID &operator=(UniqueID<D> const &) = delete;
 
public:
  // constructors / destructor
  UniqueID() : Hdf5ID<D>() {}
  UniqueID(hid_t const id) : Hdf5ID<D>(id) {}
  UniqueID(UniqueID<D> &&uid) noexcept : Hdf5ID<D>(uid.m_id) { uid.m_id = INVALID_HID; }
  ~UniqueID() { this->close(); }
 
  // assignment
  UniqueID<D> &operator=(hid_t const);
  UniqueID<D> &operator=(UniqueID<D> &&);
 
  void reset() { reset(INVALID_HID); };
  void reset(hid_t const);
  void reset(UniqueID<D> const &) = delete;
  void reset(UniqueID<D> &&);
  hid_t release();
};
 
template <herr_t (*const D)(hid_t)> inline hid_t UniqueID<D>::release() {
  hid_t tmp = this->m_id;
  this->m_id = INVALID_HID;
  return tmp;
}
 
template <herr_t (*const D)(hid_t)> inline void UniqueID<D>::reset(hid_t const id) {
  if (this->m_id != id) {
    this->close();
    this->m_id = id;
  }
}
 
template <herr_t (*const D)(hid_t)> inline void UniqueID<D>::reset(UniqueID<D> &&uid) {
  if (this != &uid) {
    reset(uid.m_id);
    uid.m_id = INVALID_HID;
  }
}
 
template <herr_t (*const D)(hid_t)> inline UniqueID<D> &UniqueID<D>::operator=(hid_t const id) {
  reset(id);
  return *this;
}
 
template <herr_t (*const D)(hid_t)> inline UniqueID<D> &UniqueID<D>::operator=(UniqueID<D> &&uid) {
  reset(std::move(uid));
  return *this;
}
 
// ******************************************************************
// SHARED ID
// ******************************************************************
 
template <herr_t (*const D)(hid_t)> class SharedID : public Hdf5ID<D> {
private:
  std::atomic<std::size_t> *m_leash_counts;
  void increment_leash_counts();
  void decrement_leash_counts();
 
public:
  // constructors / destructor
  SharedID() : Hdf5ID<D>(), m_leash_counts(nullptr) {}
  SharedID(hid_t id) : Hdf5ID<D>(id), m_leash_counts(this->isValid() ? new std::atomic<std::size_t>(1) : nullptr) {}
  SharedID(SharedID<D> const &uid) : Hdf5ID<D>(uid.m_id), m_leash_counts(uid.m_leash_counts) {
    increment_leash_counts();
  }
  SharedID(SharedID<D> &&uid) : Hdf5ID<D>(uid.m_id), m_leash_counts(uid.m_leash_counts) {
    uid.m_id = INVALID_HID;
    uid.m_leash_counts = nullptr;
  }
  ~SharedID() { decrement_leash_counts(); }
 
  SharedID<D> &operator=(hid_t const);
  SharedID<D> &operator=(SharedID<D> const &);
  SharedID<D> &operator=(SharedID<D> &&);
 
  bool operator==(SharedID<D> const &uid) const {
    if (m_leash_counts == uid.m_leash_counts) {
      return this->m_id == uid.m_id;
    } else {
      return false;
    }
  }
 
  std::size_t use_count() const { return (m_leash_counts ? (*m_leash_counts).load() : 0); }
 
  void reset() { reset(INVALID_HID); };
  void reset(hid_t const);
  void reset(SharedID<D> const &);
  void reset(SharedID<D> &&);
};
 
template <herr_t (*const D)(hid_t)> inline void SharedID<D>::reset(hid_t const id) {
  if (this->m_id != id) {
    decrement_leash_counts();
    this->m_id = id;
    m_leash_counts = nullptr;
    increment_leash_counts();
  }
}
 
template <herr_t (*const D)(hid_t)> inline void SharedID<D>::reset(SharedID<D> const &uid) {
  if (&uid != this && uid.m_id != this->m_id) {
    decrement_leash_counts();
    this->m_id = uid.m_id;
    m_leash_counts = uid.m_leash_counts;
    increment_leash_counts();
  }
}
 
template <herr_t (*const D)(hid_t)> inline void SharedID<D>::reset(SharedID<D> &&uid) {
  if (&uid != this && uid.m_id != this->m_id) {
    decrement_leash_counts();
    this->m_id = uid.m_id;
    m_leash_counts = uid.m_leash_counts;
    // unset the moved id
    uid.m_id = INVALID_HID;
    uid.m_leash_counts = nullptr;
    // no increment -- number of leashes is same
  }
}
 
template <herr_t (*const D)(hid_t)> inline void SharedID<D>::increment_leash_counts() {
  if (this->isValid()) {
    if (!m_leash_counts) {
      m_leash_counts = new std::atomic<std::size_t>(1);
    } else {
      (*m_leash_counts)++;
    }
  }
}
 
template <herr_t (*const D)(hid_t)> inline void SharedID<D>::decrement_leash_counts() {
  if (m_leash_counts) {
    // atomic-safe access the counts
    std::size_t prev_counts = (*m_leash_counts).fetch_sub(1);
    if (prev_counts == 1) {
      this->close();
      delete m_leash_counts;
      m_leash_counts = nullptr;
    } else if (prev_counts == 0) {
      m_leash_counts->store(0);
      delete m_leash_counts;
      m_leash_counts = nullptr;
    }
  }
}
 
template <herr_t (*const D)(hid_t)> inline SharedID<D> &SharedID<D>::operator=(hid_t id) {
  reset(id);
  return *this;
}
 
template <herr_t (*const D)(hid_t)> inline SharedID<D> &SharedID<D>::operator=(SharedID<D> const &uid) {
  reset(uid);
  return *this;
}
 
template <herr_t (*const D)(hid_t)> inline SharedID<D> &SharedID<D>::operator=(SharedID<D> &&uid) {
  reset(std::move(uid));
  return *this;
}
 
} // namespace Mantid::Nexus