node.hpp

#pragma once
#include <ossia/detail/any_map.hpp>
#include <ossia/detail/callback_container.hpp>
#include <ossia/detail/locked_container.hpp>
#include <ossia/detail/mutex.hpp>
#include <ossia/detail/ptr_container.hpp>
#include <ossia/detail/string_view.hpp>
#include <ossia/network/base/name_validation.hpp>
#include <ossia/network/common/parameter_properties.hpp>
 
#include <nano_signal_slot.hpp>
 
#include <functional>
#include <memory>
#include <string>
#if defined(OSSIA_QT)
class QString;
#endif
namespace ossia
{
namespace net
{
class device_base;
class parameter_base;
class node_base;
class OSSIA_EXPORT node_base
{
public:
  using children_t = std::vector<std::unique_ptr<node_base>>;
  node_base() = default;
  node_base(const node_base&) = delete;
  node_base(node_base&&) = delete;
  node_base& operator=(const node_base&) = delete;
  node_base& operator=(node_base&&) = delete;
 
  virtual ~node_base();
 
  virtual device_base& get_device() const = 0;
 
  virtual node_base* get_parent() const = 0;
 
  const std::string& get_name() const { return m_name; }
  virtual node_base& set_name(std::string) = 0;
 
  virtual parameter_base* create_parameter(val_type = val_type::IMPULSE) = 0;
  virtual void set_parameter(std::unique_ptr<ossia::net::parameter_base>);
  virtual bool remove_parameter() = 0;
  virtual parameter_base* get_parameter() const = 0;
 
  const extended_attributes& get_extended_attributes() const;
  void set_extended_attributes(const extended_attributes&);
 
  ossia::any get_attribute(std::string_view str) const;
 
  template <typename T>
  void set(std::string_view str, const T& val);
  template <typename T>
  void set(std::string_view str, T&& val);
 
  template <typename T>
  void set(std::string_view str, const std::optional<T>& val);
  template <typename T>
  void set(std::string_view str, std::optional<T>&& val);
 
  void set(std::string_view str, bool value);
 
  template <typename Attribute, typename T>
  void set(Attribute a, const T& value);
  template <typename Attribute, typename T>
  void set(Attribute a, T& value);
  template <typename Attribute, typename T>
  void set(Attribute a, T&& value);
 
  node_base* create_child(std::string name);
 
  node_base* add_child(std::unique_ptr<node_base>);
 
  node_base* find_child(std::string_view name);
#if defined(OSSIA_QT)
  node_base* find_child(const QString& name);
#endif
 
  bool has_child(ossia::net::node_base&);
 
  bool remove_child(const std::string& name);
  bool remove_child(const node_base& name);
 
  void clear_children();
 
  operator const extended_attributes&() const
  {
    return m_extended;
  }
  operator extended_attributes&()
  {
    return m_extended;
  }
 
  locked_container<const children_t> children() const
  {
    return {m_children, m_mutex};
  }
 
  const auto& unsafe_children() const TS_REQUIRES(m_mutex)
  {
    return m_children;
  }
  mutable shared_mutex_t m_mutex;
 
  std::vector<node_base*> children_copy() const;
 
  std::vector<std::string> children_names() const;
 
  int children_count() const;
 
  bool is_root_instance(const ossia::net::node_base& child) const;
 
  const std::string& osc_address() const
  {
    return m_oscAddressCache;
  }
  virtual void on_address_change();
 
  mutable Nano::Signal<void(const node_base&)> about_to_be_deleted;
 
protected:
  virtual std::unique_ptr<node_base> make_child(const std::string& name) = 0;
 
  virtual void removing_child(node_base& node_base) = 0;
 
  std::string m_name;
  children_t m_children TS_GUARDED_BY(m_mutex);
  extended_attributes m_extended{0};
  std::string m_oscAddressCache;
};
}
}