protocol.hpp

#pragma once
#include <ossia/detail/config.hpp>
 
#include <ossia/network/base/message_origin_identifier.hpp>
#include <ossia/network/common/network_logger.hpp>
 
#include <tcb/span.hpp>
 
#include <nano_signal_slot.hpp>
 
#include <future>
#include <memory>
#include <vector>
 
namespace ossia
{
class value;
struct bundle_element;
namespace net
{
class parameter_base;
class node_base;
class device_base;
struct full_parameter_data;
 
class protocol_base;
 
class OSSIA_EXPORT protocol_base
{
public:
  enum flags
  {
    SupportsMultiplex = (1 << 0)
  };
 
  explicit protocol_base()
      : m_flags{}
  {
  }
  explicit protocol_base(flags f)
      : m_flags{f}
  {
  }
  protocol_base(const protocol_base&) = delete;
  protocol_base(protocol_base&&) = delete;
  protocol_base& operator=(const protocol_base&) = delete;
  protocol_base& operator=(protocol_base&&) = delete;
 
  virtual ~protocol_base();
 
  virtual bool pull(parameter_base&) = 0;
 
  virtual std::future<void> pull_async(parameter_base&);
 
  virtual void request(parameter_base&);
 
  virtual bool push(const parameter_base&, const ossia::value& v) = 0;
  virtual bool push(const parameter_base&, ossia::value&& v);
  bool push(const parameter_base& p);
 
  virtual bool echo_incoming_message(
      const message_origin_identifier&, const parameter_base&, const ossia::value& v);
 
  virtual bool push_bundle(const std::vector<const ossia::net::parameter_base*>&);
  virtual bool push_bundle(tcb::span<ossia::bundle_element>);
  virtual bool push_bundle_bounded(tcb::span<ossia::bundle_element>);
 
  virtual bool push_raw(const full_parameter_data&) = 0;
 
  virtual bool push_raw_bundle(const std::vector<full_parameter_data>&);
 
  virtual bool observe(parameter_base&, bool) = 0;
 
  virtual bool publish(const parameter_base&);
 
  virtual bool unpublish(const parameter_base&);
 
  virtual bool observe_quietly(parameter_base&, bool) { return false; }
 
  virtual std::future<void> update_async(node_base& node_base);
 
  virtual bool update(node_base& node_base) = 0;
 
  virtual void set_device(ossia::net::device_base& dev);
 
  virtual void set_logger(const network_logger& l) { m_logger = l; }
 
  virtual const network_logger& get_logger() const noexcept { return m_logger; }
 
  virtual bool connected() const noexcept;
  virtual void connect();
  Nano::Signal<void()> on_connection_open;
  Nano::Signal<void()> on_connection_closed;
  Nano::Signal<void()> on_connection_failure;
 
  virtual void start_execution() { }
  virtual void stop_execution() { }
  virtual void stop() { }
 
  flags get_flags() const noexcept { return m_flags; }
  bool test_flag(flags f) const noexcept { return m_flags & f; }
 
protected:
  const flags m_flags{};
  network_logger m_logger;
};
 
template <typename T>
class can_learn : public T
{
public:
  using T::T;
 
  bool learning() const noexcept { return m_learning; }
 
  void set_learning(bool v) noexcept { m_learning = v; }
 
private:
  std::atomic_bool m_learning{};
};
 
}
}