rebase ontop of master

Signed-off-by: Karsten Knese <karsten@openrobotics.org>

rclcpp/include/rclcpp/loaned_message.hpp

@@ -27,21 +27,21 @@
 namespace rclcpp
 {
 
-template<typename MessageT, typename Alloc>
+template<typename MessageT, typename AllocatorT>
 class Publisher;
 
-template<typename MessageT, typename Alloc = std::allocator<void>>
+template<typename MessageT, typename AllocatorT = std::allocator<void>>
 class LoanedMessage
 {
-  using MessageAllocTraits = allocator::AllocRebind<MessageT, Alloc>;
-  using MessageAlloc = typename MessageAllocTraits::allocator_type;
+  using MessageAllocatorTraits = allocator::AllocRebind<MessageT, AllocatorT>;
+  using MessageAllocator = typename MessageAllocatorTraits::allocator_type;
 
 protected:
-  const rclcpp::Publisher<MessageT, Alloc> * pub_;
+  const rclcpp::Publisher<MessageT, AllocatorT> * pub_;
 
   std::unique_ptr<MessageT> message_;
 
-  const std::shared_ptr<MessageAlloc> message_allocator_;
+  const std::shared_ptr<MessageAllocator> message_allocator_;
 
   /// Deleted copy constructor to preserve memory integrity
   LoanedMessage(const LoanedMessage<MessageT> & other) = delete;
@@ -68,7 +68,7 @@ class LoanedMessage
    * \param allocator Allocator instance in case middleware can not allocate messages
    */
   LoanedMessage(
-    const rclcpp::Publisher<MessageT, Alloc> * pub,
+    const rclcpp::Publisher<MessageT, AllocatorT> * pub,
     const std::shared_ptr<std::allocator<MessageT>> allocator)
   : pub_(pub),
     message_(nullptr),

rclcpp/include/rclcpp/publisher.hpp

@@ -45,7 +45,7 @@
 namespace rclcpp
 {
 
-template<typename MessageT, typename Alloc>
+template<typename MessageT, typename AllocatorT>
 class LoanedMessage;
 
 /// A publisher publishes messages of any type to a topic.
@@ -150,40 +150,23 @@ class Publisher : public PublisherBase
    *
    * \return LoanedMessage containing memory for a ROS message of type MessageT
    */
-  rclcpp::LoanedMessage<MessageT, Alloc>
+  rclcpp::LoanedMessage<MessageT, AllocatorT>
   loan_message()
   {
-    return rclcpp::LoanedMessage<MessageT, Alloc>(this, this->get_allocator());
+    return rclcpp::LoanedMessage<MessageT, AllocatorT>(this, this->get_allocator());
   }
 
   /// Return and deallocate the memory for the loaned message.
   /**
    * \param loaned_message The LoanedMessage instance to be returned.
    */
   void
-  return_loaned_message(rclcpp::LoanedMessage<MessageT, Alloc> && loaned_msg) const
+  return_loaned_message(rclcpp::LoanedMessage<MessageT, AllocatorT> && loaned_msg) const
   {
     // scope exit
     (void) loaned_msg;
   }
 
-  /// Publish an instance of a LoanedMessage
-  /**
-   * When publishing a loaned message, the memory for this ROS instance will be deallocated
-   * after being published.
-   * The instance of the loaned message is no longer valid after this call.
-   *
-   * \param loaned_msg The LoanedMessage instance to be published.
-   */
-  void
-  publish(std::unique_ptr<rclcpp::LoanedMessage<MessageT, Alloc>> loaned_msg)
-  {
-    if (!loaned_msg.is_valid()) {
-      throw std::runtime_error("loaned message is not valid");
-    }
-    return rcl_publish(&publisher_handle_, *loaned_msg->get(), nullptr, true);
-  }
-
   /// Send a message to the topic for this publisher.
   /**
    * This function is templated on the input message type, MessageT.
@@ -243,13 +226,21 @@ class Publisher : public PublisherBase
     return this->do_serialized_publish(&serialized_msg);
   }
 
+  /// Publish an instance of a LoanedMessage
+  /**
+   * When publishing a loaned message, the memory for this ROS instance will be deallocated
+   * after being published.
+   * The instance of the loaned message is no longer valid after this call.
+   *
+   * \param loaned_msg The LoanedMessage instance to be published.
+   */
   void
-  publish(std::unique_ptr<rclcpp::LoanedMessage<MessageT, Alloc>> loaned_msg)
+  publish(rclcpp::LoanedMessage<MessageT, AllocatorT> && loaned_msg)
   {
     if (!loaned_msg.is_valid()) {
       throw std::runtime_error("loaned message is not valid");
     }
-    return rcl_publish(&publisher_handle_, *loaned_msg->get(), nullptr, true);
+    return rcl_publish(&publisher_handle_, *loaned_msg.get(), nullptr, true);
   }
 
   std::shared_ptr<MessageAllocator>