AtomicWrapper.h

Go to the documentation of this file.

#ifndef VolViz_AtomicWrapper_h
#define VolViz_AtomicWrapper_h

#include <mutex>
#include <functional>

#pragma clang diagnostic ignored "-Wpadded"

namespace VolViz {

template <class T> class DefaultSetPolicy {
protected:
  inline void set(T &dest, T const &src) const noexcept { dest = src; }
  inline void set(T &dest, T &&src) const noexcept { dest = std::move(src); }
};

template <class T> class SetAndNotifyPolicy : public DefaultSetPolicy<T> {
public:
  std::function<void(T const &)> beforeAction;

  std::function<void(T const &)> afterAction;

protected:
  template <class Arg> inline void set(T &dest, Arg &&src) const noexcept {
    if (beforeAction) beforeAction(src);
    DefaultSetPolicy<T>::set(dest, std::forward<Arg>(src));
    if (afterAction) afterAction(dest);
  }
};

template <class T, template <class> class SetPolicy = DefaultSetPolicy>
class AtomicWrapper : public SetPolicy<T> {
  using SetPol = SetPolicy<T>;

public:
  explicit AtomicWrapper(T const &obj) : obj_(obj) {}
  explicit AtomicWrapper(T &&obj) : obj_(std::move(obj)) {}

  AtomicWrapper(AtomicWrapper const &) = delete;
  AtomicWrapper &operator=(AtomicWrapper const &) = delete;

  operator T() const {
    std::lock_guard<std::mutex> lock(mutex_);
    auto cpy = obj_;
    return cpy;
  }

  AtomicWrapper &operator=(T const &rhs) {
    std::lock_guard<std::mutex> lock(mutex_);

    SetPol::set(obj_, rhs);

    return *this;
  }

  AtomicWrapper &operator=(T &&rhs) {
    std::lock_guard<std::mutex> lock(mutex_);

    SetPol::set(obj_, std::move(rhs));

    return *this;
  }

private:
  T obj_;

  mutable std::mutex mutex_;
};

} // namespace VolViz

#endif // VolViz_AtomicWrapper_h