PropertyValueStorage.h

Go to the documentation of this file.

#ifndef LINTEL_PROPERTYVALUESTORAGE_H
#define LINTEL_PROPERTYVALUESTORAGE_H
 
#include <atomic>
#include <shared_mutex>
#include <type_traits>
 
namespace lintel {
template<class T, class Enable = void> struct IsLockFreeAtomic : std::false_type
{
};
 
template<class T>
struct IsLockFreeAtomic<T, std::enable_if_t<std::is_trivially_copyable_v<T>>>
  : std::bool_constant<std::atomic<T>::is_always_lock_free>
{
};
 
template<class T, class Enable = void> class PropertyValueStorage
{
private:
  mutable std::shared_mutex m_mutex;
  T m_value;
 
public:
  PropertyValueStorage() : m_value() {}
 
  explicit PropertyValueStorage(const T &value) : m_value(value) {}
 
  T load() const
  {
    std::shared_lock<std::shared_mutex> lock(m_mutex);
    return m_value;
  }
 
  void store(const T &value)
  {
    std::lock_guard<std::shared_mutex> lock(m_mutex);
    m_value = value;
  }
 
  [[nodiscard]] static constexpr bool isLockFree() { return false; }
};
 
template<class T> class PropertyValueStorage<T, std::enable_if_t<IsLockFreeAtomic<T>::value>>
{
private:
  std::atomic<T> m_value;
 
public:
  PropertyValueStorage() : m_value() {}
 
  explicit PropertyValueStorage(const T &value) : m_value(value) {}
 
  T load() const { return m_value.load(std::memory_order_relaxed); }
 
  void store(const T &value) { m_value.store(value, std::memory_order_relaxed); }
 
  [[nodiscard]] static constexpr bool isLockFree() { return std::atomic<T>::is_always_lock_free; }
};
 
}// namespace lintel
#endif// LINTEL_PROPERTYVALUESTORAGE_H