[dashing] [backport] Type support fixes #342 & #350

rmw_fastrtps_cpp/include/rmw_fastrtps_cpp/TypeSupport.hpp

@@ -35,11 +35,13 @@ namespace rmw_fastrtps_cpp
 class TypeSupport : public rmw_fastrtps_shared_cpp::TypeSupport
 {
 public:
-  size_t getEstimatedSerializedSize(const void * ros_message);
+  size_t getEstimatedSerializedSize(const void * ros_message, const void * impl) const override;
 
-  bool serializeROSmessage(const void * ros_message, eprosima::fastcdr::Cdr & ser);
+  bool serializeROSmessage(
+    const void * ros_message, eprosima::fastcdr::Cdr & ser, const void * impl) const override;
 
-  bool deserializeROSmessage(eprosima::fastcdr::Cdr & deser, void * ros_message);
+  bool deserializeROSmessage(
+    eprosima::fastcdr::Cdr & deser, void * ros_message, const void * impl) const override;
 
 protected:
   TypeSupport();

rmw_fastrtps_cpp/src/rmw_client.cpp

@@ -106,6 +106,9 @@ rmw_create_client(
   response_members = static_cast<const message_type_support_callbacks_t *>(
     service_members->response_members_->data);
 
+  info->request_type_support_impl_ = request_members;
+  info->response_type_support_impl_ = response_members;
+
   std::string request_type_name = _create_type_name(request_members);
   std::string response_type_name = _create_type_name(response_members);
 

rmw_fastrtps_cpp/src/rmw_publisher.cpp

@@ -127,6 +127,7 @@ rmw_create_publisher(
   }
 
   info->typesupport_identifier_ = type_support->typesupport_identifier;
+  info->type_support_impl_ = type_support->data;
 
   auto callbacks = static_cast<const message_type_support_callbacks_t *>(type_support->data);
   std::string type_name = _create_type_name(callbacks);

rmw_fastrtps_cpp/src/rmw_serialize.cpp

@@ -41,7 +41,7 @@ rmw_serialize(
 
   auto callbacks = static_cast<const message_type_support_callbacks_t *>(ts->data);
   auto tss = new MessageTypeSupport_cpp(callbacks);
-  auto data_length = tss->getEstimatedSerializedSize(ros_message);
+  auto data_length = tss->getEstimatedSerializedSize(ros_message, callbacks);
   if (serialized_message->buffer_capacity < data_length) {
     if (rmw_serialized_message_resize(serialized_message, data_length) != RMW_RET_OK) {
       RMW_SET_ERROR_MSG("unable to dynamically resize serialized message");
@@ -54,7 +54,7 @@ rmw_serialize(
   eprosima::fastcdr::Cdr ser(
     buffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, eprosima::fastcdr::Cdr::DDS_CDR);
 
-  auto ret = tss->serializeROSmessage(ros_message, ser);
+  auto ret = tss->serializeROSmessage(ros_message, ser, callbacks);
   serialized_message->buffer_length = data_length;
   serialized_message->buffer_capacity = data_length;
   delete tss;
@@ -85,7 +85,7 @@ rmw_deserialize(
   eprosima::fastcdr::Cdr deser(buffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
     eprosima::fastcdr::Cdr::DDS_CDR);
 
-  auto ret = tss->deserializeROSmessage(deser, ros_message);
+  auto ret = tss->deserializeROSmessage(deser, ros_message, callbacks);
   delete tss;
   return ret == true ? RMW_RET_OK : RMW_RET_ERROR;
 }

rmw_fastrtps_cpp/src/rmw_service.cpp

@@ -116,6 +116,9 @@ rmw_create_service(
   response_members = static_cast<const message_type_support_callbacks_t *>(
     service_members->response_members_->data);
 
+  info->request_type_support_impl_ = request_members;
+  info->response_type_support_impl_ = response_members;
+
   std::string request_type_name = _create_type_name(request_members);
   std::string response_type_name = _create_type_name(response_members);
 

rmw_fastrtps_cpp/src/rmw_subscription.cpp

@@ -130,6 +130,7 @@ rmw_create_subscription(
   }
 
   info->typesupport_identifier_ = type_support->typesupport_identifier;
+  info->type_support_impl_ = type_support->data;
 
   auto callbacks = static_cast<const message_type_support_callbacks_t *>(type_support->data);
   std::string type_name = _create_type_name(callbacks);

rmw_fastrtps_cpp/src/type_support_common.cpp

@@ -47,45 +47,54 @@ void TypeSupport::set_members(const message_type_support_callbacks_t * members)
   m_typeSize = 4 + data_size;
 }
 
-size_t TypeSupport::getEstimatedSerializedSize(const void * ros_message)
+size_t TypeSupport::getEstimatedSerializedSize(const void * ros_message, const void * impl) const
 {
   if (max_size_bound_) {
     return m_typeSize;
   }
 
   assert(ros_message);
+  assert(impl);
+
+  auto callbacks = static_cast<const message_type_support_callbacks_t *>(impl);
 
   // Encapsulation size + message size
-  return 4 + members_->get_serialized_size(ros_message);
+  return 4 + callbacks->get_serialized_size(ros_message);
 }
 
-bool TypeSupport::serializeROSmessage(const void * ros_message, eprosima::fastcdr::Cdr & ser)
+bool TypeSupport::serializeROSmessage(
+  const void * ros_message, eprosima::fastcdr::Cdr & ser, const void * impl) const
 {
   assert(ros_message);
+  assert(impl);
 
   // Serialize encapsulation
   ser.serialize_encapsulation();
 
   // If type is not empty, serialize message
   if (has_data_) {
-    return members_->cdr_serialize(ros_message, ser);
+    auto callbacks = static_cast<const message_type_support_callbacks_t *>(impl);
+    return callbacks->cdr_serialize(ros_message, ser);
   }
 
   // Otherwise, add a dummy byte
   ser << (uint8_t)0;
   return true;
 }
 
-bool TypeSupport::deserializeROSmessage(eprosima::fastcdr::Cdr & deser, void * ros_message)
+bool TypeSupport::deserializeROSmessage(
+  eprosima::fastcdr::Cdr & deser, void * ros_message, const void * impl) const
 {
   assert(ros_message);
+  assert(impl);
 
   // Deserialize encapsulation.
   deser.read_encapsulation();
 
   // If type is not empty, deserialize message
   if (has_data_) {
-    return members_->cdr_deserialize(deser, ros_message);
+    auto callbacks = static_cast<const message_type_support_callbacks_t *>(impl);
+    return callbacks->cdr_deserialize(deser, ros_message);
   }
 
   // Otherwise, consume dummy byte

rmw_fastrtps_dynamic_cpp/CMakeLists.txt

@@ -84,6 +84,8 @@ add_library(rmw_fastrtps_dynamic_cpp
   src/rmw_wait.cpp
   src/rmw_wait_set.cpp
   src/type_support_common.cpp
+  src/type_support_proxy.cpp
+  src/type_support_registry.cpp
   src/serialization_format.cpp
 )
 target_link_libraries(rmw_fastrtps_dynamic_cpp

rmw_fastrtps_dynamic_cpp/include/rmw_fastrtps_dynamic_cpp/MessageTypeSupport.hpp

@@ -32,7 +32,7 @@ template<typename MembersType>
 class MessageTypeSupport : public TypeSupport<MembersType>
 {
 public:
-  explicit MessageTypeSupport(const MembersType * members);
+  MessageTypeSupport(const MembersType * members, const void * ros_type_support);
 };
 
 }  // namespace rmw_fastrtps_dynamic_cpp

rmw_fastrtps_dynamic_cpp/include/rmw_fastrtps_dynamic_cpp/MessageTypeSupport_impl.hpp

@@ -32,7 +32,9 @@ namespace rmw_fastrtps_dynamic_cpp
 {
 
 template<typename MembersType>
-MessageTypeSupport<MembersType>::MessageTypeSupport(const MembersType * members)
+MessageTypeSupport<MembersType>::MessageTypeSupport(
+  const MembersType * members, const void * ros_type_support)
+: TypeSupport<MembersType>(ros_type_support)
 {
   assert(members);
   this->members_ = members;

rmw_fastrtps_dynamic_cpp/include/rmw_fastrtps_dynamic_cpp/ServiceTypeSupport.hpp

@@ -25,25 +25,18 @@
 namespace rmw_fastrtps_dynamic_cpp
 {
 
-template<typename MembersType>
-class ServiceTypeSupport : public TypeSupport<MembersType>
-{
-protected:
-  ServiceTypeSupport();
-};
-
 template<typename ServiceMembersType, typename MessageMembersType>
-class RequestTypeSupport : public ServiceTypeSupport<MessageMembersType>
+class RequestTypeSupport : public TypeSupport<MessageMembersType>
 {
 public:
-  explicit RequestTypeSupport(const ServiceMembersType * members);
+  RequestTypeSupport(const ServiceMembersType * members, const void * ros_type_support);
 };
 
 template<typename ServiceMembersType, typename MessageMembersType>
-class ResponseTypeSupport : public ServiceTypeSupport<MessageMembersType>
+class ResponseTypeSupport : public TypeSupport<MessageMembersType>
 {
 public:
-  explicit ResponseTypeSupport(const ServiceMembersType * members);
+  ResponseTypeSupport(const ServiceMembersType * members, const void * ros_type_support);
 };
 
 }  // namespace rmw_fastrtps_dynamic_cpp

rmw_fastrtps_dynamic_cpp/include/rmw_fastrtps_dynamic_cpp/ServiceTypeSupport_impl.hpp

@@ -29,14 +29,10 @@
 namespace rmw_fastrtps_dynamic_cpp
 {
 
-template<typename MembersType>
-ServiceTypeSupport<MembersType>::ServiceTypeSupport()
-{
-}
-
 template<typename ServiceMembersType, typename MessageMembersType>
 RequestTypeSupport<ServiceMembersType, MessageMembersType>::RequestTypeSupport(
-  const ServiceMembersType * members)
+  const ServiceMembersType * members, const void * ros_type_support)
+: TypeSupport<MessageMembersType>(ros_type_support)
 {
   assert(members);
   this->members_ = members->request_members_;
@@ -65,7 +61,8 @@ RequestTypeSupport<ServiceMembersType, MessageMembersType>::RequestTypeSupport(
 
 template<typename ServiceMembersType, typename MessageMembersType>
 ResponseTypeSupport<ServiceMembersType, MessageMembersType>::ResponseTypeSupport(
-  const ServiceMembersType * members)
+  const ServiceMembersType * members, const void * ros_type_support)
+: TypeSupport<MessageMembersType>(ros_type_support)
 {
   assert(members);
   this->members_ = members->response_members_;

rmw_fastrtps_dynamic_cpp/include/rmw_fastrtps_dynamic_cpp/TypeSupport.hpp

@@ -130,33 +130,73 @@ struct StringHelper<rosidl_typesupport_introspection_cpp::MessageMembers>
   }
 };
 
+class TypeSupportProxy : public rmw_fastrtps_shared_cpp::TypeSupport
+{
+public:
+  explicit TypeSupportProxy(rmw_fastrtps_shared_cpp::TypeSupport * inner_type);
+
+  size_t getEstimatedSerializedSize(const void * ros_message, const void * impl) const override;
+
+  bool serializeROSmessage(
+    const void * ros_message, eprosima::fastcdr::Cdr & ser, const void * impl) const override;
+
+  bool deserializeROSmessage(
+    eprosima::fastcdr::Cdr & deser, void * ros_message, const void * impl) const override;
+};
+
+class BaseTypeSupport : public rmw_fastrtps_shared_cpp::TypeSupport
+{
+public:
+  const void * ros_type_support() const
+  {
+    return ros_type_support_;
+  }
+
+protected:
+  explicit BaseTypeSupport(const void * ros_type_support)
+  {
+    ros_type_support_ = ros_type_support;
+  }
+
+private:
+  const void * ros_type_support_;
+};
+
 template<typename MembersType>
-class TypeSupport : public rmw_fastrtps_shared_cpp::TypeSupport
+class TypeSupport : public BaseTypeSupport
 {
 public:
-  size_t getEstimatedSerializedSize(const void * ros_message);
+  size_t getEstimatedSerializedSize(const void * ros_message, const void * impl) const override;
 
-  bool serializeROSmessage(const void * ros_message, eprosima::fastcdr::Cdr & ser);
+  bool serializeROSmessage(
+    const void * ros_message, eprosima::fastcdr::Cdr & ser, const void * impl) const override;
 
-  bool deserializeROSmessage(eprosima::fastcdr::Cdr & deser, void * ros_message);
+  bool deserializeROSmessage(
+    eprosima::fastcdr::Cdr & deser, void * ros_message, const void * impl) const override;
 
 protected:
-  TypeSupport();
+  explicit TypeSupport(const void * ros_type_support);
 
   size_t calculateMaxSerializedSize(const MembersType * members, size_t current_alignment);
 
   const MembersType * members_;
 
 private:
   size_t getEstimatedSerializedSize(
-    const MembersType * members, const void * ros_message, size_t current_alignment);
+    const MembersType * members,
+    const void * ros_message,
+    size_t current_alignment) const;
 
   bool serializeROSmessage(
-    eprosima::fastcdr::Cdr & ser, const MembersType * members, const void * ros_message);
+    eprosima::fastcdr::Cdr & ser,
+    const MembersType * members,
+    const void * ros_message) const;
 
   bool deserializeROSmessage(
-    eprosima::fastcdr::Cdr & deser, const MembersType * members, void * ros_message,
-    bool call_new);
+    eprosima::fastcdr::Cdr & deser,
+    const MembersType * members,
+    void * ros_message,
+    bool call_new) const;
 };
 
 }  // namespace rmw_fastrtps_dynamic_cpp