ossia-cpp98.hpp

Go to the documentation of this file.

#ifndef OSSIA_CPP98_HPP_2017_07_07
#define OSSIA_CPP98_HPP_2017_07_07
#include <ossia_export.h>
 
#include <cstddef>
#include <string>
#include <vector>
#if(__cplusplus >= 201103L) || (defined(_MSC_VER) && (_MSC_VER >= 1900))
#define OSSIA_CPP_CXX11
#endif
 
namespace ossia
{
class value;
namespace net
{
class node_base;
class parameter_base;
class device_base;
class value;
struct parameter_data;
}
}
namespace opp
{
enum access_mode
{
  Get, 
  Set, 
  Bi   
};
enum bounding_mode
{
  Free, 
  Clip, 
  Wrap, 
  Fold, 
  Low,  
  High  
};
 
class node;
class oscquery_server;
class oscquery_mirror;
 
//**************************************//
//               value                  //
//*************************************//
 
class OSSIA_EXPORT value
{
public:
  struct vec2f
  {
    float data[2];
    float& operator[](int i) { return data[i]; }
  };
  struct vec3f
  {
    float data[3];
    float& operator[](int i) { return data[i]; }
  };
  struct vec4f
  {
    float data[4];
    float& operator[](int i) { return data[i]; }
  };
 
  struct impulse
  {
  };
 
  //*********************//
  //     Constructors    //
  //*********************//
 
  value();
  ~value();
  value(const value& v);
  value(char v);
  value(int v);
  value(bool v);
  value(float v);
  value(double v);
  value(const vec2f);
  value(const vec3f);
  value(const vec4f);
  value(std::vector<opp::value> v);
  value(std::string v);
  value(const char* v);
  value(impulse p);
 
  //*********************//
  //     Type tests      //
  //*********************//
 
  bool is_impulse() const;
  bool is_int() const;
  bool is_float() const;
  bool is_bool() const;
  bool is_vec2f() const;
  bool is_vec3f() const;
  bool is_vec4f() const;
  bool is_list() const;
  bool is_string() const;
 
  //*********************//
  //     Convertors      //
  //*********************//
 
  char to_char() const;
  int to_int() const;
  float to_float() const;
  bool to_bool() const;
  vec2f to_vec2f() const;
  vec3f to_vec3f() const;
  vec4f to_vec4f() const;
  std::vector<opp::value> to_list() const;
  std::string to_string() const;
 
  //*********************//
  // Assignment Operators //
  //*********************//
 
  value& operator=(const value& v);
  value& operator=(char v);
  value& operator=(int v);
  value& operator=(float v);
  value& operator=(bool v);
  value& operator=(vec2f v);
  value& operator=(vec3f v);
  value& operator=(vec4f v);
  value& operator=(std::vector<opp::value> v);
  value& operator=(std::string v);
 
  bool operator==(const opp::value& v) const;
 
  bool operator!=(const opp::value& v) const;
  void set_impulse();
  void set_int(int v);
  void set_float(float v);
  void set_bool(bool v);
  void set_vec2f(vec2f v);
  void set_vec3f(vec3f v);
  void set_vec4f(vec4f v);
  void set_list(std::vector<opp::value> v);
  void set_string(std::string v);
 
#if defined(OSSIA_CPP_CXX11)
  value(value&& v) noexcept;
  value& operator=(value&& v) noexcept;
#endif
 
