From c616916c46d3713084c91f536163048544ca7258 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?=
 <jeanmichael.celerier@gmail.com>
Date: Sun, 20 Oct 2024 13:04:00 -0400
Subject: [PATCH] [core] Refactor controls

---
 include/avnd/binding/ossia/callbacks.hpp      |  11 ++
 include/avnd/binding/ossia/controls.hpp       |  28 +++-
 .../avnd/binding/ossia/message_process.hpp    | 136 +++++++++++-------
 include/avnd/binding/ossia/node.hpp           |   4 +-
 .../binding/ossia/port_run_postprocess.hpp    |  27 ++--
 include/avnd/binding/ossia/to_value.hpp       |  11 +-
 include/avnd/concepts/all.hpp                 |   1 +
 include/avnd/concepts/control.hpp             |  86 +++++++++++
 include/avnd/concepts/parameter.hpp           |  78 ----------
 include/avnd/wrappers/effect_container.hpp    |  18 ++-
 include/avnd/wrappers/metadatas.hpp           |  86 +++++++++--
 11 files changed, 310 insertions(+), 176 deletions(-)
 create mode 100644 include/avnd/concepts/control.hpp

diff --git a/include/avnd/binding/ossia/callbacks.hpp b/include/avnd/binding/ossia/callbacks.hpp
index 3336aac4..977dfa28 100644
--- a/include/avnd/binding/ossia/callbacks.hpp
+++ b/include/avnd/binding/ossia/callbacks.hpp
@@ -34,6 +34,17 @@ struct do_callback<Self, Idx, Field, R, Args...>
       port.data.write_value(std::move(vec), self.start_frame_for_this_tick);
     }
 
+    // FIXME handle control feedback !
+    // if constexpr(avnd::control<Field>)
+    // {
+    //   // Get the index of the control in [0; N[
+    //   using type = typename Exec_T::processor_type;
+    //   using controls = avnd::control_output_introspection<type>;
+    //   constexpr int control_index = controls::field_index_to_index(idx);
+    //
+    //   // Mark the control as changed
+    //   self.control.outputs_set.set(control_index);
+    // }
     if constexpr(!std::is_void_v<R>)
       return R{};
   }
diff --git a/include/avnd/binding/ossia/controls.hpp b/include/avnd/binding/ossia/controls.hpp
index 825bef83..0cd05e8e 100644
--- a/include/avnd/binding/ossia/controls.hpp
+++ b/include/avnd/binding/ossia/controls.hpp
@@ -1,15 +1,34 @@
 #pragma once
 #include <avnd/introspection/input.hpp>
 #include <avnd/introspection/output.hpp>
-#include <boost/smart_ptr/atomic_shared_ptr.hpp>
+// #include <boost/smart_ptr/atomic_shared_ptr.hpp>
 #include <ossia/detail/lockfree_queue.hpp>
 
 namespace oscr
 {
 
 template <typename Field>
-using controls_type = std::decay_t<decltype(Field::value)>;
+struct controls_type;
 
+template <avnd::parameter Field>
+  requires avnd::control<Field>
+struct controls_type<Field>
+{
+  using type = std::decay_t<decltype(Field::value)>;
+};
+
+template <typename Field>
+using controls_type_t = typename controls_type<Field>::type;
+
+template <avnd::callback Field>
+  requires avnd::control<Field>
+struct controls_type<Field>
+{
+  // FIXME maybe the tuple of arguments?
+  using type = ossia::value;
+};
+
+#if 0
 template <typename T>
 using atomic_shared_ptr = boost::atomic_shared_ptr<T>;
 
@@ -35,6 +54,7 @@ struct controls_mirror
   std::bitset<i_size> inputs_bits;
   std::bitset<o_size> outputs_bits;
 };
+#endif
 
 template <typename T>
 struct controls_input_queue
