Merge pull request ekxide#25 from orecham/rmw-iox-2-serialization-support

Add ROS message serialization

Author: orecham

README.md

@@ -35,9 +35,8 @@ bindings to the Rust core.
 | Node                             | :white_check_mark: |
 | Guard Condition                  | :white_check_mark: |
 | Event                            | :construction:     |
-| Publish-Subscribe (Copy)         | :white_check_mark: |
-| Publish-Subscribe (Loan)         | :white_check_mark: |
-| Publish-Subscribe (Serialized)   | :construction:     |
+| Publish-Subscribe                | :white_check_mark: |
+| Message Serialization            | :white_check_mark: |
 | Server-Client                    | :construction:     |
 | Waitset                          | :white_check_mark: |
 | Graph                            | :construction:     |

doc/release-notes/unreleased.md

@@ -11,6 +11,8 @@
     conflicts when merging.
 -->
 
+* Serialize/deserialized non-self-contained messages into `iceoryx2` payloads [#2](https://github.com/ekxide/rmw_iceoryx2/issues/2)
+
 ### Bugfixes
 
 <!--

rmw_iceoryx2_cxx/CMakeLists.txt

@@ -45,7 +45,7 @@ set(AMENT_PACKAGES
     rosidl_typesupport_introspection_cpp
     rosidl_typesupport_fastrtps_c
     rosidl_typesupport_fastrtps_cpp
-    fastrtps
+    fastcdr
 )
 foreach(package ${AMENT_PACKAGES})
     find_package(${package} REQUIRED)
@@ -58,7 +58,6 @@ endforeach()
 add_library(${PROJECT_NAME} SHARED
   src/impl/common/names.cpp
   src/impl/message/introspection.cpp
-  src/impl/message/serialization.cpp
   src/impl/middleware/iceoryx2.cpp
   src/impl/runtime/context.cpp
   src/impl/runtime/guard_condition.cpp

rmw_iceoryx2_cxx/include/rmw_iceoryx2_cxx/impl/message/serialization.hpp

@@ -18,6 +18,7 @@
 #include "rmw_iceoryx2_cxx/impl/middleware/iceoryx2.hpp"
 #include "rmw_iceoryx2_cxx/impl/runtime/node.hpp"
 #include "rmw_iceoryx2_cxx/impl/runtime/sample_registry.hpp"
+#include "rosidl_typesupport_cpp/message_type_support.hpp"
 
 namespace rmw::iox2
 {
@@ -32,7 +33,6 @@ struct Error<Publisher>
 
 /// @brief Implementation of the RMW publisher for iceoryx2
 ///
-/// @details The publisher supports both zero-copy loans and copy-based publishing mechanisms.
 /// @details The implementation supports both copy and loan-based publishing mechanisms,
 ///          allowing for efficient zero-copy communication when possible.
 ///
@@ -59,14 +59,12 @@ class RMW_PUBLIC Publisher
     /// @param[out] error Optional error that is set if construction fails
     /// @param[in] node The node that owns this publisher
     /// @param[in] topic The topic name to publish to
-    /// @param[in] type The message type name
-    /// @param[in] size The maximum message payload size
+    /// @param[in] typesupport The message typesupport
     Publisher(CreationLock,
               iox::optional<ErrorType>& error,
               Node& node,
               const char* topic,
-              const char* type,
-              const uint64_t size);
+              const rosidl_message_type_support_t* type_support);
 
     /// @brief Get the unique identifier of this publisher
     /// @return The unique id or empty optional if failing to retrieve it from iceoryx2
@@ -76,21 +74,21 @@ class RMW_PUBLIC Publisher
     /// @return The topic name as string
     auto topic() const -> const std::string&;
 
-    /// @brief Get the message type name
-    /// @return The message type name as string
-    auto type() const -> const std::string&;
+    /// @brief Get the typesupport used by the publisher
+    /// @return Pointer to the typesupport stored in the loaded typesupport library
+    auto typesupport() const -> const rosidl_message_type_support_t*;
+
+    /// @brief Get the (unserialized) size of the message struct.
+    /// @return Size of the message
+    auto unserialized_size() const -> uint64_t;
 
     /// @brief Get the service name used internally, required for matching via iceoryx2
     /// @return The service name as string
     auto service_name() const -> const std::string&;
 
-    /// @brief Get the maximum payload size
-    /// @return The maximum payload size in bytes
-    auto payload_size() const -> uint64_t;
-
     /// @brief Loan memory for zero-copy publishing
     /// @return Expected containing pointer to loaned memory or error
-    auto loan() -> iox::expected<void*, ErrorType>;
+    auto loan(uint64_t number_of_bytes) -> iox::expected<void*, ErrorType>;
 
     /// @brief Return previously loaned memory without publishing
     /// @param[in] loaned_memory Pointer to the loaned memory to return
@@ -107,13 +105,13 @@ class RMW_PUBLIC Publisher
     /// @param[in] msg Pointer to the message data to copy
     /// @param[in] size Size of the message data in bytes
     /// @return Expected containing void or error if publish failed
-    auto publish_copy(const void* msg, uint64_t size) -> iox::expected<void, ErrorType>;
+    auto publish_copy(const void* data, uint64_t number_of_bytes) -> iox::expected<void, ErrorType>;
 
 private:
     const std::string m_topic;
-    const std::string m_type;
+    const rosidl_message_type_support_t* m_typesupport;
+    const uint64_t m_unserialized_size;
     const std::string m_service_name;
-    const uint64_t m_payload_size;
 
     iox::optional<IdType> m_iox_unique_id;
     iox::optional<IceoryxNotifier> m_iox2_notifier;

rmw_iceoryx2_cxx/include/rmw_iceoryx2_cxx/impl/runtime/publisher.hpp

@@ -70,7 +70,7 @@ class SampleRegistry
     /// @brief Remove and return a stored sample
     /// @param[in] loaned_memory Pointer to the payload data
     /// @return Expected containing the removed sample if found, error otherwise
-    auto release(uint8_t* loaned_memory) -> iox::expected<SampleType, ErrorType> {
+    auto release(const uint8_t* loaned_memory) -> iox::expected<SampleType, ErrorType> {
         using iox::err;
         using iox::ok;
         using iox::optional;
@@ -85,7 +85,7 @@ class SampleRegistry
     }
 
 private:
-    std::unordered_map<uint8_t*, SampleType> m_samples;
+    std::unordered_map<const uint8_t*, SampleType> m_samples;
 };
 
 } // namespace rmw::iox2

rmw_iceoryx2_cxx/include/rmw_iceoryx2_cxx/impl/runtime/sample_registry.hpp

@@ -17,6 +17,7 @@
 #include "rmw_iceoryx2_cxx/impl/common/creation_lock.hpp"
 #include "rmw_iceoryx2_cxx/impl/runtime/node.hpp"
 #include "rmw_iceoryx2_cxx/impl/runtime/sample_registry.hpp"
+#include "rosidl_typesupport_cpp/message_type_support.hpp"
 
 namespace rmw::iox2
 {
@@ -29,6 +30,12 @@ struct Error<Subscriber>
     using Type = SubscriberError;
 };
 
+struct SubscriberLoan
+{
+    uint8_t* bytes;
+    size_t number_of_bytes;
+};
+
 /// @brief Implementation of the RMW subscriber for iceoryx2
 /// @details The implementation supports both copy and loan-based data access patterns,
 ///          allowing for efficient zero-copy communication when possible.
@@ -54,8 +61,12 @@ class RMW_PUBLIC Subscriber
     /// @param[out] error Optional error that is set if construction fails
     /// @param[in] node The node that owns this subscriber
     /// @param[in] topic The topic name to subscribe to
-    /// @param[in] type The message type name
-    Subscriber(CreationLock, iox::optional<ErrorType>& error, Node& node, const char* topic, const char* type);
+    /// @param[in] typesupport The message typesupport
+    Subscriber(CreationLock,
+               iox::optional<ErrorType>& error,
+               Node& node,
+               const char* topic,
+               const rosidl_message_type_support_t* type_support);
 
     /// @brief Get the unique identifier of the subscriber
     /// @return Optional containing the raw ID of the subscriber
@@ -65,9 +76,9 @@ class RMW_PUBLIC Subscriber
     /// @return The topic name as string reference
     auto topic() const -> const std::string&;
 
-    /// @brief Get the message type name
-    /// @return The type name as string reference
-    auto type() const -> const std::string&;
+    /// @brief Get the typesupport used by the publisher
+    /// @return Pointer to the typesupport stored in the loaded typesupport library
+    auto typesupport() const -> const rosidl_message_type_support_t*;
 
     /// @brief Get the service name used internally, required for matching via iceoryx2
     /// @return The service name as string
@@ -80,16 +91,16 @@ class RMW_PUBLIC Subscriber
 
     /// @brief Take a loaned message without copying
     /// @return Expected containing optional pointer to the loaned message memory
-    auto take_loan() -> iox::expected<iox::optional<const void*>, ErrorType>;
+    auto take_loan() -> iox::expected<iox::optional<SubscriberLoan>, ErrorType>;
 
     /// @brief Return previously loaned message memory
     /// @param[in] loaned_memory Pointer to the loaned memory to return
     /// @return Expected containing void if successful
-    auto return_loan(void* loaned_memory) -> iox::expected<void, ErrorType>;
+    auto return_loan(void* loan) -> iox::expected<void, ErrorType>;
 
 private:
     const std::string m_topic;
-    const std::string m_type;
+    const rosidl_message_type_support_t* m_typesupport;
     const std::string m_service_name;
 
     iox::optional<IdType> m_iox2_unique_id;

rmw_iceoryx2_cxx/include/rmw_iceoryx2_cxx/impl/runtime/subscriber.hpp

@@ -24,7 +24,7 @@
   <depend>rosidl_typesupport_fastrtps_cpp</depend>
   <depend>rosidl_typesupport_introspection_c</depend>
   <depend>rosidl_typesupport_introspection_cpp</depend>
-  <depend>fastrtps</depend>
+  <depend>fastcdr</depend>
 
   <depend>iceoryx2_cxx</depend>
 

rmw_iceoryx2_cxx/package.xml

@@ -11,6 +11,7 @@
 
 #include "rmw_iceoryx2_cxx/impl/common/error_message.hpp"
 #include "rmw_iceoryx2_cxx/impl/common/names.hpp"
+#include "rmw_iceoryx2_cxx/impl/message/introspection.hpp"
 #include "rmw_iceoryx2_cxx/impl/middleware/iceoryx2.hpp"
 
 namespace rmw::iox2
@@ -20,12 +21,11 @@ Publisher::Publisher(CreationLock,
                      iox::optional<ErrorType>& error,
                      Node& node,
                      const char* topic,
-                     const char* type,
-                     const uint64_t payload_size)
+                     const rosidl_message_type_support_t* type_support)
     : m_topic{topic}