  ossia::value* get_raw_value_pointer()
  {
    return m_val;
  }
 
private:
  friend class node;
  friend class oscquery_mirror; // needed to build an opp::value from a const
                                // ossia::value& in
                                // oscquery_mirror::on_unhandled_message_callback()
  value(const ossia::value& v);
  template <typename T>
  value(const T* v);
  ossia::value* m_val;
};
 
typedef void (*value_callback)(void*, const opp::value&);
typedef void (*connection_callback)(void*, const std::string&);
typedef void (*disconnection_callback)(void*, const std::string&);
typedef void (*parameter_callback)(void*, const opp::node&);
typedef void (*node_callback)(void*, const opp::node&);
typedef void (*node_rn_callback)(void*, const opp::node&, std::string);
typedef void (*message_callback)(void*, const opp::node&);
typedef void (*unhandled_message_callback)(void*, const std::string&, const opp::value&);
typedef void (*attribute_modified_callback)(void*, const opp::node&, const std::string&);
typedef bool (*rename_node_callback)(void*, const std::string&, const std::string&);
typedef bool (*remove_node_callback)(void*, const std::string&);
typedef bool (*add_node_callback)(void*, const std::string&, const std::string&);
 
struct OSSIA_EXPORT callback_index
{
  callback_index();
  ~callback_index();
  callback_index(const callback_index&);
  callback_index& operator=(const callback_index&);
  operator bool() const;
 
private:
  friend class node;
 
  struct impl;
  impl* index;
};
 
class OSSIA_EXPORT node
{
public:
  //*********************//
  //     Constructors    //
  //*********************//
 
  node();
  node(const node&);
  node& operator=(const node&);
 
  ~node();
 
  operator bool() const;
 
  node parent() const;
 
  void request_add_child(const std::string&);
 
  void request_remove_child(const std::string&);
 
  void request_rename_child(const std::string&, const std::string&);
 
  std::string get_name() const;
  void set_name(std::string s);
 
  bool has_parameter() const;
 
  std::string get_address() const;
  std::vector<node> get_namespace() const;
  std::vector<node> get_children() const;
  node find_child(std::string addr) const;
 
  std::vector<node> find_children(std::string pattern) const;
 
  void remove_child(std::string addr);
  void remove_children();
 
  //*********************//
  //     Create Nodes    //
  //*********************//
 
  node create_child(std::string addr);
 
  //*********************//
  //     Add parameters  //
  //*********************//
 
  void set_impulse();
  void set_char();
  void set_int();
  void set_float();
  void set_bool();
  void set_vec2f();
  void set_vec3f();
  void set_vec4f();
  void set_list();
  void set_string();
  void set_buffer();
  void set_filepath();
  void set_rgb();
  void set_rgba();
  void set_argb();
  void set_argb8();
  void set_rgba8();
  void set_hsv();
  void set_cart2D();
  void set_cart3D();
  void set_opengl();
  void set_polar();
  void set_spherical();
  void set_cylindrical();
  void set_angle_radian();
  void set_angle_degree();
  void set_quaternion();
  void set_euler();
  void set_axis();
  void set_decibel();
  void set_midigain();
  void set_linear();
  void set_frequency();
  void set_midi_pitch();
  void set_bpm();
 
  //************************************//
  //     Create Nodes with parameters   //
  //************************************//
 
  node create_void(std::string addr);
  node create_impulse(std::string addr);
  node create_int(std::string addr);
  node create_float(std::string addr);
  node create_bool(std::string addr);
  node create_vec2f(std::string addr);
  node create_vec3f(std::string addr);
  node create_vec4f(std::string addr);
  node create_list(std::string addr);
  node create_string(std::string addr);
  node create_buffer(std::string addr);
  node create_filepath(std::string addr);
  node create_rgb(std::string addr);
  node create_rgba(std::string addr);
  node create_rgba8(std::string addr);
  node create_argb(std::string addr);
  node create_argb8(std::string addr);
  node create_hsv(std::string addr);
  node create_cart2D(std::string addr);
  node create_cart3D(std::string addr);
  node create_opengl(std::string addr);
  node create_polar(std::string addr);
  node create_spherical(std::string addr);
  node create_cylindrical(std::string addr);
 
  node create_angle_radian(std::string addr);
  node create_angle_degree(std::string addr);
 
  node create_quaternion(std::string addr);
  node create_euler(std::string addr);
  node create_axis(std::string addr);
  node create_decibel(std::string addr);
  node create_midigain(std::string addr);
  node create_linear(std::string addr);
  node create_frequency(std::string addr);
  node create_midi_pitch(std::string addr);
  node create_bpm(std::string addr);
 
