clock.hpp

#pragma once
 
#include <ossia/detail/config.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{};
 
  std::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();
};
}