@@ -52,7 +72,7 @@ struct controls_input_queue<T>
 {
   static constexpr int i_size = avnd::control_input_introspection<T>::size;
   using i_tuple
-      = avnd::filter_and_apply<controls_type, avnd::control_input_introspection, T>;
+      = avnd::filter_and_apply<controls_type_t, avnd::control_input_introspection, T>;
 
   ossia::mpmc_queue<i_tuple> ins_queue;
   std::bitset<i_size> inputs_set;
@@ -64,7 +84,7 @@ struct controls_output_queue<T>
 {
   static constexpr int o_size = avnd::control_output_introspection<T>::size;
   using o_tuple
-      = avnd::filter_and_apply<controls_type, avnd::control_output_introspection, T>;
+      = avnd::filter_and_apply<controls_type_t, avnd::control_output_introspection, T>;
 
   ossia::mpmc_queue<o_tuple> outs_queue;
 
diff --git a/include/avnd/binding/ossia/message_process.hpp b/include/avnd/binding/ossia/message_process.hpp
index f0c5043a..e356fe87 100644
--- a/include/avnd/binding/ossia/message_process.hpp
+++ b/include/avnd/binding/ossia/message_process.hpp
@@ -1,4 +1,11 @@
 #pragma once
+#include <avnd/common/aggregates.hpp>
+#include <avnd/concepts/all.hpp>
+#include <boost/mp11.hpp>
+#include <ossia/network/value/value.hpp>
+
+#include <optional>
+#include <tuple>
 
 namespace oscr
 {
@@ -57,18 +64,31 @@ struct message_processor
           const auto& vec = *val.target<std::vector<ossia::value>>();
           if(vec.size() == count)
           {
-            int i = 0; // FIXME doable at compile-time
-            std::apply([&self, &vec, &i]<typename... Ts>(Ts&&... args) {
-              (self.from_ossia_value(field, vec[i++], args, avnd::field_index<Idx>{}),
+            std::apply(
+                [&self, &vec, it = vec.begin()]<typename... Ts>(Ts&&... args) mutable {
+              (self.from_ossia_value(field, *(it++), args, avnd::field_index<Idx>{}),
                ...);
             }, tuple);
             return tuple;
           }
           break;
         }
-        case ossia::val_type::MAP:
-          // FIXME
+        case ossia::val_type::MAP: {
+          static constexpr M field;
+          Args tuple;
+          const auto& vec = *val.target<ossia::value_map_type>();
+          if(vec.size() == count)
+          {
+            std::apply(
+                [&self, &vec, it = vec.begin()]<typename... Ts>(Ts&&... args) mutable {
+              (self.from_ossia_value(
+                   field, (it++)->second, args, avnd::field_index<Idx>{}),
+               ...);
+            }, tuple);
+            return tuple;
+          }
           break;
+        }
         default:
           break;
       }
@@ -96,51 +116,90 @@ struct message_processor
       else
       {
         // M contains a function pointer to a free function f
-        f(first_args..., std::forward<Ts>(args)...);
+        f(std::forward<Args>(first_args)..., std::forward<Ts>(args)...);
       }
     },
         res);
   }
+
   template <auto Idx, typename M>
   void invoke_message_first_arg_is_object(
-      auto& self, const ossia::value& val, avnd::field_reflection<Idx, M>)
+      auto& self, const ossia::value& val, int64_t ts, avnd::field_reflection<Idx, M>)
   {
     auto& impl = self.impl;
     using refl = avnd::message_reflection<M>;
     using namespace boost::mp11;
     using first_arg_type = std::remove_cvref_t<avnd::first_message_argument<M>>;
-    if constexpr(std::is_same_v<first_arg_type, T>)
+
+    if constexpr(avnd::tag_timestamp<M>)
     {
-      using main_args = mp_pop_front<typename refl::arguments>;
-      using no_ref = mp_transform<std::remove_cvref_t, main_args>;
-      using args = mp_rename<no_ref, std::tuple>;
+      if constexpr(std::is_same_v<first_arg_type, T>)
+      {
+        static_assert(boost::mp11::mp_size<typename refl::arguments>::value >= 2);
+        using main_args = mp_pop_front<mp_pop_front<typename refl::arguments>>;
+        using no_ref = mp_transform<std::remove_cvref_t, main_args>;
+        using args = mp_rename<no_ref, std::tuple>;
 
-      if(auto res = value_to_argument_tuple<M, args, Idx>(self, val))
+        if(auto res = value_to_argument_tuple<M, args, Idx>(self, val))
+        {
+          for(auto& m : impl.effects())
+          {
+            invoke_message_impl<M>(self, *res, m, m, ts);
+          }
+        }
+      }
+      else
       {
-        for(auto& m : impl.effects())
+        static_assert(boost::mp11::mp_size<typename refl::arguments>::value >= 1);
+        using main_args = mp_pop_front<typename refl::arguments>;
+        using no_ref = mp_transform<std::remove_cvref_t, main_args>;
+        using args = mp_rename<no_ref, std::tuple>;
+        if(auto res = value_to_argument_tuple<M, args, Idx>(self, val))
         {
-          invoke_message_impl<M>(self, *res, m, m);
+          for(auto& m : impl.effects())
+          {
+            invoke_message_impl<M>(self, *res, m, ts);
+          }
         }
       }
     }
     else
     {
-      using main_args = typename refl::arguments;
-      using no_ref = mp_transform<std::remove_cvref_t, main_args>;
-      using args = mp_rename<no_ref, std::tuple>;
-      if(auto res = value_to_argument_tuple<M, args, Idx>(self, val))
+      if constexpr(std::is_same_v<first_arg_type, T>)
       {
-        for(auto& m : impl.effects())
+        static_assert(boost::mp11::mp_size<typename refl::arguments>::value >= 1);
+        using main_args = mp_pop_front<typename refl::arguments>;
+        using no_ref = mp_transform<std::remove_cvref_t, main_args>;
+        using args = mp_rename<no_ref, std::tuple>;
+
+        if(auto res = value_to_argument_tuple<M, args, Idx>(self, val))
         {
-          invoke_message_impl<M>(self, *res, m);
+          for(auto& m : impl.effects())
+          {
+            invoke_message_impl<M>(self, *res, m, m);
+          }
+        }
+      }
+      else
+      {
+        using main_args = typename refl::arguments;
+        using no_ref = mp_transform<std::remove_cvref_t, main_args>;
+        using args = mp_rename<no_ref, std::tuple>;
+        if(auto res = value_to_argument_tuple<M, args, Idx>(self, val))
+        {
+          for(auto& m : impl.effects())
+          {
+            invoke_message_impl<M>(self, *res, m);
+          }
         }
       }
     }
   }
 
   template <auto Idx, typename M>
