Template Class LoanedMessage

Class Documentation

template<typename MessageT, typename AllocatorT = std::allocator<void>>
class LoanedMessage

Public Types

using MessageAllocatorTraits = rclcpp::allocator::AllocRebind<MessageT, AllocatorT>
using MessageAllocator = typename MessageAllocatorTraits::allocator_type

Public Functions

inline LoanedMessage(const rclcpp::PublisherBase &pub, MessageAllocator allocator)

Constructor of the LoanedMessage class.

The constructor of this class allocates memory for a given message type and associates this with a given publisher.

The underlying middleware is queried to determine whether it is able to allocate the appropriate memory for this message type or not. In the case that the middleware cannot loan messages, the passed in allocator instance is used to allocate the message within the scope of this class. Otherwise, the allocator is ignored and the allocation is solely performed in the underlying middleware with its appropriate allocation strategy. The need for this arises as the user code can be written explicitly targeting a middleware capable of loaning messages. However, this user code is ought to be usable even when dynamically linked against a middleware which doesn’t support message loaning in which case the allocator will be used.

Parameters:

  • pub – [in] rclcpp::Publisher instance to which the memory belongs

  • allocator – [in] Allocator instance in case middleware cannot allocate messages

Throws:

anything – rclcpp::exceptions::throw_from_rcl_error can throw.

inline LoanedMessage(LoanedMessage<MessageT> &&other)

Move semantic for RVO.

inline virtual ~LoanedMessage()

Destructor of the LoanedMessage class.

The destructor has the explicit task to return the allocated memory for its message instance. If the message was previously allocated via the middleware, the message is getting returned to the middleware to cleanly destroy the allocation. In the case that the local allocator instance was used, the same instance is then being used to destroy the allocated memory.

The contract here is that the memory for this message is valid as long as this instance of the LoanedMessage class is alive.

inline bool is_valid() const

Validate if the message was correctly allocated.

The allocated memory might not be always consistent and valid. Reasons why this could fail is that an allocation step was failing, e.g. just like malloc could fail or a maximum amount of previously allocated messages is exceeded in which case the loaned messages have to be returned to the middleware prior to be able to allocate a new one.

inline MessageT &get() const

Access the ROS message instance.

A call to get() will return a mutable reference to the underlying ROS message instance. This allows a user to modify the content of the message prior to publishing it.

If this reference is copied, the memory for this copy is no longer managed by the LoanedMessage instance and has to be cleanup individually.

inline std::unique_ptr<MessageT, std::function<void(MessageT*)>> release()

Release ownership of the ROS message instance.

A call to release() will unmanage the memory for the ROS message. That means that the destructor of this class will not free the memory on scope exit. If the message is loaned from the middleware but not be published, the user needs to call rcl_return_loaned_message_from_publisher manually. If the memory is from the local allocator, the memory is freed when the unique pointer goes out instead.

Returns:

std::unique_ptr to the message instance.

Protected Functions

LoanedMessage(const LoanedMessage<MessageT> &other) = delete

Deleted copy constructor to preserve memory integrity.

Protected Attributes

const rclcpp::PublisherBase &pub_
MessageT *message_
MessageAllocator message_allocator_