Rework TypeId stuff at SubscriberImpl to be dynamic modules friendly

docs/examples/1_presentation/example_1_presentation_1_ping_user_service_udp.cpp

@@ -26,7 +26,6 @@
 #include <libcyphal/transport/udp/udp_transport_impl.hpp>
 #include <libcyphal/types.hpp>
 
-#include <cassert>  // NOLINT for NUNAVUT_ASSERT
 #include <nunavut/support/serialization.hpp>
 
 #include <gmock/gmock.h>

docs/examples/1_presentation/example_1_presentation_2_heartbeat_getinfo_udp.cpp

@@ -171,7 +171,7 @@ TEST_F(Example_1_Presentation_2_Heartbeat_GetInfo_Udp, main)
     ASSERT_THAT(heartbeat_subscriber, testing::Optional(testing::_));
     heartbeat_subscriber->setOnReceiveCallback([&](const auto& arg) {
         //
-        state.heartbeat_.print(arg.approx_now - startup_time_, arg.message, arg.metadata);
+        NodeHelpers::Heartbeat::print(arg.approx_now - startup_time_, arg.message, arg.metadata);
     });
 
     // Bring up 'GetInfo' server.

docs/examples/1_presentation/example_1_presentation_3_hb_getinfo_ping_linux_can.cpp

@@ -27,12 +27,9 @@
 #include <libcyphal/transport/types.hpp>
 #include <libcyphal/types.hpp>
 
-#include <cassert>  // NOLINT for NUNAVUT_ASSERT
 #include <nunavut/support/serialization.hpp>
 #include <uavcan/node/GetInfo_1_0.hpp>
-#include <uavcan/node/Health_1_0.hpp>
 #include <uavcan/node/Heartbeat_1_0.hpp>
-#include <uavcan/node/Mode_1_0.hpp>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

docs/examples/2_application/example_2_application_0_node_hb_getinfo_udp.cpp

@@ -30,6 +30,7 @@
 #include <gtest/gtest.h>
 
 #include <algorithm>
+#include <array>
 #include <chrono>
 #include <cstdint>
 #include <cstdlib>
@@ -153,10 +154,13 @@ TEST_F(Example_2_Application_0_NodeHeartbeatGetInfo_Udp, main)
     ASSERT_THAT(maybe_node, testing::VariantWith<Node>(testing::_)) << "Can't create node.";
     auto node = cetl::get<Node>(std::move(maybe_node));
     //
-    const std::string node_name{"org.opencyphal.Ex_2_App_0_Node_UDP"};
-    std::copy_n(node_name.begin(),
-                std::min(node_name.size(), 50UL),
-                std::back_inserter(node.getInfoProvider().response().name));
+    auto& get_info_prov = node.getInfoProvider();
+    get_info_prov  //
+        .setSoftwareVersion(0, 1)
+        .setHardwareVersion(0, 2)
+        .setName("org.opencyphal.Ex_2_App_0_Node_UDP")
+        .setCertificateOfAuthenticity("my_cert")
+        .setUniqueId(std::array<std::uint8_t, 3>{0x12, 0x34, 0x56});
 
     // 4. Bring up registry provider, and expose several registers. Load persistent storage.
     //
@@ -167,15 +171,14 @@ TEST_F(Example_2_Application_0_NodeHeartbeatGetInfo_Udp, main)
     const BitArray param_ro_val{BitArray::_traits_::TypeOf::value{{true, false}, mr_alloc_}, mr_alloc_};
     auto           param_ro = rgy.route("ro", [&param_ro_val] { return param_ro_val; });
     //
