clock.hpp

#pragma once
 
#include <ossia/detail/config.hpp>
#include <ossia/detail/thread.hpp>
 
#include <ossia/editor/scenario/time_value.hpp>
 
#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <thread>
 
namespace ossia
{
class state;
class time_interval;
using clock_type = std::chrono::steady_clock;
class OSSIA_EXPORT clock
{
  friend class time_interval;
 
public:
  enum exec_status
  {
    RUNNING,
    STOPPED
  };
  using exec_status_callback = std::function<void(exec_status)>;

  clock(ossia::time_interval& cst, double time_ratio = 1000.);

  ~clock();

  void start_and_tick();

  void stop();

  void pause();

  [[nodiscard]] bool paused() const;

  void resume();

  bool tick();

  [[nodiscard]] time_value get_duration() const;

  clock& set_duration(ossia::time_value);

  [[nodiscard]] time_value get_granularity() const;

  clock& set_granularity(std::chrono::microseconds);
  clock& set_granularity(std::chrono::milliseconds);

  [[nodiscard]] bool running() const;

  [[nodiscard]] time_value get_position() const;

  [[nodiscard]] time_value get_date() const;
 
  // Execution status will be called when the clock starts and stops.
  void set_exec_status_callback(exec_status_callback);
  [[nodiscard]] exec_status_callback get_exec_status_callback() const;
 
private:
  void do_set_duration(ossia::time_value);

  void request_stop();
 
  time_interval& m_interval;
 
  double m_ratio{};
 
  time_value m_duration{}; 

  time_value m_granularity{}; 

  time_value m_date{};
 
  ossia::thread m_thread; 

  clock_type::time_point m_lastTime{};
 
  exec_status_callback m_statusCallback;

  int64_t m_elapsedTime{};
 
  std::atomic_bool m_running{}; 
  std::atomic_bool m_paused{};  
  std::atomic_bool m_shouldStop{};

  void thread_callback();
};
}