  //************************************//
  //             Manage values          //
  //************************************//
 
  node& set_value(opp::value v);
  opp::value get_value() const;
  opp::value fetch_value() const;
 
  callback_index set_value_callback(value_callback c, void* ctx);
  void remove_value_callback(callback_index idx);
 
  //************************************//
  //           Manage attributes        //
  //************************************//
 
  //*********    Access mode:    ************//
 
  node& set_access(access_mode v);
  access_mode get_access() const;
 
  //*********    Domain:    ************//
 
  node& set_min(opp::value min);
  opp::value get_min() const;
  node& set_max(opp::value max);
  opp::value get_max() const;
  node& set_accepted_values(std::vector<opp::value> v);
  std::vector<opp::value> get_accepted_values() const;
 
  //*********    Bounding mode:    ************//
 
  node& set_bounding(bounding_mode v);
  bounding_mode get_bounding() const;
 
  //*********    Units:    ************//
 
  node& set_unit(std::string v);
  std::string get_unit() const;
 
  //*********    Other value management attributes:    ************//
 
  node& set_default_value(value v);
  value get_default_value();
 
  node& set_repetition_filter(bool v);
  bool get_repetition_filter() const;
 
  node& set_refresh_rate(int v);
  node& unset_refresh_rate();
  int get_refresh_rate();
 
  node& set_value_step_size(double v);
  node& unset_value_step_size();
  double get_value_step_size();
 
  node& set_priority(float v);
  node& unset_priority();
  float get_priority();
 
  node& set_disabled(bool v);
  bool get_disabled() const;
 
  node& set_muted(bool v);
  bool get_muted() const;
 
  node& set_critical(bool v);
  bool get_critical() const;
 
  //*********    Other informative attributes:    ************//
 
  node& set_description(std::string v);
  std::string get_description() const;
 
  node& set_tags(std::vector<std::string> v);
  std::vector<std::string> get_tags() const;
 
  node& set_instance_bounds(int min, int max);
  node& unset_instance_bounds();
  std::pair<int, int> get_instance_bounds() const;
 
  node& set_hidden(bool v);
  bool get_hidden() const;
 
  bool get_zombie() const;
 
  /***********/
  /* PRESETS */
  /***********/
 
  void load_preset(const std::string& filename);
 
  void save_preset(const std::string& filename);
 
#if defined(OSSIA_CPP_CXX11)
  node(node&&) noexcept;
  node& operator=(node&&) noexcept;
#endif
 
  ossia::net::node_base* get_raw_node_pointer()
  {
    return m_node;
  }
 
private:
  friend class oscquery_mirror;
  friend class oscquery_server;
  node(ossia::net::node_base* b);
  node(ossia::net::node_base* b, ossia::net::parameter_base* addr);
  void init();
  void cleanup(const ossia::net::node_base&);
  void cleanup_parameter(const ossia::net::parameter_base&);
 
  ossia::net::node_base* m_node;
  ossia::net::parameter_base* m_param;
};
 
class OSSIA_EXPORT oscquery_server
{
public:
  oscquery_server();
  oscquery_server(std::string name, int oscPort = 1234, int wsPort = 5678);
  ~oscquery_server();
  void setup(std::string name, int oscPort = 1234, int wsPort = 5678);
 
  node get_root_node() const;
 
  void set_echo(bool echo);
 
  bool get_echo();
 
  void set_connection_callback(connection_callback c, void* ctx);
  void remove_connection_callback();
 
  void set_disconnection_callback(disconnection_callback c, void* ctx);
  void remove_disconnection_callback();
 
  void set_add_node_callback(add_node_callback c, void* ctx);
  void remove_add_node_callback();
 
  void set_remove_node_callback(remove_node_callback c, void* ctx);
  void remove_remove_node_callback();
 