-  void
-  invoke_message(auto& self, const ossia::value& val, avnd::field_reflection<Idx, M> idx)
+  void invoke_message(
+      auto& self, const ossia::value& val, int64_t ts,
+      avnd::field_reflection<Idx, M> idx)
   {
     auto& impl = self.impl;
     if constexpr(!std::is_void_v<avnd::message_reflection<M>>)
@@ -154,37 +213,10 @@ struct message_processor
           invoke_message_impl<M>(self, std::tuple<>{}, m);
         }
       }
-      else // if constexpr(refl::count == 1)
-      {
-        invoke_message_first_arg_is_object(self, val, idx);
-      }
-      /*
       else
       {
-        using namespace boost::mp11;
-        using first_arg_type = std::remove_cvref_t<avnd::first_message_argument<M>>;
-        using second_arg_type = std::remove_cvref_t<avnd::second_message_argument<M>>;
-        if constexpr(
-            std::is_same_v<first_arg_type, T> && avnd::has_tick<M>
-            && std::is_same_v<second_arg_type, typename M::tick>)
-        {
-          using main_args = mp_pop_front<typename refl::arguments>;
-          using no_ref = mp_transform<std::remove_cvref_t, main_args>;
-          using args = mp_rename<no_ref, std::tuple>;
-
-          if(auto res = value_to_argument_tuple<M, args, Idx>(self, val))
-          {
-            for(auto& m : impl.effects())
-            {
-              invoke_message_impl<M>(self, *res, m, m);
-            }
-          }
-        }
-        else
-        {
-          invoke_message_first_arg_is_object(self, val, idx);
-        }
-      }*/
+        invoke_message_first_arg_is_object(self, val, ts, idx);
+      }
     }
   }
 
@@ -196,7 +228,7 @@ struct message_processor
       return;
     for(const auto& val : inl.data.get_data())
     {
-      invoke_message(self, val.value, avnd::field_reflection<Idx, M>{});
+      invoke_message(self, val.value, val.timestamp, avnd::field_reflection<Idx, M>{});
     }
   }
 };
