device_parameter_index.hpp

#pragma once
#include <ossia/detail/hash.hpp>
#include <ossia/network/base/device.hpp>
#include <ossia/network/base/node.hpp>
#include <ossia/network/base/osc_address.hpp>
#include <ossia/network/base/parameter.hpp>
 
#include <boost/unordered/concurrent_flat_map.hpp>
 
#include <string>
#include <string_view>
 
namespace ossia::net
{

class device_parameter_index : public Nano::Observer
{
public:
  explicit device_parameter_index(ossia::net::device_base& dev)
      : m_device{dev}
  {
    dev.on_parameter_created.connect<&device_parameter_index::on_parameter_created>(
        *this);
    dev.on_parameter_removing.connect<&device_parameter_index::on_parameter_removing>(
        *this);
    dev.on_node_removing.connect<&device_parameter_index::on_node_removing>(*this);
    dev.on_node_renamed.connect<&device_parameter_index::on_node_renamed>(*this);
 
    index_recursively(dev.get_root_node());
  }
 
  device_parameter_index(const device_parameter_index&) = delete;
  device_parameter_index(device_parameter_index&&) = delete;
  device_parameter_index& operator=(const device_parameter_index&) = delete;
  device_parameter_index& operator=(device_parameter_index&&) = delete;

  template <typename F>
  bool apply(std::string_view address, F&& f)
  {
    std::string buf;
    return m_index.visit(normalize(address, buf), [&](const auto& e) { f(*e.second); })
           > 0;
  }

  void clear() { m_index.clear(); }
 
  std::size_t size() const { return m_index.size(); }
 
private:
  static std::string_view normalize(std::string_view address, std::string& buf)
  {
    while(address.size() > 1 && address.back() == '/')
      address.remove_suffix(1);
 
    if(!address.empty() && address.front() == '/')
      return address;
 
    buf.reserve(address.size() + 1);
    buf = "/";
    buf += address;
    return buf;
  }

  static std::string address_of(const ossia::net::node_base& node)
  {
    return ossia::net::osc_parameter_string(node);
  }
 
  void index_recursively(const ossia::net::node_base& node)
  {
    if(auto param = node.get_parameter())
      m_index.insert_or_assign(address_of(node), param);
 
    for(const auto& cld : node.children_copy())
      index_recursively(*cld);
  }
 
  void on_parameter_created(const ossia::net::parameter_base& param)
  {
    m_index.insert_or_assign(
        address_of(param.get_node()), const_cast<ossia::net::parameter_base*>(&param));
  }
 
  void on_parameter_removing(const ossia::net::parameter_base& param)
  {
    m_index.erase(address_of(param.get_node()));
  }
 
  void on_node_removing(ossia::net::node_base& node)
  {
    // wrapped_node has no remove_parameter(), so a node's own parameter is not
    // always signalled separately, and a node removed with children takes their
    // parameters with it: sweep the subtree.
    const auto prefix = address_of(node);
 
    m_index.erase_if([&prefix](const auto& e) {
      const auto& key = e.first;
      return key == prefix
             || (key.size() > prefix.size() && key.starts_with(prefix)
                 && key[prefix.size()] == '/');
    });
  }
 
  void on_node_renamed(ossia::net::node_base& node, const std::string& old_name)
  {
    // A rename changes the address of a whole subtree, and the node's own cache
    // has already been updated when this runs.
    m_index.clear();
    index_recursively(m_device.get_root_node());
  }
 
  ossia::net::device_base& m_device;
  boost::concurrent_flat_map<
      std::string, ossia::net::parameter_base*, ossia::string_hash, std::equal_to<>>
      m_index;
};
 
}