Monitor.hpp

#pragma once
#include <ossia/detail/triple_buffer.hpp>
 
#include <score_lib_process_export.h>
 
#include <atomic>
#include <cstdint>
#include <utility>
 
namespace Process
{
struct SCORE_LIB_PROCESS_EXPORT Monitor
{
  Monitor() noexcept;
  Monitor(const Monitor&) = delete;
  Monitor& operator=(const Monitor&) = delete;
  virtual ~Monitor();
 
  std::atomic<int> viewers{0};
 
  bool watched() const noexcept
  {
    return viewers.load(std::memory_order_relaxed) > 0;
  }
};
 
SCORE_LIB_PROCESS_EXPORT uint64_t monitorFrame() noexcept;
 
template <typename T>
class LatestValue
{
public:
  LatestValue() = default;
  explicit LatestValue(const T& init)
      : m_buffer{init}
      , m_last{init}
  {
  }
  LatestValue(const LatestValue&) = delete;
  LatestValue& operator=(const LatestValue&) = delete;
 
  template <typename U>
  void produce(U&& v)
  {
    m_buffer.produce(std::forward<U>(v));
  }
 
  bool consume(T& out)
  {
    const uint64_t frame = monitorFrame();
    if(frame == 0)
      return m_buffer.consume(out);
    if(frame != m_frame)
    {
      m_frame = frame;
      m_fresh = m_buffer.consume(m_last);
    }
    if(m_fresh)
      out = m_last;
    return m_fresh;
  }
 
private:
  ossia::triple_buffer<T> m_buffer;
  T m_last{};
  uint64_t m_frame{};
  bool m_fresh{};
};
}