SynchronizedValue.hpp

#ifndef DITTO_SYNCHRONIZEDVALUE_H
#define DITTO_SYNCHRONIZEDVALUE_H
 
#include <functional>
#include <mutex>
#include <type_traits>
#include <utility>
 
namespace ditto {
 
// Elements in the ditto::internal namespace are not considered to be part of
// the public Ditto C++ API, and may change at any time. Do not use them in
// customer code.
namespace internal {
 
// Inspired by the proposal for a C++ std::synchronized_value<T> type
// <https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p0290r3.html>
// but compatible with C++11.

template <class T, class Mutex = std::mutex> class SynchronizedValue {
private:
  mutable Mutex mtx;
  T value;
 
  template <class R_, class F_, class T_, class M_>
  friend R_ apply(F_ &&f, SynchronizedValue<T_, M_> &sv);
 
  template <class R_, class F_, class T_, class M_>
  friend R_ apply(F_ &&f, const SynchronizedValue<T_, M_> &sv);
 
  template <class F_, class T_, class M_>
  friend void apply(F_ &&f, SynchronizedValue<T_, M_> &sv);
 
  template <class F_, class T_, class M_>
  friend void apply(F_ &&f, const SynchronizedValue<T_, M_> &sv);
 
  template <class F_, class T_, class U_, class M_, class N_>
  friend void apply(F_ &&f, SynchronizedValue<T_, M_> &lhs,
                    SynchronizedValue<U_, N_> &rhs);
 
public:
  using mutex_type = Mutex;
  using value_type = T;

  template <class U = T,
            typename std::enable_if<std::is_default_constructible<U>::value,
                                    int>::type = 0>
  SynchronizedValue() : value() {}

  SynchronizedValue(const T &desired) : value(desired) {}

  SynchronizedValue(T &&desired) noexcept(
      std::is_nothrow_move_constructible<T>::value)
      : value(std::move(desired)) {}
 
  ~SynchronizedValue() = default;
 
  SynchronizedValue(const SynchronizedValue &) = delete;
  SynchronizedValue &operator=(const SynchronizedValue &) = delete;
  SynchronizedValue(SynchronizedValue &&) = delete;
  SynchronizedValue &operator=(SynchronizedValue &&) = delete;

  void apply(std::function<void(T &)> f) {
    std::lock_guard<Mutex> lock(mtx);
    f(value);
  }

  void apply(std::function<void(const T &)> f) const {
    std::lock_guard<Mutex> lock(mtx);
    f(value);
  }

  T get() const {
    std::lock_guard<Mutex> lock(mtx);
    return value;
  }

  T exchange(T new_value) {
    std::lock_guard<Mutex> lock(mtx);
    T old_value = std::move(value);
    value = std::move(new_value);
    return old_value;
  }

  void operator=(const T &desired) {
    std::lock_guard<Mutex> lock(mtx);
    value = desired;
  }

  void operator=(T &&desired) {
    std::lock_guard<Mutex> lock(mtx);
    value = std::move(desired);
  }
};

template <class R, class F, class T, class M>
R apply(F &&f, SynchronizedValue<T, M> &sv) {
  std::lock_guard<M> lock(sv.mtx);
  return f(sv.value);
}

template <class R, class F, class T, class M>
R apply(F &&f, const SynchronizedValue<T, M> &sv) {
  std::lock_guard<M> lock(sv.mtx);
  return f(sv.value);
}

template <class F, class T, class M>
void apply(F &&f, SynchronizedValue<T, M> &sv) {
  std::lock_guard<M> lock(sv.mtx);
  f(sv.value);
}

template <class F, class T, class M>
void apply(F &&f, const SynchronizedValue<T, M> &sv) {
  std::lock_guard<M> lock(sv.mtx);
  f(sv.value);
}

template <class F, class T, class U, class M, class N>
void apply(F &&f, SynchronizedValue<T, M> &lhs, SynchronizedValue<U, N> &rhs) {
  if ((void *)&lhs == (void *)&rhs) {
    // same object, so only lock once
    std::lock_guard<M> lock(lhs.mtx);
    f(lhs.value, rhs.value);
  } else {
    std::lock(lhs.mtx, rhs.mtx);
    std::lock_guard<M> lock_lhs(lhs.mtx, std::adopt_lock);
    std::lock_guard<N> lock_rhs(rhs.mtx, std::adopt_lock);
    f(lhs.value, rhs.value);
  }
}

template <class T, class M, class N>
void swap(SynchronizedValue<T, M> &lhs, SynchronizedValue<T, N> &rhs) {
  if ((void *)&lhs == (void *)&rhs) {
    return;
  }
  apply([](T &a, T &b) { std::swap(a, b); }, lhs, rhs);
}
 
} // namespace internal
 
} // namespace ditto
 
#endif