✨ Support tuple protocol on messages

Problem:
- It's sometimes useful to destructure messages.

Solution:
- Support the tuple protocol on (owning or view) messages.

Note:
- The field order is the canonical ordering of fields by lsb; this is not
  necessarily the declaration order in the message alias.

Author: elbeno

include/msg/message.hpp

@@ -356,6 +356,9 @@ template <stdx::ct_string Name, typename Access, typename T> struct msg_base {
 template <stdx::ct_string Name, typename Env, typename... Fields>
 struct message {
     using fields_t = stdx::type_list<Fields...>;
+    using num_fields_t = std::integral_constant<std::size_t, sizeof...(Fields)>;
+    template <std::size_t I> using nth_field_t = stdx::nth_t<I, Fields...>;
+
     using env_t = Env;
     using access_t = msg_access<Name, Fields...>;
     using default_storage_t = typename access_t::default_storage_t;

include/msg/message_destructure.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <msg/message.hpp>
+
+#include <stdx/type_traits.hpp>
+
+#include <cstddef>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+template <msg::messagelike M>
+struct std::tuple_size<M> : M::definition_t::num_fields_t {};
+
+template <std::size_t I, msg::messagelike M>
+struct std::tuple_element<I, M>
+    : std::type_identity<
+          typename M::definition_t::template nth_field_t<I>::value_type> {};
+
+namespace msg::detail {
+template <std::size_t I, msg::messagelike M>
+constexpr auto get(M &&m) -> decltype(auto) {
+    return std::forward<M>(m).get(typename std::remove_cvref_t<
+                                  M>::definition_t::template nth_field_t<I>{});
+}
+} // namespace msg::detail

test/msg/message.cpp

@@ -1,5 +1,6 @@
 #include <log/fmt/logger.hpp>
 #include <msg/message.hpp>
+#include <msg/message_destructure.hpp>
 
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_templated.hpp>
@@ -73,6 +74,24 @@ TEST_CASE("construct with field values", "[message]") {
     CHECK(0x0042'd00d == data[1]);
 }
 
+TEST_CASE("message supports tuple protocol", "[message]") {
+    [[maybe_unused]] test_msg msg{"f1"_field = 0xba11, "f2"_field = 0x42,
+                                  "f3"_field = 0xd00d};
+    STATIC_REQUIRE(std::tuple_size_v<test_msg> == 4);
+    STATIC_REQUIRE(
+        std::is_same_v<std::tuple_element_t<0, test_msg>, std::uint32_t>);
+}
+
+TEST_CASE("destructure owning message", "[message]") {
+    test_msg msg{"f1"_field = 0xba11, "f2"_field = 0x42, "f3"_field = 0xd00d};
+    STATIC_REQUIRE(std::tuple_size_v<test_msg> == 4);
+    auto const [f1, id, f3, f2] = msg;
+    CHECK(0x80 == id);
+    CHECK(0xba11 == f1);
+    CHECK(0x42 == f2);
+    CHECK(0xd00d == f3);
+}
+
 TEST_CASE("use field names as template args", "[message]") {
     auto msg = []<auto F>() {
         return test_msg{F = 0xba11};
@@ -123,6 +142,18 @@ TEST_CASE("view with read-only external storage", "[message]") {
     CHECK(0xd00d == msg.get("f3"_field));
 }
 
+TEST_CASE("destructure message view", "[message]") {
+    auto const arr =
+        typename msg_defn::default_storage_t{0x8000'ba11, 0x0042'd00d};
+    const_view<msg_defn> msg{arr};
+
+    auto const [f1, id, f3, f2] = msg;
+    CHECK(0x80 == id);
+    CHECK(0xba11 == f1);
+    CHECK(0x42 == f2);
+    CHECK(0xd00d == f3);
+}
+
 TEST_CASE("view with external storage (oversized)", "[message]") {
     auto const arr = std::array<std::uint32_t, 8>{0x8000'ba11, 0x0042'd00d};
     msg_defn::view_t msg{arr};