diff --git a/include/avnd/binding/ossia/node.hpp b/include/avnd/binding/ossia/node.hpp
index 90faeb1e..52c9e3c3 100644
--- a/include/avnd/binding/ossia/node.hpp
+++ b/include/avnd/binding/ossia/node.hpp
@@ -155,9 +155,9 @@ class safe_node_base_base : public ossia::nonowning_graph_node
   [[no_unique_address]] oscr::message_processor<T> messages;
 
   using control_input_values_type
-      = avnd::filter_and_apply<controls_type, avnd::control_input_introspection, T>;
+      = avnd::filter_and_apply<controls_type_t, avnd::control_input_introspection, T>;
   using control_output_values_type
-      = avnd::filter_and_apply<controls_type, avnd::control_output_introspection, T>;
+      = avnd::filter_and_apply<controls_type_t, avnd::control_output_introspection, T>;
 };
 
 template <std::size_t Index, typename F>
diff --git a/include/avnd/binding/ossia/port_run_postprocess.hpp b/include/avnd/binding/ossia/port_run_postprocess.hpp
index fe98880d..d03cb682 100644
--- a/include/avnd/binding/ossia/port_run_postprocess.hpp
+++ b/include/avnd/binding/ossia/port_run_postprocess.hpp
@@ -78,17 +78,7 @@ struct process_after_run
   {
   }
   template <avnd::parameter Field, std::size_t Idx>
-    requires(!avnd::control<Field> && !ossia_port<Field>)
-  void write_value(
-      Field& ctrl, ossia::value_outlet& port, auto& val, int64_t ts,
-      avnd::field_index<Idx>) const noexcept
-  {
-    if(auto v = to_ossia_value(ctrl, val); v.valid())
-      port->write_value(std::move(v), ts);
-  }
-
-  template <avnd::parameter Field, std::size_t Idx>
-    requires(avnd::control<Field> && !ossia_port<Field>)
+    requires(!ossia_port<Field>)
   void write_value(
       Field& ctrl, ossia::value_outlet& port, auto& val, int64_t ts,
       avnd::field_index<Idx> idx) const noexcept
@@ -97,13 +87,16 @@ struct process_after_run
     {
       port->write_value(std::move(v), ts);
 
-      // Get the index of the control in [0; N[
-      using type = typename Exec_T::processor_type;
-      using controls = avnd::control_output_introspection<type>;
-      constexpr int control_index = controls::field_index_to_index(idx);
+      if constexpr(avnd::control<Field>)
+      {
+        // Get the index of the control in [0; N[
+        using type = typename Exec_T::processor_type;
+        using controls = avnd::control_output_introspection<type>;
+        constexpr int control_index = controls::field_index_to_index(idx);
 
-      // Mark the control as changed
-      self.control.outputs_set.set(control_index);
+        // Mark the control as changed
+        self.control.outputs_set.set(control_index);
+      }
     }
   }
 
diff --git a/include/avnd/binding/ossia/to_value.hpp b/include/avnd/binding/ossia/to_value.hpp
index 966598c9..f1011626 100644
--- a/include/avnd/binding/ossia/to_value.hpp
+++ b/include/avnd/binding/ossia/to_value.hpp
@@ -399,7 +399,9 @@ ossia::value to_ossia_value(const avnd::variant_ish auto& v)
 {
   return to_ossia_value_rec(v);
 }
-ossia::value to_ossia_value(const avnd::optional_ish auto& v)
+template <avnd::optional_ish T>
+  requires(!std::is_same_v<std::optional<ossia::value>, T>)
+ossia::value to_ossia_value(const T& v)
 {
   return to_ossia_value_rec(v);
 }
@@ -451,6 +453,13 @@ inline ossia::value to_ossia_value(const T& v)
   return v;
 }
 
