time_sync.hpp

Go to the documentation of this file.

#pragma once
#include <ossia/detail/config.hpp>
 
#include <ossia/detail/flicks.hpp>
#include <ossia/detail/ptr_container.hpp>
#include <ossia/editor/expression/expression.hpp>
#include <ossia/editor/scenario/time_event.hpp>
#include <ossia/editor/scenario/time_value.hpp>
 
#include <atomic>
#include <memory>

namespace ossia
{
class expression_base;
class state;
class time_event;
class scenario;
struct OSSIA_EXPORT time_sync_callback
{
  virtual ~time_sync_callback();
 
  virtual void triggered();

  virtual void entered_evaluation();

  virtual void entered_triggering();

  virtual void trigger_date_fixed(ossia::time_value);

  virtual void left_evaluation();

  virtual void finished_evaluation(bool);
};
 
struct OSSIA_EXPORT time_sync_callbacks
{
  ossia::small_vector<time_sync_callback*, 2> callbacks;
 
  void clear()
  {
    for(auto cb : callbacks)
      delete cb;
    callbacks.clear();
  }
 
  void triggered()
  {
    for(auto v : callbacks)
      v->triggered();
  }
 
  void entered_evaluation()
  {
    for(auto v : callbacks)
      v->entered_evaluation();
  }
 
  void entered_triggering()
  {
    for(auto v : callbacks)
      v->entered_triggering();
  }
 
  void trigger_date_fixed(ossia::time_value t)
  {
    for(auto v : callbacks)
      v->trigger_date_fixed(t);
  }
 
  void left_evaluation()
  {
    for(auto v : callbacks)
      v->left_evaluation();
  }
 
  void finished_evaluation(bool b)
  {
    for(auto v : callbacks)
      v->finished_evaluation(b);
  }
};

class OSSIA_EXPORT time_sync final
{
  friend class ossia::scenario;
 
public:
  using container = ossia::small_vector<std::shared_ptr<time_event>, 2>;
  using iterator = container::iterator;
  using const_iterator = container::const_iterator;
 
  time_sync();
  ~time_sync();

  [[nodiscard]] time_value get_date() const noexcept;

  [[nodiscard]] const expression& get_expression() const noexcept;

  time_sync& set_expression(expression_ptr) noexcept;

  iterator emplace(
      const_iterator, time_event::exec_callback,
      expression_ptr = expressions::make_expression_true());
  iterator insert(const_iterator, std::shared_ptr<time_event>);
  void remove(const std::shared_ptr<time_event>&);

  auto& get_time_events() noexcept { return m_timeEvents; }

  [[nodiscard]] const auto& get_time_events() const noexcept { return m_timeEvents; }
 
  // Interface to be used for set-up by other time processes
  [[nodiscard]] bool is_observing_expression() const noexcept;
  [[nodiscard]] bool is_evaluating() const noexcept;

  void start_trigger_request() noexcept;
  void end_trigger_request() noexcept;

  [[nodiscard]] bool is_autotrigger() const noexcept;
  void set_autotrigger(bool) noexcept;
 
  [[nodiscard]] bool is_start() const noexcept;
  void set_start(bool) noexcept;

  void observe_expression(bool);
  inline void observe_expression(bool b, auto&& cb)
  {
    if(!m_expression || m_expression->target<ossia::expressions::expression_bool>())
      return;
    return observe_expression_impl(b, std::move(cb));
  }
  void observe_expression_impl(bool, ossia::expressions::expression_result_callback cb);

  void reset();
 
  /* To be called before deletion, to break the shared_ptr cycle */
  void cleanup();
 
  void mute(bool b);
  [[nodiscard]] bool muted() const noexcept { return m_muted; }

  time_sync_callbacks callbacks;
 
  enum class status : uint8_t
  {
    NOT_DONE,
    DONE_TRIGGERED,
    DONE_MAX_REACHED
  };
  [[nodiscard]] status get_status() const noexcept { return m_status; }
 
  void set_sync_rate(double syncRatio) noexcept { m_sync_rate = syncRatio; }
  [[nodiscard]] double get_sync_rate() const noexcept { return m_sync_rate; }
  [[nodiscard]] bool has_sync_rate() const noexcept { return m_sync_rate > 0; }
 
  void set_trigger_date(time_value v) noexcept
  {
    m_trigger_date = v;
    callbacks.trigger_date_fixed(v);
  }
  [[nodiscard]] time_value get_trigger_date() const noexcept { return m_trigger_date; }
  [[nodiscard]] bool has_trigger_date() const noexcept
  {
    return !m_trigger_date.infinite();
  }
 
  void set_is_being_triggered(bool v) noexcept;
  [[nodiscard]] bool is_being_triggered() const noexcept { return m_is_being_triggered; }
 
private:
  ossia::expression_ptr m_expression;
  container m_timeEvents;
 
  std::optional<expressions::expression_callback_iterator> m_callback;
 
  double m_sync_rate = 0.;
 
  std::atomic_bool trigger_request{};
  time_value m_trigger_date = Infinite;
  status m_status : 2;
  bool m_start : 1;
  bool m_observe : 1;
  bool m_evaluating : 1;
  bool m_muted : 1;
  bool m_autotrigger : 1;
  bool m_is_being_triggered : 1;
};
 
}