node_functions.hpp

Go to the documentation of this file.

#pragma once
#include <ossia/network/base/address_scope.hpp>
#include <ossia/network/base/node.hpp>
#include <ossia/network/value/destination.hpp>
 
#include <functional>
 
namespace ossia
{
namespace net
{
 
OSSIA_EXPORT ossia::net::node_base*
find_node(node_base& dev, std::string_view parameter_base);
 
OSSIA_EXPORT std::vector<ossia::net::node_base*>
find_nodes(node_base& dev, std::string_view pattern);
 
OSSIA_EXPORT node_base& create_node(node_base& dev, std::string_view parameter_base);
 
OSSIA_EXPORT std::vector<ossia::net::node_base*>
create_nodes(node_base& dev, std::string_view pattern);
 
OSSIA_EXPORT node_base&
find_or_create_node(node_base& dev, std::string_view parameter_base);
 
parameter_base* find_or_create_parameter(
    node_base& node, std::string_view address, std::string_view type);
OSSIA_EXPORT std::vector<parameter_base*> find_parameter_or_create_node(
    node_base& node, std::string_view address, std::string_view type);
 
OSSIA_EXPORT node_base*
find_or_create_node(node_base& dev, std::string_view parameter_base, bool create);
 
void sanitize_name(std::string& name, const node_base::children_t& brethren);
 
OSSIA_EXPORT ossia::value_with_unit get_value(const ossia::destination& addr);
 
OSSIA_EXPORT void
push_value(const ossia::destination& addr, const ossia::value_with_unit&);
 
template <typename Address>
auto create_parameter(ossia::net::node_base& root, std::string name)
{
  auto& node = ossia::net::create_node(root, std::move(name));
  auto addr = new Address(node);
  node.set_parameter(std::unique_ptr<Address>(addr));
  return addr;
}
 
template <typename Address>
auto find_parameter_or_create_node(ossia::net::node_base& root, std::string_view name)
{
  auto& node = ossia::net::find_or_create_node(root, std::move(name));
  if(auto p = dynamic_cast<Address*>(node.get_parameter()))
  {
    return p;
  }
  else
  {
    auto addr = new Address{node};
    node.set_parameter(std::unique_ptr<Address>(addr));
    return addr;
  }
}
OSSIA_EXPORT std::ostream& operator<<(std::ostream&, const ossia::net::parameter_base&);
 
OSSIA_EXPORT
void expand_ranges(std::string& str);
 
OSSIA_EXPORT
std::pair<std::vector<std::string>, bool> expand_address(std::string address);
 
OSSIA_EXPORT
std::vector<ossia::net::node_base*>
list_all_children(ossia::net::node_base* node, unsigned int depth = 0, bool sort = true);
 
OSSIA_EXPORT
void
list_all_children(
        ossia::net::node_base* node,
        std::vector<ossia::net::node_base*>&out,
        unsigned int depth,
        bool sort);
 
OSSIA_EXPORT
void iterate_all_children(
    ossia::net::node_base* node,
    const std::function<void(ossia::net::parameter_base&)>&);
 
struct OSSIA_EXPORT fuzzysearch_result
{
  double score{};
  std::string oscname;
  ossia::net::node_base* node{};
 
  friend bool
  operator==(const fuzzysearch_result& lhs, const fuzzysearch_result& rhs) noexcept
  {
    return lhs.score == rhs.score && lhs.oscname == rhs.oscname && lhs.node == rhs.node;
  }
};
 
struct fuzzysearch_options
{
  bool case_sensitive{true};
};
 
OSSIA_EXPORT
void fuzzysearch(
    const std::vector<ossia::net::node_base*>& node,
    const std::vector<std::string>& patterns, std::vector<fuzzysearch_result>& results,
    fuzzysearch_options = {});
 
OSSIA_EXPORT
ossia::value_map_type to_map(const ossia::net::node_base& n) noexcept;
 
}
}