+template <typename T>
+  requires std::is_same_v<std::optional<ossia::value>, T>
+inline ossia::value to_ossia_value(const T& v)
+{
+  return v ? *v : ossia::value{};
+}
+
 inline ossia::value to_ossia_value(auto& field, const auto& src)
 {
   return to_ossia_value(src);
diff --git a/include/avnd/concepts/all.hpp b/include/avnd/concepts/all.hpp
index 1949ca1a..1718d41d 100644
--- a/include/avnd/concepts/all.hpp
+++ b/include/avnd/concepts/all.hpp
@@ -7,6 +7,7 @@
 #include <avnd/concepts/audio_processor.hpp>
 #include <avnd/concepts/callback.hpp>
 #include <avnd/concepts/channels.hpp>
+#include <avnd/concepts/control.hpp>
 #include <avnd/concepts/curve.hpp>
 #include <avnd/concepts/dynamic_ports.hpp>
 #include <avnd/concepts/fft.hpp>
diff --git a/include/avnd/concepts/control.hpp b/include/avnd/concepts/control.hpp
new file mode 100644
index 00000000..d51505f2
--- /dev/null
+++ b/include/avnd/concepts/control.hpp
@@ -0,0 +1,86 @@
+#pragma once
+
+/* SPDX-License-Identifier: GPL-3.0-or-later OR BSL-1.0 OR CC0-1.0 OR CC-PDCC OR 0BSD */
+
+#include <avnd/concepts/callback.hpp>
+#include <avnd/concepts/parameter.hpp>
+
+namespace avnd
+{
+
+/**
+ * A "control" is a parameter + some metadata:
+ *
+ * struct
+ * {
+ *   // see widgets.hpp
+ *   enum widget { slider };
+ *
+ *
+ *   static consteval auto range() {
+ *     struct {
+ *       float min = 0.;
+ *       float max = 1.;
+ *       float init = 0.25;
+ *     } r;
+ *     return r;
+ *   }
+ *
+ *   float value;
+ * };
+ */
+template <typename T>
+concept control = /*(parameter<T> || callback<T>) &&*/ parameter<T>
+                  && (has_range<T> || has_widget<T>);
+
+// FIXME all this needs improving: they do not support callbacks.
+// Also messages are not handled.
+// Ideally, messages, callbacks and controls would all be handled exactly in the same way ?
+template <typename T>
+concept int_control = int_parameter<T> && control<T>;
+template <typename T>
+concept enum_control = enum_parameter<T> && control<T>;
+template <typename T>
+concept float_control = float_parameter<T> && control<T>;
+template <typename T>
+concept bool_control = bool_parameter<T> && control<T>;
+template <typename T>
+concept string_control = string_parameter<T> && control<T>;
+template <typename T>
+concept time_control = float_control<T> && requires { T::time_chooser; };
+
+template <typename T>
+concept int_value_port = int_parameter<T> && !control<T>;
+template <typename T>
+concept enum_value_port = enum_parameter<T> && !control<T>;
+template <typename T>
+concept float_value_port = float_parameter<T> && !control<T>;
+template <typename T>
+concept bool_value_port = bool_parameter<T> && !control<T>;
+template <typename T>
+concept string_value_port = string_parameter<T> && !control<T>;
+
+/**
+ * A value port is a parameter which is not a control.
+ */
+template <typename T>
+concept value_port = parameter<T> && !control<T>;
+
+template <typename T>
+concept span_control = span_parameter<T> && control<T>;
+template <typename T>
+concept span_value_port = span_parameter<T> && value_port<T>;
+
+/**
+ * Like control but sample-accurate
+ */
+template <typename T>
+concept sample_accurate_control = sample_accurate_parameter<T> && control<T>;
+
+/**
+ * Like value_port but sample-accurate
+ */
+template <typename T>
+concept sample_accurate_value_port = sample_accurate_parameter<T> && !control<T>;
+
+}
diff --git a/include/avnd/concepts/parameter.hpp b/include/avnd/concepts/parameter.hpp
index 211cd6fd..50e0c374 100644
--- a/include/avnd/concepts/parameter.hpp
+++ b/include/avnd/concepts/parameter.hpp
@@ -127,67 +127,6 @@ concept program_parameter
                                  } -> std::convertible_to<std::string>;
                              };
 
