🎨 Allow indexed handler to handle messages by value

- remove the `T` suffix from several template arguments
- rename `BaseMsg` to `MsgBase` where appropriate: there was a mix of uses, and
  it isn't necessarily a message at all, but the raw storage underlying. So it's
  not a base message, but it is a message base.
- handle by-value callbacks in the indexed builder/handler.

Author: elbeno

include/msg/detail/indexed_builder_common.hpp

@@ -127,28 +127,26 @@ template <typename... Fields>
 using index_spec = decltype(stdx::make_indexed_tuple<get_field_type>(
     temp_index<Fields, 512, 256>{}...));
 
-template <template <typename, typename, typename, typename...> typename ParentT,
-          typename IndexSpec, typename CallbacksT, typename BaseMsgT,
-          typename... ExtraCallbackArgsT>
+template <template <typename, typename, typename, typename...> typename Parent,
+          typename IndexSpec, typename Callbacks, typename MsgBase,
+          typename... ExtraCallbackArgs>
 struct indexed_builder_base {
-    CallbacksT callbacks;
+    Callbacks callbacks;
 
     template <typename... Ts> [[nodiscard]] constexpr auto add(Ts... ts) {
         auto new_callbacks =
             stdx::tuple_cat(callbacks, separate_sum_terms(ts)...);
         using new_callbacks_t = decltype(new_callbacks);
-        return ParentT<IndexSpec, new_callbacks_t, BaseMsgT,
-                       ExtraCallbackArgsT...>{new_callbacks};
+        return Parent<IndexSpec, new_callbacks_t, MsgBase,
+                      ExtraCallbackArgs...>{new_callbacks};
     }
 
-    using callback_func_t = auto (*)(BaseMsgT const &,
-                                     ExtraCallbackArgsT... args) -> bool;
+    using callback_func_t = auto (*)(MsgBase const &,
+                                     ExtraCallbackArgs... args) -> bool;
 
     template <typename BuilderValue, std::size_t I>
-    constexpr static auto invoke_callback(BaseMsgT const &data,
-                                          ExtraCallbackArgsT... args) -> bool {
-        // FIXME: incomplete message callback invocation...
-        //        1) bit_cast message argument
+    constexpr static auto invoke_callback(MsgBase const &data,
+                                          ExtraCallbackArgs... args) -> bool {
         constexpr auto cb = IndexSpec{}.apply([&]<typename... Indices>(
                                                   Indices...) {
             constexpr auto orig_cb =
@@ -164,15 +162,14 @@ struct indexed_builder_base {
                 "Indexed callback has matcher that is never matched!");
         }
 
-        auto view = typename CB::msg_t::view_t{data};
-
-        if (cb.matcher(view)) {
+        using msg_t = typename CB::msg_t;
+        if (msg::call_with_message<msg_t>(cb.matcher, data)) {
             CIB_INFO(
                 "Incoming message matched [{}], because [{}] (collapsed to "
                 "[{}]), executing callback",
                 stdx::ct_string_to_type<cb.name, sc::string_constant>(),
                 orig_cb.matcher.describe(), cb.matcher.describe());
-            cb.callable(view, args...);
+            msg::call_with_message<msg_t>(cb.callable, data, args...);
             return true;
         }
         return false;

include/msg/detail/indexed_handler_common.hpp

@@ -2,10 +2,15 @@
 
 #include <log/log.hpp>
 #include <msg/handler_interface.hpp>
+#include <msg/message.hpp>
 
 #include <stdx/compiler.hpp>
 #include <stdx/ranges.hpp>
 
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
 namespace msg {
 
 template <typename Field, typename Lookup> struct index {
@@ -23,30 +28,25 @@ template <typename Field, typename Lookup> struct index {
     }
 };
 
-template <typename BaseMsgT, typename... ExtraCallbackArgsT>
-struct callback_args_t {};
-
-template <typename BaseMsgT, typename... ExtraCallbackArgsT>
-constexpr callback_args_t<BaseMsgT, ExtraCallbackArgsT...> callback_args{};
+template <typename Index, typename Callbacks, typename MsgBase,
+          typename... ExtraCallbackArgs>
+struct indexed_handler : handler_interface<MsgBase, ExtraCallbackArgs...> {
+    Index index;
+    Callbacks callback_entries;
 
-template <typename IndexT, typename CallbacksT, typename BaseMsgT,
-          typename... ExtraCallbackArgsT>
-struct indexed_handler : handler_interface<BaseMsgT, ExtraCallbackArgsT...> {
-    IndexT index;
-    CallbacksT callback_entries;
+    template <typename Idx, typename CBs>
+    constexpr explicit indexed_handler(Idx &&idx, CBs &&cbs)
+        : index{std::forward<Idx>(idx)},
+          callback_entries{std::forward<CBs>(cbs)} {}
 
-    constexpr explicit indexed_handler(
-        callback_args_t<BaseMsgT, ExtraCallbackArgsT...>, IndexT new_index,
-        CallbacksT new_callbacks)
-        : index{new_index}, callback_entries{new_callbacks} {}
-
-    auto is_match(BaseMsgT const &msg) const -> bool final {
+    // This function may lie... it may claim to match when it doesn't because
+    // there are further conditions on the non-indexed parts of the matcher
+    auto is_match(MsgBase const &msg) const -> bool final {
         return not index(msg).none();
     }
 
     __attribute__((flatten)) auto
-    handle(BaseMsgT const &msg,
-           ExtraCallbackArgsT... args) const -> bool final {
+    handle(MsgBase const &msg, ExtraCallbackArgs... args) const -> bool final {
         auto const callback_candidates = index(msg);
 
         bool handled{};
@@ -60,4 +60,11 @@ struct indexed_handler : handler_interface<BaseMsgT, ExtraCallbackArgsT...> {
     }
 };
 
+template <typename MsgBase, typename... ExtraCallbackArgs>
+constexpr auto make_indexed_handler = []<typename Idx, typename CBs>(
+                                          Idx &&idx, CBs &&cbs) {
+    return indexed_handler<std::remove_cvref_t<Idx>, std::remove_cvref_t<CBs>,
+                           MsgBase, ExtraCallbackArgs...>{
+        std::forward<Idx>(idx), std::forward<CBs>(cbs)};
+};
 } // namespace msg

include/msg/handler.hpp

@@ -7,19 +7,19 @@
 
 namespace msg {
 
-template <typename Callbacks, typename BaseMsg, typename... ExtraCallbackArgs>
-struct handler : handler_interface<BaseMsg, ExtraCallbackArgs...> {
+template <typename Callbacks, typename MsgBase, typename... ExtraCallbackArgs>
+struct handler : handler_interface<MsgBase, ExtraCallbackArgs...> {
     Callbacks callbacks{};
 
     constexpr explicit handler(Callbacks new_callbacks)
         : callbacks{new_callbacks} {}
 
-    auto is_match(BaseMsg const &msg) const -> bool final {
+    auto is_match(MsgBase const &msg) const -> bool final {
         return stdx::any_of(
             [&](auto &callback) { return callback.is_match(msg); }, callbacks);
     }
 
-    auto handle(BaseMsg const &msg,
+    auto handle(MsgBase const &msg,
                 ExtraCallbackArgs... args) const -> bool final {
         auto const found_valid_callback = stdx::apply(
             [&](auto &...cbs) -> bool {

include/msg/handler_builder.hpp

@@ -6,21 +6,20 @@
 #include <stdx/tuple_algorithms.hpp>
 
 namespace msg {
-template <typename CallbacksT, typename BaseMsgT,
-          typename... ExtraCallbackArgsT>
+template <typename CallbacksT, typename MsgBase, typename... ExtraCallbackArgs>
 struct handler_builder {
     CallbacksT callbacks;
 
     template <typename... Ts> [[nodiscard]] constexpr auto add(Ts... ts) {
         auto new_callbacks =
             stdx::tuple_cat(callbacks, stdx::make_tuple(ts...));
         using new_callbacks_t = decltype(new_callbacks);
-        return handler_builder<new_callbacks_t, BaseMsgT,
-                               ExtraCallbackArgsT...>{new_callbacks};
+        return handler_builder<new_callbacks_t, MsgBase, ExtraCallbackArgs...>{
+            new_callbacks};
     }
 
     template <typename BuilderValue> constexpr static auto build() {
-        return handler<CallbacksT, BaseMsgT, ExtraCallbackArgsT...>{
+        return handler<CallbacksT, MsgBase, ExtraCallbackArgs...>{
             BuilderValue::value.callbacks};
     }
 };

include/msg/handler_interface.hpp

@@ -1,11 +1,11 @@
 #pragma once
 
 namespace msg {
-template <typename MsgBaseT, typename... ExtraCallbackArgsT>
+template <typename MsgBase, typename... ExtraCallbackArgs>
 struct handler_interface {
-    virtual auto is_match(MsgBaseT const &msg) const -> bool = 0;
+    virtual auto is_match(MsgBase const &msg) const -> bool = 0;
 
-    virtual auto handle(MsgBaseT const &msg,
-                        ExtraCallbackArgsT... extra_args) const -> bool = 0;
+    virtual auto handle(MsgBase const &msg,
+                        ExtraCallbackArgs... extra_args) const -> bool = 0;
 };
 } // namespace msg

include/msg/indexed_builder.hpp

@@ -17,13 +17,13 @@
 
 namespace msg {
 // TODO: needs index configuration
-template <typename IndexSpec, typename CallbacksT, typename BaseMsgT,
-          typename... ExtraCallbackArgsT>
+template <typename IndexSpec, typename Callbacks, typename MsgBase,
+          typename... ExtraCallbackArgs>
 struct indexed_builder
-    : indexed_builder_base<indexed_builder, IndexSpec, CallbacksT, BaseMsgT,
-                           ExtraCallbackArgsT...> {
-    using base_t = indexed_builder_base<indexed_builder, IndexSpec, CallbacksT,
-                                        BaseMsgT, ExtraCallbackArgsT...>;
+    : indexed_builder_base<indexed_builder, IndexSpec, Callbacks, MsgBase,
+                           ExtraCallbackArgs...> {
+    using base_t = indexed_builder_base<indexed_builder, IndexSpec, Callbacks,
+                                        MsgBase, ExtraCallbackArgs...>;
 
     template <typename I, auto E>
     static CONSTEVAL auto get_entry(auto const &indices) {
@@ -73,14 +73,12 @@ struct indexed_builder
             });
 
         constexpr auto num_callbacks = BuilderValue::value.callbacks.size();
-        constexpr std::array<typename base_t::callback_func_t, num_callbacks>
-            callback_array =
-                base_t::template create_callback_array<BuilderValue>(
-                    std::make_index_sequence<num_callbacks>{});
+        constexpr auto callback_array =
+            base_t::template create_callback_array<BuilderValue>(
+                std::make_index_sequence<num_callbacks>{});
 
-        return indexed_handler{
-            callback_args_t<BaseMsgT, ExtraCallbackArgsT...>{}, baked_indices,
-            callback_array};
+        return make_indexed_handler<MsgBase, ExtraCallbackArgs...>(
+            baked_indices, callback_array);
     }
 };
 

include/msg/indexed_handler.hpp

@@ -6,12 +6,12 @@
 
 namespace msg {
 
-template <typename... IndicesT> struct indices : IndicesT... {
-    CONSTEVAL explicit indices(IndicesT... index_args)
-        : IndicesT{index_args}... {}
+template <typename... Indices> struct indices : Indices... {
+    CONSTEVAL explicit indices(Indices... index_args)
+        : Indices{index_args}... {}
 
     constexpr auto operator()(auto const &data) const {
-        return (this->IndicesT::operator()(data) & ...);
+        return (this->Indices::operator()(data) & ...);
     }
 };
 

include/msg/indexed_service.hpp

@@ -7,10 +7,10 @@
 #include <stdx/tuple.hpp>
 
 namespace msg {
-template <typename IndexSpec, typename MsgBaseT, typename... ExtraCallbackArgsT>
+template <typename IndexSpec, typename MsgBase, typename... ExtraCallbackArgs>
 struct indexed_service
     : cib::builder_meta<
-          indexed_builder<IndexSpec, stdx::tuple<>, MsgBaseT,
-                          ExtraCallbackArgsT...>,
-          handler_interface<MsgBaseT, ExtraCallbackArgsT...> const *> {};
+          indexed_builder<IndexSpec, stdx::tuple<>, MsgBase,
+                          ExtraCallbackArgs...>,
+          handler_interface<MsgBase, ExtraCallbackArgs...> const *> {};
 } // namespace msg

include/msg/message.hpp

@@ -629,8 +629,8 @@ constexpr auto equivalent(O1 const &lhs, O2 const &rhs) {
 }
 
 template <typename Msg, typename F, typename S, typename... Args>
-constexpr auto call_with_message(F &&f, S &&s,
-                                 Args &&...args) -> decltype(auto) {
+__attribute__((flatten, always_inline)) constexpr auto
+call_with_message(F &&f, S &&s, Args &&...args) -> decltype(auto) {
     if constexpr (requires {
                       std::forward<F>(f)(std::forward<S>(s),
                                          std::forward<Args>(args)...);

include/msg/service.hpp

@@ -7,9 +7,9 @@
 #include <stdx/tuple.hpp>
 
 namespace msg {
-template <typename MsgBaseT, typename... ExtraCallbackArgsT>
+template <typename MsgBase, typename... ExtraCallbackArgs>
 struct service
     : cib::builder_meta<
-          handler_builder<stdx::tuple<>, MsgBaseT, ExtraCallbackArgsT...>,
-          handler_interface<MsgBaseT, ExtraCallbackArgsT...> const *> {};
+          handler_builder<stdx::tuple<>, MsgBase, ExtraCallbackArgs...>,
+          handler_interface<MsgBase, ExtraCallbackArgs...> const *> {};
 } // namespace msg