-    , m_type{type}
-    , m_service_name{::rmw::iox2::names::topic(topic)}
-    , m_payload_size{payload_size} {
+    , m_typesupport{type_support}
+    , m_unserialized_size{::rmw::iox2::message_size(type_support)}
+    , m_service_name{::rmw::iox2::names::topic(topic)} {
     auto iox2_service_name = Iceoryx2::ServiceName::create(m_service_name.c_str());
     if (iox2_service_name.has_error()) {
         RMW_IOX2_CHAIN_ERROR_MSG(::iox::into<const char*>(iox2_service_name.error()));
@@ -40,6 +40,8 @@ Publisher::Publisher(CreationLock,
                                    // TODO: make configurable
                                    .max_publishers(64)
                                    .max_subscribers(64)
+                                   .history_size(10)
+                                   .subscriber_max_buffer_size(10)
                                    .payload_alignment(8) // All ROS2 messages have alignment 8. Maybe?
                                    .open_or_create();    // TODO: set attribute for ROS typename
 
@@ -49,7 +51,10 @@ Publisher::Publisher(CreationLock,
         return;
     }
 
-    auto publisher = iox2_pubsub_service.value().publisher_builder().initial_max_slice_len(m_payload_size).create();
+    auto publisher = iox2_pubsub_service.value()
+                         .publisher_builder()
+                         .initial_max_slice_len(::rmw::iox2::message_size(m_typesupport))
+                         .create();
     if (publisher.has_error()) {
         RMW_IOX2_CHAIN_ERROR_MSG(::iox::into<const char*>(publisher.error()));
         error.emplace(ErrorType::PUBLISHER_CREATION_FAILURE);
@@ -84,23 +89,25 @@ auto Publisher::topic() const -> const std::string& {
     return m_topic;
 }
 
-auto Publisher::type() const -> const std::string& {
-    return m_type;
+auto Publisher::typesupport() const -> const rosidl_message_type_support_t* {
+    return m_typesupport;
 }
 
-auto Publisher::service_name() const -> const std::string& {
-    return m_service_name;
+
+auto Publisher::unserialized_size() const -> uint64_t {
+    return m_unserialized_size;
 }
 
-auto Publisher::payload_size() const -> uint64_t {
-    return m_payload_size;
+auto Publisher::service_name() const -> const std::string& {
+    return m_service_name;
 }
 
-auto Publisher::loan() -> iox::expected<void*, ErrorType> {
+// TODO: Make return uint8_t
+auto Publisher::loan(uint64_t number_of_bytes) -> iox::expected<void*, ErrorType> {
     using iox::err;
     using iox::ok;
 
-    auto sample = m_iox2_publisher->loan_slice_uninit(m_payload_size);
+    auto sample = m_iox2_publisher->loan_slice_uninit(number_of_bytes);
     if (sample.has_error()) {
         return err(ErrorType::LOAN_FAILURE);
     }
@@ -148,13 +155,13 @@ auto Publisher::publish_loan(void* loaned_memory) -> iox::expected<void, ErrorTy
     return ok();
 }
 
-auto Publisher::publish_copy(const void* msg, uint64_t size) -> iox::expected<void, ErrorType> {
+auto Publisher::publish_copy(const void* data, uint64_t number_of_bytes) -> iox::expected<void, ErrorType> {
     using ::iox::err;
     using ::iox::ImmutableSlice;
     using ::iox::ok;
 
     // Send
-    auto payload = ImmutableSlice<uint8_t>{static_cast<const uint8_t*>(msg), size};
+    auto payload = ImmutableSlice<uint8_t>{static_cast<const uint8_t*>(data), number_of_bytes};
 
     if (auto result = m_iox2_publisher->send_slice_copy(payload); result.has_error()) {
         RMW_IOX2_CHAIN_ERROR_MSG(::iox::into<const char*>(result.error()));