-/**
- * A "control" is a parameter + some metadata:
- *
- * struct
- * {
- *   // see widgets.hpp
- *   enum widget { slider };
- *
- *
- *   static consteval auto range() {
- *     struct {
- *       float min = 0.;
- *       float max = 1.;
- *       float init = 0.25;
- *     } r;
- *     return r;
- *   }
- *
- *   float value;
- * };
- */
-
-template <typename T>
-concept control = parameter<T> && (has_range<T> || has_widget<T>);
-
-template <typename T>
-concept int_control = int_parameter<T> && control<T>;
-template <typename T>
-concept enum_control = enum_parameter<T> && control<T>;
-template <typename T>
-concept float_control = float_parameter<T> && control<T>;
-template <typename T>
-concept bool_control = bool_parameter<T> && control<T>;
-template <typename T>
-concept string_control = string_parameter<T> && control<T>;
-template <typename T>
-concept time_control = float_control<T> && requires { T::time_chooser; };
-
-template <typename T>
-concept int_value_port = int_parameter<T> && !
-control<T>;
-template <typename T>
-concept enum_value_port = enum_parameter<T> && !
-control<T>;
-template <typename T>
-concept float_value_port = float_parameter<T> && !
-control<T>;
-template <typename T>
-concept bool_value_port = bool_parameter<T> && !
-control<T>;
-template <typename T>
-concept string_value_port = string_parameter<T> && !
-control<T>;
-
-/**
- * A value port is a parameter which is not a control.
- */
-template <typename T>
-concept value_port = parameter<T> && !
-control<T>;
-
 /**
  * Here T is a e.g. std::span<T>
  */
@@ -202,10 +141,6 @@ concept span_value
       } && std::is_constructible_v<T, typename T::value_type*, std::size_t> && std::is_trivially_copy_constructible_v<T>;
 template <typename T>
 concept span_parameter = parameter<T> && span_value<std::decay_t<decltype(T::value)>>;
-template <typename T>
-concept span_control = span_parameter<T> && control<T>;
-template <typename T>
-concept span_value_port = span_parameter<T> && value_port<T>;
 
 /**
  * Timed values are used for sample-accurate ports.
@@ -257,19 +192,6 @@ concept sample_accurate_parameter
           || requires(T t) { t.value = t.values.begin()->value; } // span
       );
 
-/**
- * Like control but sample-accurate
- */
-template <typename T>
-concept sample_accurate_control = sample_accurate_parameter<T> && control<T>;
-
-/**
- * Like value_port but sample-accurate
- */
-template <typename T>
-concept sample_accurate_value_port = sample_accurate_parameter<T> && !
-control<T>;
-
 template <typename T>
 concept linear_sample_accurate_parameter
     = sample_accurate_parameter<T>
diff --git a/include/avnd/wrappers/effect_container.hpp b/include/avnd/wrappers/effect_container.hpp
index ee98bfe2..5fdcacdc 100644
--- a/include/avnd/wrappers/effect_container.hpp
+++ b/include/avnd/wrappers/effect_container.hpp
@@ -122,12 +122,12 @@ struct effect_container
 
   T effect;
 
-  void init_channels(int input, int output)
+  inline constexpr void init_channels(int input, int output)
   {
     // TODO maybe a runtime check
   }
 
