time_event.hpp

Go to the documentation of this file.

#pragma once
#include <ossia/detail/config.hpp>
 
#include <ossia/detail/ptr_container.hpp>
#include <ossia/editor/expression/expression_fwd.hpp>
#include <ossia/editor/scenario/time_value.hpp>
 
#include <cstdint>
#include <functional>
#include <memory>
 
namespace ossia
{
class state;
class time_interval;
class time_sync;
class time_process;
class scenario;
class OSSIA_EXPORT time_event
{
  friend class ossia::scenario;
 
public:
  enum class status : uint8_t
  {
    NONE = 0b00000000,
    PENDING = 0b00000001,
    HAPPENED = 0b00000010,
    DISPOSED = 0b00000011,
    FINISHED = 0b10000000
  };
 
  enum class offset_behavior : uint8_t
  {
    EXPRESSION_TRUE,  
    EXPRESSION_FALSE, 
    EXPRESSION        
  };
 
  using exec_callback = std::function<void(status)>;
 
public:
  time_event(
      time_event::exec_callback, time_sync& aTimeSync, expression_ptr anExpression);
 
  ~time_event();
 
  void set_callback(time_event::exec_callback);
 
  void add_time_process(std::shared_ptr<time_process>);
  void remove_time_process(time_process*);
  [[nodiscard]] const auto& get_time_processes() const { return m_processes; }
 
  void tick(ossia::time_value date, ossia::time_value offset);
 
  [[nodiscard]] time_sync& get_time_sync() const;
 
  void set_time_sync(time_sync&);
 
  [[nodiscard]] const expression& get_expression() const;
 
  time_event& set_expression(expression_ptr);
 
  [[nodiscard]] status get_status() const;
 
  [[nodiscard]] offset_behavior get_offset_behavior() const;
 
  time_event& set_offset_behavior(offset_behavior);
 
  auto& previous_time_intervals() { return m_previous_time_intervals; }
 
  [[nodiscard]] const auto& previous_time_intervals() const
  {
    return m_previous_time_intervals;
  }
 
  auto& next_time_intervals() { return m_next_time_intervals; }
 
  [[nodiscard]] const auto& next_time_intervals() const { return m_next_time_intervals; }
 
  void set_status(status s);
 
  void reset();
 
  /* To be called before deletion, to break the shared_ptr cycle */
  void cleanup();
 
  void mute(bool m);
 
private:
  time_event::exec_callback m_callback;
 
  time_sync* m_timesync{};
  ossia::small_vector<std::shared_ptr<time_process>, 1> m_processes;
  status m_status;
  offset_behavior m_offset{offset_behavior::EXPRESSION_TRUE};
 
  expression_ptr m_expression;
 
  small_ptr_container<time_interval, 1> m_previous_time_intervals;
  small_ptr_container<time_interval, 1> m_next_time_intervals;
};
 
inline constexpr auto
operator&(ossia::time_event::status lhs, ossia::time_event::status rhs) noexcept
{
  using t = std::underlying_type_t<ossia::time_event::status>;
  return static_cast<t>(lhs) & static_cast<t>(rhs);
}
}