✨ Add environments for message definitions

elbeno · elbeno · commit aba9fc19f46a · 2025-03-05T17:12:25.000-07:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -25,7 +25,7 @@ include(cmake/string_catalog.cmake)
 add_versioned_package("gh:boostorg/mp11#boost-1.83.0")
 fmt_recipe(11.1.3)
 add_versioned_package("gh:intel/cpp-baremetal-concurrency#7c5b26c")
-add_versioned_package("gh:intel/cpp-std-extensions#ec95cd6")
+add_versioned_package("gh:intel/cpp-std-extensions#7725142")
 add_versioned_package("gh:intel/cpp-baremetal-senders-and-receivers#73d95bc")
 
 set(GEN_STR_CATALOG
diff --git a/include/msg/message.hpp b/include/msg/message.hpp
@@ -9,7 +9,7 @@
 
 #include <stdx/compiler.hpp>
 #include <stdx/ct_string.hpp>
-#include <stdx/cx_vector.hpp>
+#include <stdx/env.hpp>
 #include <stdx/iterator.hpp>
 #include <stdx/ranges.hpp>
 #include <stdx/span.hpp>
@@ -197,7 +197,7 @@ template <typename... Fields> struct storage_size {
 
 template <typename F> using name_for = typename F::name_t;
 
-template <stdx::ct_string Name, typename... Fields> class message_access {
+template <stdx::ct_string Name, typename... Fields> class msg_access {
     using FieldsTuple =
         decltype(stdx::make_indexed_tuple<name_for>(Fields{}...));
 
@@ -295,10 +295,11 @@ concept storage_like = stdx::range<T> and requires {
     typename T::value_type;
 };
 
-template <stdx::ct_string Name, typename... Fields> struct message;
+template <stdx::ct_string Name, typename Env, typename... Fields>
+struct message;
 
-template <stdx::ct_string Name> struct msg_q {
-    template <typename... Fields> using fn = message<Name, Fields...>;
+template <stdx::ct_string Name, typename Env> struct msg_q {
+    template <typename... Fields> using fn = message<Name, Env, Fields...>;
 };
 
 template <typename F1, typename F2>
@@ -312,9 +313,9 @@ using unique_by_name = boost::mp11::mp_unique_if<
     boost::mp11::mp_sort<boost::mp11::mp_list<Fields...>, field_sort_fn>,
     name_equal_fn>;
 
-template <stdx::ct_string Name, typename... Fields>
+template <stdx::ct_string Name, typename Env, typename... Fields>
 using message_without_unique_field_names =
-    boost::mp11::mp_apply_q<detail::msg_q<Name>,
+    boost::mp11::mp_apply_q<detail::msg_q<Name, Env>,
                             detail::unique_by_name<Fields...>>;
 
 template <stdx::ct_string Name, typename... Fields>
@@ -323,12 +324,45 @@ struct message_with_unique_field_names {
                       name_for, boost::mp11::mp_list<Fields...>>>::value,
                   "Message contains fields with duplicate names");
 
-    using type = message_without_unique_field_names<Name, Fields...>;
+    using type =
+        message_without_unique_field_names<Name, stdx::env<>, Fields...>;
+};
+
+template <stdx::ct_string Name, stdx::envlike Env, typename... Fields>
+struct message_with_unique_field_names<Name, Env, Fields...> {
+    static_assert(boost::mp11::mp_is_set<boost::mp11::mp_transform<
+                      name_for, boost::mp11::mp_list<Fields...>>>::value,
+                  "Message contains fields with duplicate names");
+
+    using type = message_without_unique_field_names<Name, Env, Fields...>;
 };
 
-template <stdx::ct_string Name, typename... Fields> struct message {
+template <stdx::ct_string Name, typename Access, typename T> struct msg_base {
+    constexpr static auto name = Name;
+
+    constexpr auto as_derived() const -> T const & {
+        return static_cast<T const &>(*this);
+    }
+    constexpr auto as_derived() -> T & { return static_cast<T &>(*this); }
+
+    [[nodiscard]] constexpr auto get(auto f) const {
+        return Access::get(as_derived().data(), f);
+    }
+    constexpr auto set(auto... fs) -> void {
+        Access::set(as_derived().data(), fs...);
+    }
+    constexpr auto set() -> void {}
+
+    [[nodiscard]] constexpr auto describe() const {
+        return Access::describe(as_derived().data());
+    }
+};
+
+template <stdx::ct_string Name, typename Env, typename... Fields>
+struct message {
     using fields_t = stdx::type_list<Fields...>;
-    using access_t = detail::message_access<Name, Fields...>;
+    using env_t = Env;
+    using access_t = msg_access<Name, Fields...>;
     using default_storage_t = typename access_t::default_storage_t;
     using default_span_t = typename access_t::default_span_t;
     using default_const_span_t = typename access_t::default_const_span_t;
@@ -342,32 +376,13 @@ template <stdx::ct_string Name, typename... Fields> struct message {
 
     template <auto N, typename Unit = bit_unit>
     using shifted_by =
-        message<Name, typename Fields::template shifted_by<N, Unit>...>;
+        message<Name, Env, typename Fields::template shifted_by<N, Unit>...>;
 
     template <typename S>
     constexpr static auto fits_inside =
         (... and Fields::template fits_inside<S>());
 
-    template <typename T> struct base {
-        constexpr static auto name = Name;
-
-        constexpr auto as_derived() const -> T const & {
-            return static_cast<T const &>(*this);
-        }
-        constexpr auto as_derived() -> T & { return static_cast<T &>(*this); }
-
-        [[nodiscard]] constexpr auto get(auto f) const {
-            return access_t::get(as_derived().data(), f);
-        }
-        constexpr auto set(auto... fs) -> void {
-            access_t::set(as_derived().data(), fs...);
-        }
-        constexpr auto set() -> void {}
-
-        [[nodiscard]] constexpr auto describe() const {
-            return access_t::describe(as_derived().data());
-        }
-    };
+    template <typename T> using base = msg_base<Name, access_t, T>;
 
     template <typename> struct owner_t;
 
@@ -583,13 +598,17 @@ template <stdx::ct_string Name, typename... Fields> struct message {
     // name (see unique_by_name)
     template <stdx::ct_string NewName, typename... NewFields>
     using extension =
-        message_without_unique_field_names<NewName, NewFields..., Fields...>;
+        message_without_unique_field_names<NewName, Env, NewFields...,
+                                           Fields...>;
+
+    template <stdx::envlike E>
+    using with_env = message<Name, stdx::append_env_t<Env, E>, Fields...>;
 };
 } // namespace detail
 
-template <stdx::ct_string Name, typename... Fields>
+template <stdx::ct_string Name, typename... Ts>
 using message =
-    typename detail::message_with_unique_field_names<Name, Fields...>::type;
+    typename detail::message_with_unique_field_names<Name, Ts...>::type;
 
 template <typename T> using owning = typename T::template owner_t<>;
 template <typename T> using mutable_view = typename T::mutable_view_t;
@@ -681,15 +700,16 @@ using shifted_msgs =
                                 msg_offsets<AlignTo, Msgs...>,
                                 stdx::type_list<Msgs..., msg::message<"end">>>;
 
-template <stdx::ct_string Name> struct combiner {
-    template <typename... Fields> using fn = msg::message<Name, Fields...>;
+template <stdx::ct_string Name, stdx::envlike Env> struct combiner {
+    template <typename... Fields> using fn = msg::message<Name, Env, Fields...>;
 };
 
 template <stdx::ct_string Name> struct combine_q {
     template <typename... Msgs>
         requires(sizeof...(Msgs) > 0)
     using fn = boost::mp11::mp_apply_q<
-        combiner<Name>, boost::mp11::mp_append<typename Msgs::fields_t...>>;
+        combiner<Name, stdx::append_env_t<typename Msgs::env_t...>>,
+        boost::mp11::mp_append<typename Msgs::fields_t...>>;
 };
 } // namespace detail
 
@@ -709,32 +729,37 @@ using is_locatable = std::bool_constant<requires { F::sort_key; }>;
 template <typename F1, typename F2>
 using field_size_sort_fn = std::bool_constant < F2::bitsize<F1::bitsize>;
 
-template <stdx::ct_string Name, typename... Fields> struct field_locator {
+template <stdx::ct_string Name, typename... Fields>
+struct field_locator : field_locator<Name, stdx::env<>, Fields...> {};
+
+template <stdx::ct_string Name, stdx::envlike Env, typename... Fields>
+struct field_locator<Name, Env, Fields...> {
     using fields = boost::mp11::mp_partition<boost::mp11::mp_list<Fields...>,
                                              is_locatable>;
     using located_fields = boost::mp11::mp_first<fields>;
     using unlocated_fields = boost::mp11::mp_second<fields>;
 
-    using located_msg = boost::mp11::mp_apply_q<combiner<Name>, located_fields>;
+    using located_msg =
+        boost::mp11::mp_apply_q<combiner<Name, stdx::env<>>, located_fields>;
 
     using auto_fields =
         boost::mp11::mp_sort<unlocated_fields, field_size_sort_fn>;
 
     template <typename F>
     using as_singleton_message =
-        msg::message<Name, typename F::default_located>;
+        msg::message<Name, Env, typename F::default_located>;
     using auto_msgs =
         boost::mp11::mp_transform<as_singleton_message, auto_fields>;
 
     using all_msgs = boost::mp11::mp_push_front<auto_msgs, located_msg>;
 
     template <typename... Msgs>
     using pack = msg::pack<Name, std::uint8_t, Msgs...>;
-    using msg_type = boost::mp11::mp_apply<pack, all_msgs>;
+    using msg_type =
+        typename boost::mp11::mp_apply<pack, all_msgs>::template with_env<Env>;
 };
 } // namespace detail
 
-template <stdx::ct_string Name, typename... Fields>
-using relaxed_message =
-    typename detail::field_locator<Name, Fields...>::msg_type;
+template <stdx::ct_string Name, typename... Ts>
+using relaxed_message = typename detail::field_locator<Name, Ts...>::msg_type;
 } // namespace msg
diff --git a/test/msg/message.cpp b/test/msg/message.cpp
@@ -428,7 +428,6 @@ TEST_CASE("view_of concept", "[message]") {
 TEST_CASE("message fields are canonically sorted by lsb", "[message]") {
     using defn = message<"msg", field2, field1>;
     static_assert(std::is_same_v<defn, message<"msg", field1, field2>>);
-    static_assert(std::is_same_v<defn, detail::message<"msg", field1, field2>>);
 }
 
 TEST_CASE("extend message with more fields", "[message]") {
@@ -642,3 +641,58 @@ TEST_CASE("pack with empty messages", "[message]") {
                 f4::shifted_by<m1::size<std::uint8_t>::value, std::uint8_t>>;
     static_assert(std::is_same_v<defn, expected_defn>);
 }
+
+namespace {
+[[maybe_unused]] constexpr inline struct custom_t {
+    template <typename T>
+        requires true // more constrained
+    CONSTEVAL auto operator()(T &&t) const
+        noexcept(noexcept(std::forward<T>(t).query(std::declval<custom_t>())))
+            -> decltype(std::forward<T>(t).query(*this)) {
+        return std::forward<T>(t).query(*this);
+    }
+
+    CONSTEVAL auto operator()(auto &&) const { return 42; }
+} custom;
+} // namespace
+
+TEST_CASE("message with default empty environment", "[message]") {
+    static_assert(custom(msg_defn::env_t{}) == 42);
+}
+
+TEST_CASE("message with defined environment", "[message]") {
+    using env_t = stdx::make_env_t<custom, 17>;
+    using defn = message<"msg", env_t, id_field::with_required<0x80>, field1,
+                         field2, field3>;
+    static_assert(custom(defn::env_t{}) == 17);
+}
+
+TEST_CASE("supplement message environment", "[message]") {
+    using env_t = stdx::make_env_t<custom, 17>;
+    using defn = message<"msg", env_t, id_field::with_required<0x80>, field1,
+                         field2, field3>;
+    using new_defn = defn::with_env<stdx::make_env_t<custom, 18>>;
+    static_assert(custom(new_defn::env_t{}) == 18);
+}
+
+TEST_CASE("combine appends environments", "[message]") {
+    using env1_t = stdx::make_env_t<custom, 17>;
+    using m1 = message<"m1", env1_t>;
+
+    using env2_t = stdx::make_env_t<custom, 18>;
+    using m2 = message<"m2", env2_t>;
+
+    using defn = combine<"defn", m1, m2>;
+    static_assert(custom(defn::env_t{}) == 18);
+}
+
+TEST_CASE("pack appends environments", "[message]") {
+    using env1_t = stdx::make_env_t<custom, 17>;
+    using m1 = message<"m1", env1_t>;
+
+    using env2_t = stdx::make_env_t<custom, 18>;
+    using m2 = message<"m2", env2_t>;
+
+    using defn = pack<"defn", std::uint8_t, m1, m2>;
+    static_assert(custom(defn::env_t{}) == 18);
+}
diff --git a/test/msg/relaxed_message.cpp b/test/msg/relaxed_message.cpp
@@ -65,3 +65,28 @@ TEST_CASE("auto field without default value", "[relaxed_message]") {
         "msg", auto_f1::located<at{0_dw, 31_msb, 0_lsb}>::without_default>;
     static_assert(std::is_same_v<defn, expected_defn>);
 }
+
+namespace {
+[[maybe_unused]] constexpr inline struct custom_t {
+    template <typename T>
+        requires true // more constrained
+    CONSTEVAL auto operator()(T &&t) const
+        noexcept(noexcept(std::forward<T>(t).query(std::declval<custom_t>())))
+            -> decltype(std::forward<T>(t).query(*this)) {
+        return std::forward<T>(t).query(*this);
+    }
+
+    CONSTEVAL auto operator()(auto &&) const { return 42; }
+} custom;
+} // namespace
+
+TEST_CASE("message with default empty environment", "[relaxed_message]") {
+    using defn = relaxed_message<"msg", auto_f1, auto_f2>;
+    static_assert(custom(defn::env_t{}) == 42);
+}
+
+TEST_CASE("message with defined environment", "[message]") {
+    using env_t = stdx::make_env_t<custom, 17>;
+    using defn = relaxed_message<"msg", env_t, auto_f1, auto_f2>;
+    static_assert(custom(defn::env_t{}) == 17);
+}