-  auto& inputs() noexcept
+  inline constexpr auto& inputs() noexcept
   {
     if constexpr(has_inputs<T>)
     {
@@ -139,7 +139,8 @@ struct effect_container
     else
       return dummy_instance;
   }
-  auto& inputs() const noexcept
+
+  inline constexpr auto& inputs() const noexcept
   {
     if constexpr(has_inputs<T>)
     {
@@ -151,7 +152,8 @@ struct effect_container
     else
       return dummy_instance;
   }
-  auto& outputs() noexcept
+
+  inline constexpr auto& outputs() noexcept
   {
     if constexpr(has_outputs<T>)
     {
@@ -163,7 +165,8 @@ struct effect_container
     else
       return dummy_instance;
   }
-  auto& outputs() const noexcept
+
+  inline constexpr auto& outputs() const noexcept
   {
     if constexpr(has_outputs<T>)
     {
@@ -183,12 +186,13 @@ struct effect_container
     decltype(std::declval<effect_container>().outputs())& outputs;
   };
 
-  std::array<ref, 1> full_state() noexcept
+  inline std::array<ref, 1> full_state() noexcept
   {
     return {ref{effect, this->inputs(), this->outputs()}};
   }
 
-  auto effects() {
+  inline auto effects() noexcept
+  {
     return member_iterator_one_effect<effect_container>{*this};
   }
 };
diff --git a/include/avnd/wrappers/metadatas.hpp b/include/avnd/wrappers/metadatas.hpp
index 0810e601..3c93afc4 100644
--- a/include/avnd/wrappers/metadatas.hpp
+++ b/include/avnd/wrappers/metadatas.hpp
@@ -22,6 +22,67 @@ namespace avnd
 #define AVND_IF_CONSTEVAL (std::is_constant_evaluated())
 #endif
 
+#define define_get_property_auto(PropName, Default)                       \
+  template <typename T>                                                   \
+  constexpr auto get_##PropName()                                         \
+  {                                                                       \
+    if constexpr(requires { T::PropName(); })                             \
+      return T::PropName();                                               \
+    else if constexpr(requires { T::PropName; })                          \
+      return T::PropName;                                                 \
+    else                                                                  \
+      return Default;                                                     \
+  }                                                                       \
+                                                                          \
+  template <typename T>                                                   \
+  constexpr auto get_##PropName(const T& t)                               \
+  {                                                                       \
+    if AVND_IF_CONSTEVAL                                                  \
+    {                                                                     \
+      return get_##PropName<T>();                                         \
+    }                                                                     \
+    else                                                                  \
+    {                                                                     \
+      if constexpr(requires { T::PropName(); })                           \
+        return T::PropName();                                             \
+      else if constexpr(requires { T::PropName; })                        \
+        return T::PropName;                                               \
+      else if constexpr(requires { t.PropName(); })                       \
+        return t.PropName();                                              \
+      else if constexpr(requires { t.PropName; })                         \
+        return t.PropName;                                                \
+      else                                                                \
+        return get_##PropName<T>();                                       \
+    }                                                                     \
+  }                                                                       \
+                                                                          \
+  template <typename T>                                                   \
+  concept has_##PropName                                                  \
+      = requires(T t) { t.PropName(); } || requires(T t) { t.PropName; }; \
+                                                                          \
+  struct prop_##PropName                                                  \
+  {                                                                       \
+    template <typename T>                                                 \
+    static constexpr bool has() noexcept                                  \
+    {                                                                     \
+      return has_##PropName<T>;                                           \
+    }                                                                     \
+                                                                          \
+    static constexpr std::string_view name() noexcept                     \
+    {                                                                     \
+      return #PropName;                                                   \
+    }                                                                     \
+                                                                          \
+    template <typename T>                                                 \
+    static constexpr auto get()                                           \
+    {                                                                     \
+      if constexpr(has_##PropName<T>)                                     \
+        return get_##PropName<T>();                                       \
+      else                                                                \
+        return Default;                                                   \
+    }                                                                     \
+  };
+
 #define define_get_property(PropName, Type, Default)                                  \
   template <typename T>                                                               \
   constexpr Type get_##PropName()                                                     \
@@ -134,8 +195,10 @@ define_get_property(description, std::string_view, "(description)")
 define_get_property(short_description, std::string_view, "(short_description)")
 define_get_property(module, std::string_view, "(module)")
 
-template <typename T>
-constexpr std::string_view default_osc_path()
+define_get_property_auto(pixmaps, std::span<const char*>{})
+
+    template <typename T>
+    constexpr std::string_view default_osc_path()
 {
   return get_name<T>();
 }
@@ -304,30 +367,22 @@ template <typename T>
 /* constexpr */ int get_int_version()
 {
   if constexpr(requires {
-                 {
-                   T::version()
-                 } -> std::integral;
+                 { T::version() } -> std::integral;
                })
   {
     return T::version();
   }
   else if constexpr(requires {
-                      {
-                        std::declval<T>().version
-                      } -> std::integral;
+                      { std::declval<T>().version } -> std::integral;
                     })
   {
     return T::version;
   }
   else if constexpr(requires {
-                      {
-                        T::version()
-                        } -> avnd::string_ish;
+                      { T::version() } -> avnd::string_ish;
                     } || requires {
-             {
-               std::declval<T>().version
-               } -> avnd::string_ish;
-           })
+                      { std::declval<T>().version } -> avnd::string_ish;
+                    })
   {
     auto str = avnd::get_version<T>();
     if(str.empty())
@@ -346,6 +401,7 @@ template <typename T>
     return 1;
   }
 }
+
 template <typename T, char Sep>
 constexpr std::array<char, 256> get_keywords()
 {