dataflow: give exec_state_facade ability to process destination_t

Author: jcelerier

3rdparty/libremidi

@@ -7,6 +7,7 @@
 
 namespace ossia
 {
+struct exec_state_facade;
 struct do_nothing_for_nodes
 {
   void operator()(ossia::net::node_base* node, bool) const noexcept { }
@@ -53,4 +54,12 @@ bool apply_to_destination(
     }
   }
 }
+
+std::vector<ossia::net::node_base*> list_destinations(
+    const destination_t& address,
+    const ossia::small_vector<ossia::net::device_base*, 4>& devices);
+
+ossia::net::node_base* get_first_destination(
+    const destination_t& address,
+    const ossia::small_vector<ossia::net::device_base*, 4>& devices);
 }

src/ossia/dataflow/dataflow.hpp

@@ -1,6 +1,8 @@
 #pragma once
 #include <ossia/detail/config.hpp>
 
+#include <ossia/dataflow/dataflow_fwd.hpp>
+
 #include <cinttypes>
 #include <string_view>
 
@@ -48,6 +50,9 @@ struct OSSIA_EXPORT exec_state_facade
   void insert(ossia::net::parameter_base& dest, const value_port& v);
   void insert(ossia::audio_parameter& dest, const audio_port& v);
   void insert(ossia::net::midi::midi_parameter& dest, const midi_port& v);
+
+  std::vector<ossia::net::node_base*> list_destinations(const destination_t& address);
+  ossia::net::node_base* get_first_destination(const destination_t& address);
 };
 
 }

src/ossia/dataflow/exec_state_facade.hpp

@@ -563,4 +563,99 @@ void exec_state_facade::insert(net::midi::midi_parameter& dest, const midi_port&
 {
   impl->insert(dest, v);
 }
+
+std::vector<ossia::net::node_base*>
+exec_state_facade::list_destinations(const destination_t& address)
+{
+  return ossia::list_destinations(address, impl->exec_devices());
+}
+
+ossia::net::node_base*
+exec_state_facade::get_first_destination(const destination_t& address)
+{
+  return ossia::get_first_destination(address, impl->exec_devices());
+}
+
+std::vector<ossia::net::node_base*> list_destinations(
+    const destination_t& address,
+    const ossia::small_vector<ossia::net::device_base*, 4>& devices)
+{
+  std::vector<ossia::net::node_base*> ret;
+  switch(address.which().index())
+  {
+    // ossia::net::parameter_base*
+    case destination_t::index_of<ossia::net::parameter_base*>().index(): {
+      auto addr = *address.target<ossia::net::parameter_base*>();
+      if(addr)
+      {
+        ret.push_back(&addr->get_node());
+        break;
+      }
+      break;
+    }
+
+      // ossia::traversal::path
+    case destination_t::index_of<ossia::traversal::path>().index(): {
+      std::vector<ossia::net::node_base*> roots{};
+
+      for(auto n : devices)
+        roots.push_back(&n->get_root_node());
+
+      auto& p = *address.target<ossia::traversal::path>();
+      ossia::traversal::apply(p, roots);
+
+      for(auto n : roots)
+        ret.push_back(n);
+      break;
+    }
+
+      // ossia::net::node_base*
+    case destination_t::index_of<ossia::net::node_base*>().index(): {
+      ret.push_back(*address.target<ossia::net::node_base*>());
+      break;
+    }
+    default:
+      break;
+  }
+  return ret;
+}
+
+ossia::net::node_base* get_first_destination(
+    const destination_t& address,
+    const ossia::small_vector<ossia::net::device_base*, 4>& devices)
+{
+  switch(address.which().index())
+  {
+    // ossia::net::parameter_base*
+    case destination_t::index_of<ossia::net::parameter_base*>().index(): {
+      auto addr = *address.target<ossia::net::parameter_base*>();
+      if(addr)
+        return &addr->get_node();
+      break;
+    }
+
+      // ossia::traversal::path
+    case destination_t::index_of<ossia::traversal::path>().index(): {
+      std::vector<ossia::net::node_base*> roots{};
+
+      for(auto n : devices)
+        roots.push_back(&n->get_root_node());
+
+      auto& p = *address.target<ossia::traversal::path>();
+      ossia::traversal::apply(p, roots);
+
+      for(auto n : roots)
+        return n;
+      break;
+    }
+
+      // ossia::net::node_base*
+    case destination_t::index_of<ossia::net::node_base*>().index(): {
+      return *address.target<ossia::net::node_base*>();
+    }
+    default:
+      break;
+  }
+  return nullptr;
+}
 }

src/ossia/dataflow/execution_state.cpp

@@ -3,9 +3,12 @@
 // TSAN seems to have some trouble with ReaderWriterQueue...
 #if !defined(OSSIA_FREESTANDING)
 
+#include <blockingconcurrentqueue.h>
+#include <concurrentqueue.h>
+
+// SPSC
 #if defined(__has_feature)
 #if __has_feature(thread_sanitizer)
-#include <concurrentqueue.h>
 namespace ossia
 {
 template <typename T, size_t MAX_BLOCK_SIZE = 512>
@@ -28,12 +31,15 @@ using spsc_queue = moodycamel::ReaderWriterQueue<T, MAX_BLOCK_SIZE>;
 }
 #endif
 
-#include <concurrentqueue.h>
+// MPMC
 namespace ossia
 {
 template <typename T>
 using mpmc_queue = moodycamel::ConcurrentQueue<T>;
+template <typename T>
+using blocking_mpmc_queue = moodycamel::BlockingConcurrentQueue<T>;
 }
+
 #else
 // Will only be used on one thread anyways
 #include <vector>
@@ -62,5 +68,7 @@ template <typename T>
 using spsc_queue = ossia::minimal_queue<T>;
 template <typename T>
 using mpmc_queue = ossia::minimal_queue<T>;
+template <typename T>
+using blocking_mpmc_queue = ossia::minimal_queue<T>;
 }
 #endif