-    auto& get_info   = node.getInfoProvider().response();
-    auto  param_name = rgy.route(  //
+    auto param_name = rgy.route(  //
         "uavcan.node.description",
-        [this, &get_info] { return makeStringValue(registry::makeStringView(get_info.name)); },
-        [&get_info](const registry::IRegister::Value& value) -> cetl::optional<registry::SetError> {
+        [this, &get_info_prov] { return makeStringValue(registry::makeStringView(get_info_prov.response().name)); },
+        [&get_info_prov](const registry::IRegister::Value& value) -> cetl::optional<registry::SetError> {
             //
             if (const auto* const str = value.get_string_if())
             {
-                get_info.name = str->value;
+                get_info_prov.setName(registry::makeStringView(str->value));
                 return cetl::nullopt;
             }
             return registry::SetError::Semantics;

docs/examples/platform/node_helpers.hpp

@@ -19,7 +19,6 @@
 #include <libcyphal/transport/types.hpp>
 #include <libcyphal/types.hpp>
 
-#include <cassert>  // NOLINT for NUNAVUT_ASSERT
 #include <nunavut/support/serialization.hpp>
 #include <uavcan/node/GetInfo_1_0.hpp>
 #include <uavcan/node/Health_1_0.hpp>

include/libcyphal/application/node/get_info_provider.hpp

@@ -11,10 +11,14 @@
 #include "libcyphal/types.hpp"
 
 #include <cetl/pf17/cetlpf.hpp>
+#include <cetl/pf20/cetlpf.hpp>
 
 #include <uavcan/node/GetInfo_1_0.hpp>
 
+#include <algorithm>
 #include <chrono>
+#include <cstdint>
+#include <iterator>
 #include <utility>
 
 namespace libcyphal
@@ -86,14 +90,120 @@ class GetInfoProvider final  // NOSONAR cpp:S4963
     /// @brief Sets the response transmission timeout (default is 1s).
     ///
     /// @param timeout Duration of the response transmission timeout. Applied for the next response transmission.
+    /// @return Reference to self for method chaining.
     ///
-    void setResponseTimeout(const Duration& timeout) noexcept
+    GetInfoProvider& setResponseTimeout(const Duration& timeout) noexcept
     {
         response_timeout_ = timeout;
+        return *this;
+    }
+
+    /// @brief Sets the node unique 128-bit id in the GetInfo response.
+    ///
+    /// Default is all zeros.
+    /// Truncates the id if it exceeds 16 bytes capacity of the response field.
+    ///
+    /// @return Reference to self for method chaining.
+    ///
+    GetInfoProvider& setUniqueId(const cetl::span<const std::uint8_t> id) noexcept
+    {
+        response_.unique_id = {};
+        (void) std::copy_n(id.data(), std::min(id.size(), response_.unique_id.size()), response_.unique_id.begin());
+        return *this;
+    }
+
+    /// @brief Sets the node protocol version in the GetInfo response.
+    ///
+    /// Default is '1.0'.
+    ///
+    /// @return Reference to self for method chaining.
+    ///
+    GetInfoProvider& setProtocolVersion(const std::uint8_t major, const std::uint8_t minor) noexcept  // NOLINT
+    {
+        response_.protocol_version.major = major;
+        response_.protocol_version.minor = minor;
+        return *this;
+    }
+
+    /// @brief Sets the node hardware version in the GetInfo response.
+    ///
+    /// Default is '0.0'.
+    ///
+    /// @return Reference to self for method chaining.
+    ///
+    GetInfoProvider& setHardwareVersion(const std::uint8_t major, const std::uint8_t minor) noexcept  // NOLINT
+    {
+        response_.hardware_version.major = major;
+        response_.hardware_version.minor = minor;
+        return *this;
+    }
+
+    /// @brief Sets the node software version in the GetInfo response.
+    ///
+    /// Default is '0.0'.
+    ///
+    /// @return Reference to self for method chaining.
+    ///
+    GetInfoProvider& setSoftwareVersion(const std::uint8_t major, const std::uint8_t minor) noexcept  // NOLINT
+    {
+        response_.software_version.major = major;
+        response_.software_version.minor = minor;
+        return *this;
+    }
+
+    /// @brief Sets the node software Version Control System (VCS) revision in the GetInfo response.
+    ///
+    /// Default is `0`.
+    ///
+    /// @return Reference to self for method chaining.
+    ///
+    GetInfoProvider& setSoftwareVcsRevisionId(const std::uint64_t revision_id)
+    {
+        response_.software_vcs_revision_id = revision_id;
+        return *this;
+    }
+
+    /// @brief Sets the node software image CRC in the GetInfo response.
+    ///
+    /// Default is empty (not present).
+    ///
+    /// @return Reference to self for method chaining.
+    ///
+    GetInfoProvider& setSoftwareImageCrc(const std::uint64_t crc)
+    {
+        response_.software_image_crc.clear();
+        response_.software_image_crc.push_back(crc);
+        return *this;
+    }
+
+    /// @brief Sets the node name in the GetInfo response.
+    ///
+    /// Default is ''.
+    /// Truncates the name if it exceeds the capacity of the response field.
+    ///
+    /// @return Reference to self for method chaining.
+    ///
+    GetInfoProvider& setName(const cetl::string_view name)
+    {
+        return setStringField<ArrayCapacity::name>(response_.name, name);
+    }
+
+    /// @brief Sets the node certificate of authenticity in the GetInfo response.
+    ///
+    /// Default is ''.
+    /// Truncates the certificate if it exceeds the capacity of the response field.
+    ///
+    /// @return Reference to self for method chaining.
+    ///
+    GetInfoProvider& setCertificateOfAuthenticity(const cetl::string_view certificate)
+    {
+        return setStringField<ArrayCapacity::certificate_of_authenticity>(response_.certificate_of_authenticity,
+                                                                          certificate);
     }
 
 private:
-    using Server = presentation::ServiceServer<Service>;
+    using ArrayCapacity = Response::_traits_::ArrayCapacity;
+    using Server        = presentation::ServiceServer<Service>;
 
     GetInfoProvider(presentation::Presentation& presentation, Server&& server)
         : presentation_{presentation}
@@ -115,6 +225,16 @@ class GetInfoProvider final  // NOSONAR cpp:S4963
         });
     }
 
+    template <std::size_t Capacity, typename Field>
+    GetInfoProvider& setStringField(Field& field, const cetl::string_view value)
+    {
+        const auto dst_size = std::min(value.size(), Capacity);
+        field.clear();
+        field.reserve(dst_size);
+        (void) std::copy_n(value.begin(), dst_size, std::back_inserter(field));
+        return *this;
+    }
+
     // MARK: Data members:
 
     presentation::Presentation& presentation_;

include/libcyphal/application/node/heartbeat_producer.hpp

@@ -101,7 +101,7 @@ class HeartbeatProducer final  // NOSONAR cpp:S4963
         ///
         struct Arg
         {
-            /// Holds current heartbeat message.
+            /// Holds the current heartbeat message.
             Message& message;
 
             /// Holds the approximate time when the callback was called.
@@ -110,7 +110,7 @@ class HeartbeatProducer final  // NOSONAR cpp:S4963
 
         /// @brief Defines signature of the heartbeat update callback function.
         ///
-        /// Size of the function is arbitrary (4 pointers), but should be enough for simple lambdas.
+        /// The size of the function is arbitrary (4 pointers), but should be enough for simple lambdas.
         ///
         static constexpr std::size_t FunctionSize = sizeof(void*) * 4;
         using Function                            = cetl::pmr::function<void(const Arg& arg), FunctionSize>;

include/libcyphal/application/registry/register.hpp

@@ -233,11 +233,12 @@ using Register = ImplementationCell<IRegister, cetl::unbounded_variant<Footprint
 inline uavcan::_register::Name_1_0 makeRegisterName(const uavcan::_register::Name_1_0::allocator_type& alloc,
                                                     const IRegister::Name                              name)
 {
-    uavcan::_register::Name_1_0 out{alloc};
+    using uavcan::_register::Name_1_0;
+
+    Name_1_0 out{alloc};
     if (!name.empty())
     {
-        // TODO: Fix Nunavut to expose `ARRAY_CAPACITY` so we can use it here instead of 255 hardcode.
-        constexpr std::size_t NameCapacity = 255U;
+        constexpr auto NameCapacity = Name_1_0::_traits_::ArrayCapacity::name;
         out.name.resize(std::min(name.size(), NameCapacity));
 
         // No Sonar `cpp:S5356` b/c we need to pass name payload as raw data.

include/libcyphal/presentation/client.hpp

@@ -18,7 +18,6 @@
 #include <cetl/pf17/cetlpf.hpp>
 #include <cetl/pf20/cetlpf.hpp>
 
-#include <cassert>  // NOLINT for NUNAVUT_ASSERT
 #include <nunavut/support/serialization.hpp>
 
 #include <array>

include/libcyphal/presentation/common_helpers.hpp

@@ -11,7 +11,6 @@
 
 #include <cetl/pf17/cetlpf.hpp>
 
-#include <cassert>  // NOLINT for NUNAVUT_ASSERT
 #include <nunavut/support/serialization.hpp>
 
 #include <cstdint>

include/libcyphal/presentation/publisher.hpp

@@ -16,7 +16,6 @@
 #include <cetl/pf17/cetlpf.hpp>
 #include <cetl/pf20/cetlpf.hpp>
 
-#include <cassert>  // NOLINT for NUNAVUT_ASSERT
 #include <nunavut/support/serialization.hpp>
 
 #include <array>

include/libcyphal/presentation/response_promise.hpp

@@ -18,7 +18,6 @@
 #include <cetl/pf17/cetlpf.hpp>
 #include <cetl/pmr/function.hpp>
 
-#include <cassert>  // NOLINT for NUNAVUT_ASSERT
 #include <nunavut/support/serialization.hpp>
 
 #include <cstddef>

include/libcyphal/presentation/server.hpp

@@ -19,7 +19,6 @@
 #include <cetl/pf20/cetlpf.hpp>
 #include <cetl/pmr/function.hpp>
 
-#include <cassert>  // NOLINT for NUNAVUT_ASSERT
 #include <nunavut/support/serialization.hpp>
 
 #include <array>

include/libcyphal/presentation/subscriber.hpp

@@ -106,9 +106,10 @@ class SubscriberBase : public SubscriberImpl::CallbackNode  // NOSONAR cpp:S4963
 ///
 /// @tparam Message The message type of the subscriber. This type has the following requirements:
 ///                 - contains nested `allocator_type`, which is a PMR allocator
-///                 - constructible with the PMR allocator.
+///                 - constructible with the PMR allocator
 ///                 - contains `_traits_::ExtentBytes` constant
-///                 - has freestanding `deserialize` function under its namespace (so that ADL will find it).
+///                 - contains `_traits_::FullNameAndVersion()` static constexpr method (-> `const char*`)
+///                 - has freestanding `deserialize` function under its namespace (so that ADL will find it)
 ///
 template <typename Message>
 class Subscriber final : public detail::SubscriberBase
@@ -147,7 +148,7 @@ class Subscriber final : public detail::SubscriberBase
 
     explicit Subscriber(detail::SubscriberImpl* const impl)
         : SubscriberBase{impl,
-                         {Deserializer::getTypeId<Message>(),
+                         {Deserializer::TypeIdGenerator<Message>::get(),
                           Deserializer::deserializeMsgOnceForManySubs<Message, Subscriber>}}
     {
     }
@@ -209,7 +210,8 @@ class Subscriber<void> final : public detail::SubscriberBase
     friend class detail::SubscriberImpl;
 
     explicit Subscriber(detail::SubscriberImpl* const impl)
-        : SubscriberBase{impl, {Deserializer::getTypeId<void>(), Deserializer::passRawMessageAsIs<Subscriber>}}
+        : SubscriberBase{impl,
+                         {Deserializer::TypeIdGenerator<void>::get(), Deserializer::passRawMessageAsIs<Subscriber>}}
     {
     }
 

include/libcyphal/presentation/subscriber_impl.hpp

@@ -10,6 +10,7 @@
 #include "shared_object.hpp"
 
 #include "libcyphal/common/cavl/cavl.hpp"
+#include "libcyphal/common/crc.hpp"
 #include "libcyphal/transport/msg_sessions.hpp"
 #include "libcyphal/transport/scattered_buffer.hpp"
 #include "libcyphal/transport/types.hpp"
@@ -53,18 +54,18 @@ class SubscriberImpl final : public cavl::Node<SubscriberImpl>, public SharedObj
 
             };  // Context
 
-            using TypeId = std::uintptr_t;
+            using TypeId = std::uint64_t;
             template <typename Message>
-            static TypeId getTypeId() noexcept
+            struct TypeIdGenerator
             {
-                static const struct
+                static TypeId get() noexcept
                 {
-                } placeholder{};
-                // No Lint and Sonar cpp:S3630 "reinterpret_cast" should not be used" b/c it's a part of
-                // the type id/erasure pattern - we use this cast to be able to compare deserializers.
-                // NOLINTNEXTLINE(*-pro-type-reinterpret-cast)
-                return reinterpret_cast<TypeId>(&placeholder);  // NOSONAR : cpp:S3630
-            }
+                    const cetl::string_view type_name{Message::_traits_::FullNameAndVersion()};
+                    const common::CRC64WE   crc64{type_name.cbegin(), type_name.cend()};
+                    return crc64.get();
+                }
+
+            };  // TypeIdGenerator
 
             template <typename Message, typename Subscriber>
             static void deserializeMsgOnceForManySubs(Context& context)
@@ -302,6 +303,15 @@ class SubscriberImpl final : public cavl::Node<SubscriberImpl>, public SharedObj
 
 };  // SubscriberImpl
 
+template <>
+struct SubscriberImpl::CallbackNode::Deserializer::TypeIdGenerator<void>
+{
+    static constexpr TypeId get() noexcept
+    {
+        return 0U;
+    }
+};
+
 }  // namespace detail
 }  // namespace presentation
 }  // namespace libcyphal