  void set_rename_node_callback(rename_node_callback c, void* ctx);
  void remove_rename_node_callback();
 
  bool connected() const;
 
  ossia::net::device_base* get_raw_device_pointer() { return m_dev; }
 
private:
  void on_connection(const std::string&);
  void on_disconnection(const std::string&);
  void on_add_node_request(
      const std::string& parent, const ossia::net::parameter_data& param);
  void on_remove_node_request(const std::string& parent, const std::string& node);
  void
  on_rename_node_request(const std::string& node_to_rename, const std::string& new_name);
  ossia::net::device_base* m_dev;
 
  connection_callback m_con;
  void* m_con_ctx;
 
  disconnection_callback m_discon;
  void* m_discon_ctx;
 
  add_node_callback m_add_node_cb;
  void* m_add_node_ctx;
 
  remove_node_callback m_remove_node_cb;
  void* m_remove_node_ctx;
 
  rename_node_callback m_rename_node_cb;
  void* m_rename_node_ctx;
};
 
class OSSIA_EXPORT oscquery_mirror
{
public:
  oscquery_mirror(std::string name, std::string host = "ws://127.0.0.1:5678");
  ~oscquery_mirror();
 
  node get_root_node() const;
 
  void refresh();
 
  void update();
 
  void reconnect(std::string name = "", std::string host = "");
 
  bool is_connected() const { return m_dev != nullptr; }
 
  void set_parameter_created_callback(parameter_callback c, void* ctx);
  void remove_parameter_created_callback();
 
  void set_parameter_removed_callback(parameter_callback c, void* ctx);
  void remove_parameter_removed_callback();
 
  void set_node_created_callback(node_callback c, void* ctx);
  void remove_node_created_callback();
 
  void set_node_removed_callback(node_callback c, void* ctx);
  void remove_node_removed_callback();
 
  void set_node_renamed_callback(node_rn_callback c, void* ctx);
  void remove_node_renamed_callback();
 
  void set_message_callback(message_callback c, void* ctx);
  void remove_message_callback();
 
  void set_unhandled_message_callback(unhandled_message_callback c, void* ctx);
  void remove_unhandled_message_callback();
 
  void set_attribute_modified_callback(attribute_modified_callback c, void* ctx);
 
  void remove_attribute_modified_callback();
 
  void set_zombie_on_remove(bool b);
 
  bool get_zombie_on_remove() const;
 
  void request_add_node(node parent, const std::string& name);
 
  void request_remove_node(node node_to_be_removed);
 
  void request_rename_node(node node, std::string new_name);
 
  ossia::net::device_base* get_raw_device_pointer() { return m_dev; }
 
private:
  void on_parameter_created(const ossia::net::parameter_base&);
  void on_parameter_removed(const ossia::net::parameter_base&);
 
  void on_node_created(ossia::net::node_base&);
  void on_node_removed(ossia::net::node_base&);
  void on_node_renamed(ossia::net::node_base&, std::string);
 
  void on_message(const ossia::net::parameter_base&);
  void on_unhandled_message(const std::string&, const ossia::value&);
  void on_attribute_modified(ossia::net::node_base&, const std::string&);
 
  ossia::net::device_base* m_dev;
  parameter_callback m_param_cb;
  void* m_param_ctx;
 
  parameter_callback m_rm_param_cb;
  void* m_rm_param_ctx;
 
  node_callback m_node_cb;
  void* m_node_ctx;
 
  node_callback m_rm_node_cb;
  void* m_rm_node_ctx;
 
  node_rn_callback m_rn_node_cb;
  void* m_rn_node_ctx;
 
  message_callback m_message_cb;
  void* m_message_ctx;
 
  unhandled_message_callback m_unhandled_message_cb;
  void* m_unhandled_message_ctx;
 
  attribute_modified_callback m_attribute_modified_cb;
  void* m_attribute_modified_ctx;
 
  std::string m_name;
  std::string m_host;
};
}
 
#endif