use Reader/Writer lock for Ring Buffer.

Signed-off-by: Tomoya Fujita <Tomoya.Fujita@sony.com>

.github/ISSUE_TEMPLATE.md

@@ -1,45 +0,0 @@
-<!--
-For general questions, please ask on ROS answers: https://answers.ros.org, make sure to include at least the `ros2` tag and the rosdistro version you are running, e.g. `ardent`.
-For general design discussions, please post on discourse: https://discourse.ros.org/c/ng-ros
-Not sure if this is the right repository? Open an issue on https://github.com/ros2/ros2/issues
-For Bug report or feature requests, please fill out the relevant category below
--->
-
-## Bug report
-
-**Required Info:**
-
-- Operating System:
-  - <!-- OS and version (e.g. Windows 10, Ubuntu 16.04...) -->
-- Installation type:
-  - <!-- binaries or from source  -->
-- Version or commit hash:
-  - <!-- Output of git rev-parse HEAD, release version, or repos file  -->
-- DDS implementation:
-  - <!-- rmw_implementation used (e.g. Fast-RTPS, RTI Connext, etc -->
-- Client library (if applicable):
-  - <!-- e.g. rclcpp, rclpy, or N/A -->
-
-#### Steps to reproduce issue
-<!-- Detailed instructions on how to reliably reproduce this issue http://sscce.org/
-``` code that can be copy-pasted is preferred ``` -->
-```
-
-```
-
-#### Expected behavior
-
-#### Actual behavior
-
-#### Additional information
-
-<!-- If you are reporting a bug delete everything below
-     If you are requesting a feature deleted everything above this line -->
-----
-## Feature request
-
-#### Feature description
-<!-- Description in a few sentences what the feature consists of and what problem it will solve -->
-
-#### Implementation considerations
-<!-- Relevant information on how the feature could be implemented and pros and cons of the different solutions -->

rclcpp/CHANGELOG.rst

@@ -2,6 +2,47 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+29.6.0 (2025-04-25)
+-------------------
+* throws std::invalid_argument if ParameterEvent is NULL. (`#2814 <https://github.com/ros2/rclcpp/issues/2814>`_)
+* Removed clang warnings (`#2823 <https://github.com/ros2/rclcpp/issues/2823>`_)
+* Contributors: Alejandro Hernández Cordero, Tomoya Fujita
+
+29.5.0 (2025-04-18)
+-------------------
+* Fix a race condition (`#2819 <https://github.com/ros2/rclcpp/issues/2819>`_)
+* Remove redundant typesupport check in serialization module (`#2808 <https://github.com/ros2/rclcpp/issues/2808>`_)
+* Remove get_typesupport_handle implementation. (`#2806 <https://github.com/ros2/rclcpp/issues/2806>`_)
+* Use NodeParameterInterface instead of /parameter_event to update "use_sim_time" (`#2378 <https://github.com/ros2/rclcpp/issues/2378>`_)
+* Remove cancel_clock_executor_promise\_. (`#2797 <https://github.com/ros2/rclcpp/issues/2797>`_)
+* Enable parameter update recursively only when QoS override parameters. (`#2742 <https://github.com/ros2/rclcpp/issues/2742>`_)
+* Contributors: Pedro de Azeredo, Tanishq Chaudhary, Tomoya Fujita
+
+29.4.0 (2025-04-04)
+-------------------
+* Removed trailing whitespace from the codebase. (`#2791 <https://github.com/ros2/rclcpp/issues/2791>`_)
+* Expanded docstring of `get_rmw_qos_profile()` (`#2787 <https://github.com/ros2/rclcpp/issues/2787>`_)
+* Set envars to run tests with rmw_zenoh_cpp with multicast discovery (`#2776 <https://github.com/ros2/rclcpp/issues/2776>`_)
+* fix: Compilefix for clang (`#2775 <https://github.com/ros2/rclcpp/issues/2775>`_)
+* add exception doc for configure_introspection. (`#2773 <https://github.com/ros2/rclcpp/issues/2773>`_)
+* feat: Add ClockWaiter and ClockConditionalVariable (`#2691 <https://github.com/ros2/rclcpp/issues/2691>`_)
+* doc: Added warning to not instantiate Clock directly with RCL_ROS_TIME (`#2768 <https://github.com/ros2/rclcpp/issues/2768>`_)
+* Use rmw_event_type_is_supported in test_qos_event (`#2761 <https://github.com/ros2/rclcpp/issues/2761>`_)
+* Support action typesupport helper (`#2750 <https://github.com/ros2/rclcpp/issues/2750>`_)
+* use maybe_unused attribute for the portability. (`#2758 <https://github.com/ros2/rclcpp/issues/2758>`_)
+* Executor strong reference fix (`#2745 <https://github.com/ros2/rclcpp/issues/2745>`_)
+* Cleanup of https://github.com/ros2/rclcpp/pull/2683 (`#2714 <https://github.com/ros2/rclcpp/issues/2714>`_)
+* Fix typo in doc section for get_service_typesupport_handle (`#2751 <https://github.com/ros2/rclcpp/issues/2751>`_)
+* Test case and fix for for https://github.com/ros2/rclcpp/issues/2652 (`#2713 <https://github.com/ros2/rclcpp/issues/2713>`_)
+* fix(timer): Delete node, after executor thread terminated (`#2737 <https://github.com/ros2/rclcpp/issues/2737>`_)
+* update doc section for spin_xxx methods. (`#2730 <https://github.com/ros2/rclcpp/issues/2730>`_)
+* fix: Expose timers used by rclcpp::Waitables (`#2699 <https://github.com/ros2/rclcpp/issues/2699>`_)
+* use rmw_qos_profile_rosout_default instead of rcl. (`#2663 <https://github.com/ros2/rclcpp/issues/2663>`_)
+* fix(Executor): Fixed entities not beeing executed after just beeing added (`#2724 <https://github.com/ros2/rclcpp/issues/2724>`_)
+* fix: make the loop condition align with the description (`#2726 <https://github.com/ros2/rclcpp/issues/2726>`_)
+* Collect log messages from rcl, and reset. (`#2720 <https://github.com/ros2/rclcpp/issues/2720>`_)
+* Contributors: Abhishek Kashyap, Alejandro Hernández Cordero, Barry Xu, Janosch Machowinski, Leander Stephen D'Souza, Tomoya Fujita, Yuyuan Yuan
+
 29.3.0 (2024-12-20)
 -------------------
 * Fix transient local IPC publish  (`#2708 <https://github.com/ros2/rclcpp/issues/2708>`_)

rclcpp/CMakeLists.txt

@@ -113,7 +113,6 @@ set(${PROJECT_NAME}_SRCS
   src/rclcpp/qos.cpp
   src/rclcpp/event_handler.cpp
   src/rclcpp/qos_overriding_options.cpp
-  src/rclcpp/dynamic_subscription.cpp
   src/rclcpp/rate.cpp
   src/rclcpp/serialization.cpp
   src/rclcpp/serialized_message.cpp

rclcpp/doc/api_review_march_2020.md

@@ -434,4 +434,3 @@
 
 - (tfoote) There should be no jumps in steady time. If there's a big change in system time, it doesn't necessarily mean that time jumped, just that you might have been sleeping for a long time. Most ntp systems adjust the slew rate these days instead of jumping but still that's an external process and I don't know of any APIs to introspect the state of the clock. I'm not sure that we have a way to detect jumps in time for system or steady time. To that end I think that we should be clear that we only provide callbacks when simulation time starts or stops, or simulation time jumps. We should also strongly recommend that operators not actively adjust their system clocks while running ROS nodes.
 - (jacobperron) I agree with Tully, if we don't have a way to detect system time jumps then I think we should just document that this only works with ROS time. In addition to documentation, we could log an info or warning message if the user registers jump callback with steady or system time, but it may be unnecessarily noisy.
-

rclcpp/doc/proposed_node_parameter_callbacks.md

@@ -2,15 +2,15 @@
 
 ## Introduction:
 
-The original requirement came in **gazebo_ros_pkgs** for setting individual wheel slip parameters based on global wheel slip value [link to original issue](https://github.com/ros-simulation/gazebo_ros_pkgs/pull/1365). 
+The original requirement came in **gazebo_ros_pkgs** for setting individual wheel slip parameters based on global wheel slip value [link to original issue](https://github.com/ros-simulation/gazebo_ros_pkgs/pull/1365).
 
-The main requirement is to set one or more parameters after another parameter is set successfully. 
+The main requirement is to set one or more parameters after another parameter is set successfully.
 
 Additionally, it would be nice if users could be notified locally (via a callback) when parameters have been set successfully (i.e. post validation).
 
 Related discussion can be found in [#609](https://github.com/ros2/rclcpp/issues/609) [#1789](https://github.com/ros2/rclcpp/pull/1789)
 
-With the current parameters API, the `add_on_set_parameters_callback` is intended for validation of parameter values before they are set, it should **not** cause any side-effects. 
+With the current parameters API, the `add_on_set_parameters_callback` is intended for validation of parameter values before they are set, it should **not** cause any side-effects.
 
 There is also the `ParameterEventHandler` that publishes changes to node parameters on `/parameter_events` topic for external nodes to see. Though the node could subscribe to the `/parameter_events` topic to be notified of changes to its own parameters, it is less than ideal since there is a delay caused by waiting for an executor to process the callback.
 
@@ -19,11 +19,11 @@ We propose adding a `PostSetParametersCallbackHandle` for successful parameter s
 The validation callback is often abused to trigger side effects in the code, for instance updating class attributes even before a parameter has been set successfully. Instead of relying on the `/parameter_events` topic to be notified of parameter changes, users can register a callback with a new API, `add_post_set_parameters_callback`.
 
 It is possible to use the proposed `add_post_set_parameters_callback` for setting additional parameters, but this might result in infinite recursion and does not allow those additional parameters to be set atomically with the original parameter(s) changed.
-To workaround these issues, we propose adding a "pre set" callback type that can be registered with `add_pre_set_parameters_callback`, which will be triggered before the validation callbacks and can be used to modify the parameter list. 
+To workaround these issues, we propose adding a "pre set" callback type that can be registered with `add_pre_set_parameters_callback`, which will be triggered before the validation callbacks and can be used to modify the parameter list.
 
 ![Desgin API](https://github.com/ros2/rclcpp/blob/deepanshu/local-param-changed-callback-support/rclcpp/doc/param_callback_design.png?raw=true)
 
 ## Alternatives
 
 * Users could call `set_parameter` while processing a message from the `/parameter_events` topic, however, there is extra overhead in having to create subscription (as noted earlier).
-* Users could call `set_parameter` inside the "on set" parameters callback, however it is not well-defined how side-effects should handle cases where parameter validation fails.
+* Users could call `set_parameter` inside the "on set" parameters callback, however it is not well-defined how side-effects should handle cases where parameter validation fails.

rclcpp/include/rclcpp/allocator/allocator_deleter.hpp

@@ -69,18 +69,17 @@ private:
 };
 
 template<typename Alloc, typename T, typename D>
-void set_allocator_for_deleter(D * deleter, Alloc * alloc)
+void set_allocator_for_deleter([[maybe_unused]] D * deleter, [[maybe_unused]] Alloc * alloc)
 {
-  (void) alloc;
-  (void) deleter;
   throw std::runtime_error("Reached unexpected template specialization");
 }
 
 template<typename T, typename U>
-void set_allocator_for_deleter(std::default_delete<T> * deleter, std::allocator<U> * alloc)
+void set_allocator_for_deleter(
+  [[maybe_unused]] std::default_delete<T> * deleter,
+  [[maybe_unused]] std::allocator<U> * alloc)
 {
-  (void) deleter;
-  (void) alloc;
+  // This function is intentionally left empty.
 }
 
 template<typename Alloc, typename T>

rclcpp/include/rclcpp/client.hpp

@@ -789,6 +789,9 @@ public:
    * \param[in] clock clock to use to generate introspection timestamps
    * \param[in] qos_service_event_pub QoS settings to use when creating the introspection publisher
    * \param[in] introspection_state the state to set introspection to
+   *
+   * \throws anything rclcpp::exceptions::throw_from_rcl_error can throw if
+   *   it failed to configure introspection.
    */
   void
   configure_introspection(

rclcpp/include/rclcpp/clock.hpp

@@ -60,6 +60,13 @@ public:
   /**
    * Initializes the clock instance with the given clock_type.
    *
+   * WARNING Don't instantiate a clock using RCL_ROS_TIME directly,
+   * unless you really know what you are doing. By default no TimeSource
+   * is attached to a new clock. This will lead to the unexpected behavior,
+   * that your RCL_ROS_TIME will run always on system time. If you want
+   * a RCL_ROS_TIME use Node::get_clock(), or make sure to attach a
+   * TimeSource yourself.
+   *
    * \param clock_type type of the clock.
    * \throws anything rclcpp::exceptions::throw_from_rcl_error can throw.
    */
@@ -193,16 +200,6 @@ public:
   bool
   ros_time_is_active();
 
-  /**
-   * Cancels an ongoing or future sleep operation of one thread.
-   *
-   * This function can be used by one thread, to wakeup another thread that is
-   * blocked using any of the sleep_ or wait_ methods of this class.
-   */
-  RCLCPP_PUBLIC
-  void
-  cancel_sleep_or_wait();
-
   /// Return the rcl_clock_t clock handle
   RCLCPP_PUBLIC
   rcl_clock_t *
@@ -260,6 +257,117 @@ private:
   std::shared_ptr<Impl> impl_;
 };
 
+/**
+ * A synchronization primitive, equal to std::conditional_variable,
+ * that works with the rclcpp::Clock.
+ *
+ * For more information on the API see https://en.cppreference.com/w/cpp/thread/condition_variable.
+ *
+ * Note, this class does not handle shutdowns, if you want to
+ * haven them handles as well, use ClockConditionalVariable.
+ */
+class ClockWaiter
+{
+private:
+  class ClockWaiterImpl;
+  std::unique_ptr<ClockWaiterImpl> impl_;
+
+public:
+  RCLCPP_SMART_PTR_DEFINITIONS(ClockWaiter)
+
+  RCLCPP_PUBLIC
+  explicit ClockWaiter(const rclcpp::Clock::SharedPtr & clock);
+
+  RCLCPP_PUBLIC
+  ~ClockWaiter();
+
+  /**
+   * Calling this function will block the current thread, until abs_time is reached,
+   * or pred returns true.
+   * @param lock A locked lock. The lock must be locked at call time, or this method will throw.
+   *             The lock will be atomically released and this thread will blocked.
+   * @param abs_time The time until which this thread shall be blocked.
+   * @param pred may be called in cased of spurious wakeups, but must be called every time
+   *             notify_one() was called. During the call to pred, the given lock will be locked.
+   *             This method will return, if pred returns true.
+   */
+  RCLCPP_PUBLIC
+  bool
+  wait_until(
+    std::unique_lock<std::mutex> & lock,
+    const rclcpp::Time & abs_time, const std::function<bool ()> & pred);
+
+  /**
+   * Notify the blocked thread, that it should reevaluate the wakeup condition.
+   * The given pred function in wait_until will be reevaluated and wait_until
+   * will return if it evaluates to true.
+   */
+  RCLCPP_PUBLIC
+  void
+  notify_one();
+};
+
+
+/**
+ * A synchronization primitive, similar to std::conditional_variable,
+ * that works with the rclcpp::Clock.
+ *
+ * For more information on the API see https://en.cppreference.com/w/cpp/thread/condition_variable.
+ *
+ * This primitive will wake up if the context was shut down.
+ */
+class ClockConditionalVariable
+{
+  class Impl;
+  std::unique_ptr<Impl> impl_;
+
+public:
+  RCLCPP_SMART_PTR_DEFINITIONS(ClockConditionalVariable)
+
+  RCLCPP_PUBLIC
+  ClockConditionalVariable(
+    const rclcpp::Clock::SharedPtr & clock,
+    rclcpp::Context::SharedPtr context = rclcpp::contexts::get_global_default_context());
+  RCLCPP_PUBLIC
+  ~ClockConditionalVariable();
+
+  /**
+   * Calling this function will block the current thread, until abs_time is reached,
+   * or pred returns true.
+   * @param lock A locked lock. The lock must be locked at call time, or this method will throw.
+   *             The lock will be atomically released and this thread will blocked.
+   *             The given lock must be created using the mutex returned my mutex().
+   * @param abs_time The time until which this thread shall be blocked.
+   * @param pred may be called in cased of spurious wakeups, but must be called every time
+   *             notify_one() was called. During the call to pred, the given lock will be locked.
+   *             This method will return, if pred returns true.
+   *
+   * @return true if until was reached.
+   */
+  RCLCPP_PUBLIC
+  bool
+  wait_until(
+    std::unique_lock<std::mutex> & lock, rclcpp::Time until,
+    const std::function<bool ()> & pred);
+
+  /**
+   * Notify the blocked thread, that is should reevaluate the wakeup condition.
+   * E.g. the given pred function in wait_until shall be reevaluated.
+   */
+  RCLCPP_PUBLIC
+  void
+  notify_one();
+
+  /**
+   * Returns the internal mutex. In order to be race free with the context shutdown,
+   * this mutex must be used for the wait_until call.
+   */
+  RCLCPP_PUBLIC
+  std::mutex &
+  mutex();
+};
+
+
 }  // namespace rclcpp
 
 #endif  // RCLCPP__CLOCK_HPP_

rclcpp/include/rclcpp/detail/qos_parameters.hpp

@@ -97,6 +97,9 @@ declare_parameter_or_get(
   rcl_interfaces::msg::ParameterDescriptor descriptor)
 {
   try {
+    // enable parameter modification to make it possible
+    // to declare QoS override parameters during parameter callbacks.
+    parameters_interface.enable_parameter_modification();
     return parameters_interface.declare_parameter(
       param_name, param_value, descriptor);
   } catch (const rclcpp::exceptions::ParameterAlreadyDeclaredException &) {

rclcpp/include/rclcpp/dynamic_subscription.hpp

@@ -1,175 +0,0 @@
-// Copyright 2022 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef RCLCPP__DYNAMIC_SUBSCRIPTION_HPP_
-#define RCLCPP__DYNAMIC_SUBSCRIPTION_HPP_
-
-#include <rosidl_dynamic_typesupport/identifier.h>
-
-#include <functional>
-#include <memory>
-#include <string>
-
-#include "rcpputils/shared_library.hpp"
-
-#include "rclcpp/callback_group.hpp"
-#include "rclcpp/dynamic_typesupport/dynamic_message_type_support.hpp"
-#include "rclcpp/macros.hpp"
-#include "rclcpp/node_interfaces/node_base_interface.hpp"
-#include "rclcpp/node_interfaces/node_topics_interface.hpp"
-#include "rclcpp/qos.hpp"
-#include "rclcpp/serialized_message.hpp"
-#include "rclcpp/subscription_base.hpp"
-#include "rclcpp/typesupport_helpers.hpp"
-#include "rclcpp/visibility_control.hpp"
-
-namespace rclcpp
-{
-
-/// %Subscription for messages whose type descriptions are obtained at runtime.
-/**
- * Since the type is not known at compile time, this is not a template, and the dynamic library
- * containing type support information has to be identified and loaded based on the type name.
- *
- * NOTE(methylDragon): No considerations for intra-process handling are made.
- */
-class DynamicSubscription : public rclcpp::SubscriptionBase
-{
-public:
-  // cppcheck-suppress unknownMacro
-  RCLCPP_SMART_PTR_DEFINITIONS(DynamicSubscription)
-
-  template<typename AllocatorT = std::allocator<void>>
-  DynamicSubscription(
-    rclcpp::node_interfaces::NodeBaseInterface * node_base,
-    rclcpp::dynamic_typesupport::DynamicMessageTypeSupport::SharedPtr type_support,
-    const std::string & topic_name,
-    const rclcpp::QoS & qos,
-    std::function<void(
-      rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr,
-      const rosidl_runtime_c__type_description__TypeDescription &
-    )> callback,
-    const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options)
-  : SubscriptionBase(
-      node_base,
-      type_support->get_const_rosidl_message_type_support(),
-      topic_name,
-      options.to_rcl_subscription_options(
-        qos),
-      options.event_callbacks,
-      options.use_default_callbacks,
-      DeliveredMessageKind::DYNAMIC_MESSAGE),
-    ts_(type_support),
-    callback_(callback),
-    serialization_support_(nullptr),
-    dynamic_message_(nullptr),
-    dynamic_message_type_(nullptr)
-  {
-    if (!type_support) {
-      throw std::runtime_error("DynamicMessageTypeSupport cannot be nullptr!");
-    }
-
-    if (type_support->get_const_rosidl_message_type_support().typesupport_identifier !=
-      rosidl_get_dynamic_typesupport_identifier())
-    {
-      throw std::runtime_error(
-              "DynamicSubscription must use dynamic type introspection type support!");
-    }
-
-    serialization_support_ = type_support->get_shared_dynamic_serialization_support();
-    dynamic_message_type_ = type_support->get_shared_dynamic_message_type()->clone_shared();
-    dynamic_message_ = type_support->get_shared_dynamic_message()->clone_shared();
-  }
-
-  // TODO(methylDragon):
-  /// Deferred type description constructor, only usable if the middleware implementation supports
-  /// type discovery
-
-  RCLCPP_PUBLIC
-  virtual ~DynamicSubscription() = default;
-
-  // Same as create_serialized_message() as the subscription is to serialized_messages only
-  RCLCPP_PUBLIC
-  std::shared_ptr<void> create_message() override;
-
-  RCLCPP_PUBLIC
-  std::shared_ptr<rclcpp::SerializedMessage> create_serialized_message() override;
-
-  /// Cast the message to a rclcpp::SerializedMessage and call the callback.
-  RCLCPP_PUBLIC
-  void handle_message(
-    std::shared_ptr<void> & message, const rclcpp::MessageInfo & message_info) override;
-
-  /// Handle dispatching rclcpp::SerializedMessage to user callback.
-  RCLCPP_PUBLIC
-  void
-  handle_serialized_message(
-    const std::shared_ptr<rclcpp::SerializedMessage> & serialized_message,
-    const rclcpp::MessageInfo & message_info) override;
-
-  /// This function is currently not implemented.
-  RCLCPP_PUBLIC
-  void handle_loaned_message(
-    void * loaned_message, const rclcpp::MessageInfo & message_info) override;
-
-  // Same as return_serialized_message() as the subscription is to serialized_messages only
-  RCLCPP_PUBLIC
-  void return_message(std::shared_ptr<void> & message) override;
-
-  RCLCPP_PUBLIC
-  void return_serialized_message(std::shared_ptr<rclcpp::SerializedMessage> & message) override;
-
-
-  // DYNAMIC TYPE ==================================================================================
-  // TODO(methylDragon): Reorder later
-  RCLCPP_PUBLIC
-  rclcpp::dynamic_typesupport::DynamicMessageType::SharedPtr
-  get_shared_dynamic_message_type() override;
-
-  RCLCPP_PUBLIC
-  rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr get_shared_dynamic_message() override;
-
-  RCLCPP_PUBLIC
-  rclcpp::dynamic_typesupport::DynamicSerializationSupport::SharedPtr
-  get_shared_dynamic_serialization_support() override;
-
-  RCLCPP_PUBLIC
-  rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr create_dynamic_message() override;
-
-  RCLCPP_PUBLIC
-  void return_dynamic_message(
-    rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message) override;
-
-  RCLCPP_PUBLIC
-  void handle_dynamic_message(
-    const rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message,
-    const rclcpp::MessageInfo & message_info) override;
-
-private:
-  RCLCPP_DISABLE_COPY(DynamicSubscription)
-
-  rclcpp::dynamic_typesupport::DynamicMessageTypeSupport::SharedPtr ts_;
-  std::function<void(
-      rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr,
-      const rosidl_runtime_c__type_description__TypeDescription &
-    )> callback_;
-
-  rclcpp::dynamic_typesupport::DynamicSerializationSupport::SharedPtr serialization_support_;
-  rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr dynamic_message_;
-  rclcpp::dynamic_typesupport::DynamicMessageType::SharedPtr dynamic_message_type_;
-};
-
-}  // namespace rclcpp
-
-#endif  // RCLCPP__DYNAMIC_SUBSCRIPTION_HPP_

rclcpp/include/rclcpp/dynamic_typesupport/detail/dynamic_message_impl.hpp

@@ -1,327 +0,0 @@
-// Copyright 2023 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef RCLCPP__DYNAMIC_TYPESUPPORT__DETAIL__DYNAMIC_MESSAGE_IMPL_HPP_
-#define RCLCPP__DYNAMIC_TYPESUPPORT__DETAIL__DYNAMIC_MESSAGE_IMPL_HPP_
-
-#include <rosidl_dynamic_typesupport/types.h>
-#include <rosidl_dynamic_typesupport/api/dynamic_data.h>
-
-#include <cstdint>
-#include <cstddef>
-#include <memory>
-#include <string>
-
-#include "rclcpp/exceptions.hpp"
-
-#ifndef RCLCPP__DYNAMIC_TYPESUPPORT__DYNAMIC_MESSAGE_HPP_
-#include "rclcpp/dynamic_typesupport/dynamic_message.hpp"
-#endif
-
-
-#define __DYNAMIC_MESSAGE_GET_VALUE_BY_ID_FN(ValueT, FunctionT) \
-  template<> \
-  ValueT \
-  DynamicMessage::get_value<ValueT>(rosidl_dynamic_typesupport_member_id_t id) \
-  { \
-    ValueT out; \
-    rosidl_dynamic_typesupport_dynamic_data_get_ ## FunctionT ## _value( \
-      &rosidl_dynamic_data_, id, &out); \
-    return out; \
-  }
-
-#define __DYNAMIC_MESSAGE_GET_VALUE_BY_NAME_FN(ValueT, FunctionT) \
-  template<> \
-  ValueT \
-  DynamicMessage::get_value<ValueT>(const std::string & name) \
-  { \
-    return get_value<ValueT>(get_member_id(name)); \
-  }
-
-#define __DYNAMIC_MESSAGE_SET_VALUE_BY_ID_FN(ValueT, FunctionT) \
-  template<> \
-  void \
-  DynamicMessage::set_value<ValueT>(rosidl_dynamic_typesupport_member_id_t id, ValueT value) \
-  { \
-    rosidl_dynamic_typesupport_dynamic_data_set_ ## FunctionT ## _value( \
-      &rosidl_dynamic_data_, id, value); \
-  }
-
-#define __DYNAMIC_MESSAGE_SET_VALUE_BY_NAME_FN(ValueT, FunctionT) \
-  template<> \
-  void \
-  DynamicMessage::set_value<ValueT>(const std::string & name, ValueT value) \
-  { \
-    set_value<ValueT>(get_member_id(name), value); \
-  }
-
-#define __DYNAMIC_MESSAGE_INSERT_VALUE(ValueT, FunctionT) \
-  template<> \
-  rosidl_dynamic_typesupport_member_id_t \
-  DynamicMessage::insert_value<ValueT>(ValueT value) \
-  { \
-    rosidl_dynamic_typesupport_member_id_t out; \
-    rosidl_dynamic_typesupport_dynamic_data_insert_ ## FunctionT ## _value( \
-      &rosidl_dynamic_data_, value, &out); \
-    return out; \
-  }
-
-#define DYNAMIC_MESSAGE_DEFINITIONS(ValueT, FunctionT) \
-  __DYNAMIC_MESSAGE_GET_VALUE_BY_ID_FN(ValueT, FunctionT) \
-  __DYNAMIC_MESSAGE_GET_VALUE_BY_NAME_FN(ValueT, FunctionT) \
-  __DYNAMIC_MESSAGE_SET_VALUE_BY_ID_FN(ValueT, FunctionT) \
-  __DYNAMIC_MESSAGE_SET_VALUE_BY_NAME_FN(ValueT, FunctionT) \
-  __DYNAMIC_MESSAGE_INSERT_VALUE(ValueT, FunctionT)
-
-
-namespace rclcpp
-{
-namespace dynamic_typesupport
-{
-
-/**
- * Since we're in a ROS layer, these should support all ROS interface C++ types as found in:
- * https://docs.ros.org/en/rolling/Concepts/About-ROS-Interfaces.html
- *
- * Explicitly:
- * - Basic types:        bool, byte, char
- * - Float types:        float, double
- * - Int types:          int8_t, int16_t, int32_t, int64_t
- * - Unsigned int types: uint8_t, uint16_t, uint32_t, uint64_t
- * - String types:       std::string, std::u16string
- */
-
-DYNAMIC_MESSAGE_DEFINITIONS(bool, bool);
-// DYNAMIC_MESSAGE_DEFINITIONS(std::byte, byte);
-DYNAMIC_MESSAGE_DEFINITIONS(char, char);
-DYNAMIC_MESSAGE_DEFINITIONS(float, float32);
-DYNAMIC_MESSAGE_DEFINITIONS(double, float64);
-DYNAMIC_MESSAGE_DEFINITIONS(int8_t, int8);
-DYNAMIC_MESSAGE_DEFINITIONS(int16_t, int16);
-DYNAMIC_MESSAGE_DEFINITIONS(int32_t, int32);
-DYNAMIC_MESSAGE_DEFINITIONS(int64_t, int64);
-DYNAMIC_MESSAGE_DEFINITIONS(uint8_t, uint8);
-DYNAMIC_MESSAGE_DEFINITIONS(uint16_t, uint16);
-DYNAMIC_MESSAGE_DEFINITIONS(uint32_t, uint32);
-DYNAMIC_MESSAGE_DEFINITIONS(uint64_t, uint64);
-// DYNAMIC_MESSAGE_DEFINITIONS(std::string, std::string);
-// DYNAMIC_MESSAGE_DEFINITIONS(std::u16string, std::u16string);
-
-// Byte and String getters have a different implementation and are defined below
-
-
-// BYTE ============================================================================================
-template<>
-std::byte
-DynamicMessage::get_value<std::byte>(rosidl_dynamic_typesupport_member_id_t id)
-{
-  unsigned char out;
-  rosidl_dynamic_typesupport_dynamic_data_get_byte_value(&get_rosidl_dynamic_data(), id, &out);
-  return static_cast<std::byte>(out);
-}
-
-
-template<>
-std::byte
-DynamicMessage::get_value<std::byte>(const std::string & name)
-{
-  return get_value<std::byte>(get_member_id(name));
-}
-
-
-template<>
-void
-DynamicMessage::set_value<std::byte>(
-  rosidl_dynamic_typesupport_member_id_t id, const std::byte value)
-{
-  rosidl_dynamic_typesupport_dynamic_data_set_byte_value(
-    &rosidl_dynamic_data_, id, static_cast<unsigned char>(value));
-}
-
-
-template<>
-void
-DynamicMessage::set_value<std::byte>(const std::string & name, const std::byte value)
-{
-  set_value<std::byte>(get_member_id(name), value);
-}
-
-
-template<>
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::insert_value<std::byte>(const std::byte value)
-{
-  rosidl_dynamic_typesupport_member_id_t out;
-  rosidl_dynamic_typesupport_dynamic_data_insert_byte_value(
-    &rosidl_dynamic_data_, static_cast<unsigned char>(value), &out);
-  return out;
-}
-
-
-// STRINGS =========================================================================================
-template<>
-std::string
-DynamicMessage::get_value<std::string>(rosidl_dynamic_typesupport_member_id_t id)
-{
-  size_t buf_length;
-  char * buf = nullptr;
-  rosidl_dynamic_typesupport_dynamic_data_get_string_value(
-    &get_rosidl_dynamic_data(), id, &buf, &buf_length);
-  auto out = std::string(buf, buf_length);
-  delete buf;
-  return out;
-}
-
-
-template<>
-std::u16string
-DynamicMessage::get_value<std::u16string>(rosidl_dynamic_typesupport_member_id_t id)
-{
-  size_t buf_length;
-  char16_t * buf = nullptr;
-  rosidl_dynamic_typesupport_dynamic_data_get_wstring_value(
-    &get_rosidl_dynamic_data(), id, &buf, &buf_length);
-  auto out = std::u16string(buf, buf_length);
-  delete buf;
-  return out;
-}
-
-
-template<>
-std::string
-DynamicMessage::get_value<std::string>(const std::string & name)
-{
-  return get_value<std::string>(get_member_id(name));
-}
-
-
-template<>
-std::u16string
-DynamicMessage::get_value<std::u16string>(const std::string & name)
-{
-  return get_value<std::u16string>(get_member_id(name));
-}
-
-
-template<>
-void
-DynamicMessage::set_value<std::string>(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string value)
-{
-  rosidl_dynamic_typesupport_dynamic_data_set_string_value(
-    &rosidl_dynamic_data_, id, value.c_str(), value.size());
-}
-
-
-template<>
-void
-DynamicMessage::set_value<std::u16string>(
-  rosidl_dynamic_typesupport_member_id_t id, const std::u16string value)
-{
-  rosidl_dynamic_typesupport_dynamic_data_set_wstring_value(
-    &rosidl_dynamic_data_, id, value.c_str(), value.size());
-}
-
-
-template<>
-void
-DynamicMessage::set_value<std::string>(const std::string & name, const std::string value)
-{
-  set_value<std::string>(get_member_id(name), value);
-}
-
-
-template<>
-void
-DynamicMessage::set_value<std::u16string>(const std::string & name, const std::u16string value)
-{
-  set_value<std::u16string>(get_member_id(name), value);
-}
-
-
-template<>
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::insert_value<std::string>(const std::string value)
-{
-  rosidl_dynamic_typesupport_member_id_t out;
-  rosidl_dynamic_typesupport_dynamic_data_insert_string_value(
-    &rosidl_dynamic_data_, value.c_str(), value.size(), &out);
-  return out;
-}
-
-
-template<>
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::insert_value<std::u16string>(const std::u16string value)
-{
-  rosidl_dynamic_typesupport_member_id_t out;
-  rosidl_dynamic_typesupport_dynamic_data_insert_wstring_value(
-    &rosidl_dynamic_data_, value.c_str(), value.size(), &out);
-  return out;
-}
-
-
-// THROW FOR UNSUPPORTED TYPES =====================================================================
-template<typename ValueT>
-ValueT
-DynamicMessage::get_value(rosidl_dynamic_typesupport_member_id_t id)
-{
-  throw rclcpp::exceptions::UnimplementedError("get_value is not implemented for input type");
-}
-
-
-template<typename ValueT>
-ValueT
-DynamicMessage::get_value(const std::string & name)
-{
-  throw rclcpp::exceptions::UnimplementedError("get_value is not implemented for input type");
-}
-
-
-template<typename ValueT>
-void
-DynamicMessage::set_value(
-  rosidl_dynamic_typesupport_member_id_t id, ValueT value)
-{
-  throw rclcpp::exceptions::UnimplementedError("set_value is not implemented for input type");
-}
-
-
-template<typename ValueT>
-void
-DynamicMessage::set_value(const std::string & name, ValueT value)
-{
-  throw rclcpp::exceptions::UnimplementedError("set_value is not implemented for input type");
-}
-
-
-template<typename ValueT>
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::insert_value(ValueT value)
-{
-  throw rclcpp::exceptions::UnimplementedError("insert_value is not implemented for input type");
-}
-
-
-}  // namespace dynamic_typesupport
-}  // namespace rclcpp
-
-#undef __DYNAMIC_MESSAGE_GET_VALUE_BY_ID_FN
-#undef __DYNAMIC_MESSAGE_GET_VALUE_BY_NAME_FN
-#undef __DYNAMIC_MESSAGE_SET_VALUE_BY_ID_FN
-#undef __DYNAMIC_MESSAGE_SET_VALUE_BY_NAME_FN
-#undef __DYNAMIC_MESSAGE_INSERT_VALUE
-#undef DYNAMIC_MESSAGE_DEFINITIONS
-
-#endif  // RCLCPP__DYNAMIC_TYPESUPPORT__DETAIL__DYNAMIC_MESSAGE_IMPL_HPP_

rclcpp/include/rclcpp/dynamic_typesupport/detail/dynamic_message_type_builder_impl.hpp

@@ -1,189 +0,0 @@
-// Copyright 2023 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef RCLCPP__DYNAMIC_TYPESUPPORT__DETAIL__DYNAMIC_MESSAGE_TYPE_BUILDER_IMPL_HPP_
-#define RCLCPP__DYNAMIC_TYPESUPPORT__DETAIL__DYNAMIC_MESSAGE_TYPE_BUILDER_IMPL_HPP_
-
-#include <rosidl_dynamic_typesupport/types.h>
-#include <rosidl_dynamic_typesupport/api/dynamic_type.h>
-
-#include <cstdint>
-#include <cstddef>
-#include <memory>
-#include <string>
-
-#include "rclcpp/exceptions.hpp"
-
-#ifndef RCLCPP__DYNAMIC_TYPESUPPORT__DYNAMIC_MESSAGE_TYPE_BUILDER_HPP_
-#include "rclcpp/dynamic_typesupport/dynamic_message_type_builder.hpp"
-#endif
-
-
-#define __DYNAMIC_MESSAGE_TYPE_BUILDER_ADD_MEMBER_FN(MemberT, FunctionT) \
-  template<> \
-  void \
-  DynamicMessageTypeBuilder::add_member<MemberT>( \
-    rosidl_dynamic_typesupport_member_id_t id, \
-    const std::string & name, \
-    const std::string & default_value) \
-  { \
-    rosidl_dynamic_typesupport_dynamic_type_builder_add_ ## FunctionT ## _member( \
-      &rosidl_dynamic_type_builder_, \
-      id, name.c_str(), name.size(), default_value.c_str(), default_value.size()); \
-  }
-
-#define __DYNAMIC_MESSAGE_TYPE_BUILDER_ADD_ARRAY_MEMBER_FN(MemberT, FunctionT) \
-  template<> \
-  void \
-  DynamicMessageTypeBuilder::add_array_member<MemberT>( \
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name, \
-    size_t array_length, \
-    const std::string & default_value) \
-  { \
-    rosidl_dynamic_typesupport_dynamic_type_builder_add_ ## FunctionT ## _array_member( \
-      &rosidl_dynamic_type_builder_, \
-      id, name.c_str(), name.size(), default_value.c_str(), default_value.size(), \
-      array_length); \
-  }
-
-#define __DYNAMIC_MESSAGE_TYPE_BUILDER_ADD_UNBOUNDED_SEQUENCE_MEMBER_FN(MemberT, FunctionT) \
-  template<> \
-  void \
-  DynamicMessageTypeBuilder::add_unbounded_sequence_member<MemberT>( \
-    rosidl_dynamic_typesupport_member_id_t id, \
-    const std::string & name, \
-    const std::string & default_value) \
-  { \
-    rosidl_dynamic_typesupport_dynamic_type_builder_add_ ## FunctionT ## \
-    _unbounded_sequence_member( \
-      &rosidl_dynamic_type_builder_, \
-      id, name.c_str(), name.size(), default_value.c_str(), default_value.size()); \
-  }
-
-#define __DYNAMIC_MESSAGE_TYPE_BUILDER_ADD_BOUNDED_SEQUENCE_MEMBER_FN(MemberT, FunctionT) \
-  template<> \
-  void \
-  DynamicMessageTypeBuilder::add_bounded_sequence_member<MemberT>( \
-    rosidl_dynamic_typesupport_member_id_t id, \
-    const std::string & name, \
-    size_t sequence_bound, \
-    const std::string & default_value) \
-  { \
-    rosidl_dynamic_typesupport_dynamic_type_builder_add_ ## FunctionT ## _bounded_sequence_member( \
-      &rosidl_dynamic_type_builder_, \
-      id, name.c_str(), name.size(), default_value.c_str(), default_value.size(), \
-      sequence_bound); \
-  }
-
-#define DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(MemberT, FunctionT) \
-  __DYNAMIC_MESSAGE_TYPE_BUILDER_ADD_MEMBER_FN(MemberT, FunctionT) \
-  __DYNAMIC_MESSAGE_TYPE_BUILDER_ADD_ARRAY_MEMBER_FN(MemberT, FunctionT) \
-  __DYNAMIC_MESSAGE_TYPE_BUILDER_ADD_UNBOUNDED_SEQUENCE_MEMBER_FN(MemberT, FunctionT) \
-  __DYNAMIC_MESSAGE_TYPE_BUILDER_ADD_BOUNDED_SEQUENCE_MEMBER_FN(MemberT, FunctionT) \
-
-
-namespace rclcpp
-{
-namespace dynamic_typesupport
-{
-
-/**
- * Since we're in a ROS layer, these should support all ROS interface C++ types as found in:
- * https://docs.ros.org/en/rolling/Concepts/About-ROS-Interfaces.html
- *
- * Explicitly:
- * - Basic types:        bool, byte, char
- * - Float types:        float, double
- * - Int types:          int8_t, int16_t, int32_t, int64_t
- * - Unsigned int types: uint8_t, uint16_t, uint32_t, uint64_t
- * - String types:       std::string, std::u16string
- */
-
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(bool, bool);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(std::byte, byte);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(char, char);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(float, float32);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(double, float64);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(int8_t, int8);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(int16_t, int16);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(int32_t, int32);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(int64_t, int64);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(uint8_t, uint8);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(uint16_t, uint16);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(uint32_t, uint32);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(uint64_t, uint64);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(std::string, string);
-DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS(std::u16string, wstring);
-
-
-// THROW FOR UNSUPPORTED TYPES =====================================================================
-template<typename MemberT>
-void
-DynamicMessageTypeBuilder::add_member(
-  rosidl_dynamic_typesupport_member_id_t id,
-  const std::string & name,
-  const std::string & default_value)
-{
-  throw rclcpp::exceptions::UnimplementedError(
-          "add_member is not implemented for input type");
-}
-
-
-template<typename MemberT>
-void
-DynamicMessageTypeBuilder::add_array_member(
-  rosidl_dynamic_typesupport_member_id_t id,
-  const std::string & name,
-  size_t array_length, const std::string & default_value)
-{
-  throw rclcpp::exceptions::UnimplementedError(
-          "add_array_member is not implemented for input type");
-}
-
-
-template<typename MemberT>
-void
-DynamicMessageTypeBuilder::add_unbounded_sequence_member(
-  rosidl_dynamic_typesupport_member_id_t id,
-  const std::string & name,
-  const std::string & default_value)
-{
-  throw rclcpp::exceptions::UnimplementedError(
-          "add_unbounded_sequence_member is not implemented for input type");
-}
-
-
-template<typename MemberT>
-void
-DynamicMessageTypeBuilder::add_bounded_sequence_member(
-  rosidl_dynamic_typesupport_member_id_t id,
-  const std::string & name,
-  size_t sequence_bound,
-  const std::string & default_value)
-{
-  throw rclcpp::exceptions::UnimplementedError(
-          "add_bounded_sequence_member is not implemented for input type");
-}
-
-
-}  // namespace dynamic_typesupport
-}  // namespace rclcpp
-
-#undef __DYNAMIC_MESSAGE_TYPE_BUILDER_ADD_MEMBER_FN
-#undef __DYNAMIC_MESSAGE_TYPE_BUILDER_ADD_ARRAY_MEMBER_FN
-#undef __DYNAMIC_MESSAGE_TYPE_BUILDER_ADD_UNBOUNDED_SEQUENCE_MEMBER_FN
-#undef __DYNAMIC_MESSAGE_TYPE_BUILDER_ADD_BOUNDED_SEQUENCE_MEMBER_FN
-#undef DYNAMIC_MESSAGE_TYPE_BUILDER_DEFINITIONS
-
-#endif  // RCLCPP__DYNAMIC_TYPESUPPORT__DETAIL__DYNAMIC_MESSAGE_TYPE_BUILDER_IMPL_HPP_

rclcpp/include/rclcpp/dynamic_typesupport/dynamic_message.hpp

@@ -32,372 +32,16 @@ namespace rclcpp
 namespace dynamic_typesupport
 {
 
-class DynamicMessageType;
-class DynamicMessageTypeBuilder;
-
 /// Utility wrapper class for rosidl_dynamic_typesupport_dynamic_data_t
-/**
- * This class:
- * - Exposes getter methods for the struct
- * - Exposes the underlying serialization support API
- *
- * Ownership:
- * - This class borrows the rosidl_dynamic_typesupport_serialization_support_t stored in the passed
- *   DynamicSerializationSupport. So it cannot outlive the DynamicSerializationSupport.
- * - The DynamicSerializationSupport's rosidl_dynamic_typesupport_serialization_support_t pointer
- *   must point to the same location in memory as the stored raw pointer!
- *
- * Note: This class is meant to map to the lower level rosidl_dynamic_typesupport_dynamic_data_t,
- *       even though rosidl_dynamic_typesupport_dynamic_data_t is equivalent to
- *       rosidl_dynamic_typesupport_dynamic_data_t, exposing the fundamental methods available to
- *       rosidl_dynamic_typesupport_dynamic_data_t, allowing the user to access the data's fields.
- */
+/// STUBBED OUT
 class DynamicMessage : public std::enable_shared_from_this<DynamicMessage>
 {
 public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(DynamicMessage)
 
-  // CONSTRUCTION ==================================================================================
-  // Most constructors require a passed in DynamicSerializationSupport::SharedPtr, to extend the
-  // lifetime of the serialization support (if the constructor cannot otherwise get it from args).
-  //
-  // In cases where a dynamic data pointer is passed, the serialization support composed by
-  // the data should be the exact same object managed by the DynamicSerializationSupport,
-  // otherwise the lifetime management will not work properly.
-
-  /// Construct a new DynamicMessage with the provided dynamic type builder, using its allocator
-  RCLCPP_PUBLIC
-  explicit DynamicMessage(std::shared_ptr<DynamicMessageTypeBuilder> dynamic_type_builder);
-
-  /// Construct a new DynamicMessage with the provided dynamic type builder and allocator
-  RCLCPP_PUBLIC
-  DynamicMessage(
-    std::shared_ptr<DynamicMessageTypeBuilder> dynamic_type_builder,
-    rcl_allocator_t allocator);
-
-  /// Construct a new DynamicMessage with the provided dynamic type, using its allocator
-  RCLCPP_PUBLIC
-  explicit DynamicMessage(std::shared_ptr<DynamicMessageType> dynamic_type);
-
-  /// Construct a new DynamicMessage with the provided dynamic type and allocator
-  RCLCPP_PUBLIC
-  DynamicMessage(
-    std::shared_ptr<DynamicMessageType> dynamic_type,
-    rcl_allocator_t allocator);
-
-  /// Assume ownership of struct
-  RCLCPP_PUBLIC
-  DynamicMessage(
-    DynamicSerializationSupport::SharedPtr serialization_support,
-    rosidl_dynamic_typesupport_dynamic_data_t && rosidl_dynamic_data);
-
-  /// Loaning constructor
-  /// Must only be called with a rosidl dynaimc data object obtained from loaning!
-  // NOTE(methylDragon): I'd put this in protected, but I need this exposed to
-  //                     enable_shared_from_this...
-  RCLCPP_PUBLIC
-  DynamicMessage(
-    DynamicMessage::SharedPtr parent_data,
-    rosidl_dynamic_typesupport_dynamic_data_t && rosidl_loaned_data);
-
-  // NOTE(methylDragon): Deliberately no constructor from description to nudge users towards using
-  //                     construction from dynamic type/builder, which is more efficient
-
-  /// Move constructor
-  RCLCPP_PUBLIC
-  DynamicMessage(DynamicMessage && other) noexcept;
-
-  /// Move assignment
-  RCLCPP_PUBLIC
-  DynamicMessage & operator=(DynamicMessage && other) noexcept;
-
   RCLCPP_PUBLIC
   virtual ~DynamicMessage();
 
-
-  // GETTERS =======================================================================================
-  RCLCPP_PUBLIC
-  const std::string
-  get_serialization_library_identifier() const;
-
-  RCLCPP_PUBLIC
-  const std::string
-  get_name() const;
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_dynamic_data_t &
-  get_rosidl_dynamic_data();
-
-  RCLCPP_PUBLIC
-  const rosidl_dynamic_typesupport_dynamic_data_t &
-  get_rosidl_dynamic_data() const;
-
-  RCLCPP_PUBLIC
-  DynamicSerializationSupport::SharedPtr
-  get_shared_dynamic_serialization_support();
-
-  RCLCPP_PUBLIC
-  DynamicSerializationSupport::ConstSharedPtr
-  get_shared_dynamic_serialization_support() const;
-
-  RCLCPP_PUBLIC
-  size_t
-  get_item_count() const;
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_member_id_t
-  get_member_id(size_t index) const;
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_member_id_t
-  get_member_id(const std::string & name) const;
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_member_id_t
-  get_array_index(size_t index) const;
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_member_id_t
-  get_array_index(const std::string & name) const;
-
-
-  // METHODS =======================================================================================
-  RCLCPP_PUBLIC
-  DynamicMessage
-  clone(rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  DynamicMessage::SharedPtr
-  clone_shared(rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  DynamicMessage
-  init_from_type(
-    DynamicMessageType & type, rcl_allocator_t allocator = rcl_get_default_allocator()) const;
-
-  RCLCPP_PUBLIC
-  DynamicMessage::SharedPtr
-  init_from_type_shared(
-    DynamicMessageType & type, rcl_allocator_t allocator = rcl_get_default_allocator()) const;
-
-  RCLCPP_PUBLIC
-  bool
-  equals(const DynamicMessage & other) const;
-
-  RCLCPP_PUBLIC
-  DynamicMessage::SharedPtr
-  loan_value(
-    rosidl_dynamic_typesupport_member_id_t id,
-    rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  DynamicMessage::SharedPtr
-  loan_value(
-    const std::string & name,
-    rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  void
-  clear_all_values();
-
-  RCLCPP_PUBLIC
-  void
-  clear_nonkey_values();
-
-  RCLCPP_PUBLIC
-  void
-  clear_value(rosidl_dynamic_typesupport_member_id_t id);
-
-  RCLCPP_PUBLIC
-  void
-  clear_value(const std::string & name);
-
-  RCLCPP_PUBLIC
-  void
-  clear_sequence();
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_member_id_t
-  insert_sequence_data();
-
-  RCLCPP_PUBLIC
-  void
-  remove_sequence_data(rosidl_dynamic_typesupport_member_id_t index);
-
-  RCLCPP_PUBLIC
-  bool
-  serialize(rcl_serialized_message_t & buffer);
-
-  RCLCPP_PUBLIC
-  bool
-  deserialize(rcl_serialized_message_t & buffer);
-
-
-  // MEMBER ACCESS TEMPLATES =======================================================================
-  /**
-   * Since we're in a ROS layer, these should support all ROS interface C++ types as found in:
-   * https://docs.ros.org/en/rolling/Concepts/About-ROS-Interfaces.html
-   *
-   * Explicitly:
-   * - Basic types:        bool, byte, char
-   * - Float types:        float, double
-   * - Int types:          int8_t, int16_t, int32_t, int64_t
-   * - Unsigned int types: uint8_t, uint16_t, uint32_t, uint64_t
-   * - String types:       std::string, std::u16string
-   */
-
-  template<typename ValueT>
-  ValueT
-  get_value(rosidl_dynamic_typesupport_member_id_t id);
-
-  template<typename ValueT>
-  ValueT
-  get_value(const std::string & name);
-
-  template<typename ValueT>
-  void
-  set_value(rosidl_dynamic_typesupport_member_id_t id, ValueT value);
-
-  template<typename ValueT>
-  void
-  set_value(const std::string & name, ValueT value);
-
-  template<typename ValueT>
-  rosidl_dynamic_typesupport_member_id_t
-  insert_value(ValueT value);
-
-
-  // FIXED STRING MEMBER ACCESS ====================================================================
-  RCLCPP_PUBLIC
-  const std::string
-  get_fixed_string_value(rosidl_dynamic_typesupport_member_id_t id, size_t string_length);
-
-  RCLCPP_PUBLIC
-  const std::string
-  get_fixed_string_value(const std::string & name, size_t string_length);
-
-  RCLCPP_PUBLIC
-  const std::u16string
-  get_fixed_wstring_value(rosidl_dynamic_typesupport_member_id_t id, size_t wstring_length);
-
-  RCLCPP_PUBLIC
-  const std::u16string
-  get_fixed_wstring_value(const std::string & name, size_t wstring_length);
-
-  RCLCPP_PUBLIC
-  void
-  set_fixed_string_value(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string value, size_t string_length);
-
-  RCLCPP_PUBLIC
-  void
-  set_fixed_string_value(const std::string & name, const std::string value, size_t string_length);
-
-  RCLCPP_PUBLIC
-  void
-  set_fixed_wstring_value(
-    rosidl_dynamic_typesupport_member_id_t id, const std::u16string value, size_t wstring_length);
-
-  RCLCPP_PUBLIC
-  void
-  set_fixed_wstring_value(
-    const std::string & name, const std::u16string value, size_t wstring_length);
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_member_id_t
-  insert_fixed_string_value(const std::string value, size_t string_length);
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_member_id_t
-  insert_fixed_wstring_value(const std::u16string value, size_t wstring_length);
-
-
-  // BOUNDED STRING MEMBER ACCESS ==================================================================
-  RCLCPP_PUBLIC
-  const std::string
-  get_bounded_string_value(rosidl_dynamic_typesupport_member_id_t id, size_t string_bound);
-
-  RCLCPP_PUBLIC
-  const std::string
-  get_bounded_string_value(const std::string & name, size_t string_bound);
-
-  RCLCPP_PUBLIC
-  const std::u16string
-  get_bounded_wstring_value(rosidl_dynamic_typesupport_member_id_t id, size_t wstring_bound);
-
-  RCLCPP_PUBLIC
-  const std::u16string
-  get_bounded_wstring_value(const std::string & name, size_t wstring_bound);
-
-  RCLCPP_PUBLIC
-  void
-  set_bounded_string_value(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string value, size_t string_bound);
-
-  RCLCPP_PUBLIC
-  void
-  set_bounded_string_value(const std::string & name, const std::string value, size_t string_bound);
-
-  RCLCPP_PUBLIC
-  void
-  set_bounded_wstring_value(
-    rosidl_dynamic_typesupport_member_id_t id, const std::u16string value, size_t wstring_bound);
-
-  RCLCPP_PUBLIC
-  void
-  set_bounded_wstring_value(
-    const std::string & name, const std::u16string value, size_t wstring_bound);
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_member_id_t
-  insert_bounded_string_value(const std::string value, size_t string_bound);
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_member_id_t
-  insert_bounded_wstring_value(const std::u16string value, size_t wstring_bound);
-
-
-  // NESTED MEMBER ACCESS ==========================================================================
-  RCLCPP_PUBLIC
-  DynamicMessage
-  get_nested_data(
-    rosidl_dynamic_typesupport_member_id_t id,
-    rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  DynamicMessage
-  get_nested_data(
-    const std::string & name,
-    rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  DynamicMessage::SharedPtr
-  get_nested_data_shared(
-    rosidl_dynamic_typesupport_member_id_t id,
-    rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  DynamicMessage::SharedPtr
-  get_nested_data_shared(
-    const std::string & name,
-    rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  void
-  set_nested_data(rosidl_dynamic_typesupport_member_id_t id, DynamicMessage & value);
-
-  RCLCPP_PUBLIC
-  void
-  set_nested_data(const std::string & name, DynamicMessage & value);
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_member_id_t
-  insert_nested_data_copy(const DynamicMessage & value);
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_member_id_t
-  insert_nested_data(DynamicMessage & value);
-
 protected:
   // NOTE(methylDragon):
   // This is just here to extend the lifetime of the serialization support
@@ -418,12 +62,6 @@ private:
 
   RCLCPP_PUBLIC
   DynamicMessage();
-
-  RCLCPP_PUBLIC
-  bool
-  match_serialization_support_(
-    const DynamicSerializationSupport & serialization_support,
-    const rosidl_dynamic_typesupport_dynamic_data_t & dynamic_data);
 };
 
 }  // namespace dynamic_typesupport

rclcpp/include/rclcpp/dynamic_typesupport/dynamic_message_type.hpp

@@ -30,143 +30,16 @@ namespace rclcpp
 namespace dynamic_typesupport
 {
 
-class DynamicMessage;
-class DynamicMessageTypeBuilder;
-
 /// Utility wrapper class for `rosidl_dynamic_typesupport_dynamic_type_t`
-/**
- * This class:
- * - Exposes getter methods for the struct
- * - Exposes the underlying serialization support API
- *
- * Ownership:
- * - This class borrows the `rosidl_dynamic_typesupport_serialization_support_t` stored in the
- *   passed `DynamicSerializationSupport`.
- *   So it cannot outlive the `DynamicSerializationSupport`.
- * - The `DynamicSerializationSupport`'s `rosidl_dynamic_typesupport_serialization_support_t`
- *   pointer must point to the same location in memory as the stored raw pointer!
- *
- * This class is meant to map to the lower level `rosidl_dynamic_typesupport_dynamic_type_t`,
- * which can be constructed via `DynamicMessageTypeBuilder`, which maps to
- * `rosidl_dynamic_typesupport_dynamic_type_builder_t`.
- *
- *  The usual method of obtaining a `DynamicMessageType` is through construction of
- *  `rosidl_message_type_support_t` via `rcl_dynamic_message_type_support_handle_create()`, then
- *  taking ownership of its contents. But `DynamicMessageTypeBuilder` can also be used to obtain
- *  `DynamicMessageType` by constructing it bottom-up instead, since it exposes the lower_level
- *  rosidl methods.
- */
+/// STUBBED OUT
 class DynamicMessageType : public std::enable_shared_from_this<DynamicMessageType>
 {
 public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(DynamicMessageType)
 
-  // CONSTRUCTION ==================================================================================
-  // Most constructors require a passed in `DynamicSerializationSupport::SharedPtr`, to extend the
-  // lifetime of the serialization support (if the constructor cannot otherwise get it from args).
-  //
-  // In cases where a dynamic type pointer is passed, the serialization support composed by
-  // the type should be the exact same object managed by the `DynamicSerializationSupport`,
-  // otherwise the lifetime management will not work properly.
-
-  /// Construct a new `DynamicMessageType` with the provided dynamic type builder,
-  /// using its allocator
-  RCLCPP_PUBLIC
-  explicit DynamicMessageType(std::shared_ptr<DynamicMessageTypeBuilder> dynamic_type_builder);
-
-  /// Construct a new `DynamicMessageType` with the provided dynamic type builder and allocator
-  RCLCPP_PUBLIC
-  DynamicMessageType(
-    std::shared_ptr<DynamicMessageTypeBuilder> dynamic_type_builder,
-    rcl_allocator_t allocator);
-
-  /// Assume ownership of struct
-  RCLCPP_PUBLIC
-  DynamicMessageType(
-    DynamicSerializationSupport::SharedPtr serialization_support,
-    rosidl_dynamic_typesupport_dynamic_type_t && rosidl_dynamic_type);
-
-  /// From description
-  RCLCPP_PUBLIC
-  DynamicMessageType(
-    DynamicSerializationSupport::SharedPtr serialization_support,
-    const rosidl_runtime_c__type_description__TypeDescription & description,
-    rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  /// Move constructor
-  RCLCPP_PUBLIC
-  DynamicMessageType(DynamicMessageType && other) noexcept;
-
-  /// Move assignment
-  RCLCPP_PUBLIC
-  DynamicMessageType & operator=(DynamicMessageType && other) noexcept;
-
   RCLCPP_PUBLIC
   virtual ~DynamicMessageType();
 
-  /// Swaps the serialization support if `serialization_support` is populated
-  /**
-   * The user can call this with another description to reconfigure the type without changing the
-   * serialization support
-   */
-  RCLCPP_PUBLIC
-  void
-  init_from_description(
-    const rosidl_runtime_c__type_description__TypeDescription & description,
-    rcl_allocator_t allocator = rcl_get_default_allocator(),
-    DynamicSerializationSupport::SharedPtr serialization_support = nullptr);
-
-  // GETTERS =======================================================================================
-  RCLCPP_PUBLIC
-  const std::string
-  get_serialization_library_identifier() const;
-
-  RCLCPP_PUBLIC
-  const std::string
-  get_name() const;
-
-  RCLCPP_PUBLIC
-  size_t
-  get_member_count() const;
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_dynamic_type_t &
-  get_rosidl_dynamic_type();
-
-  RCLCPP_PUBLIC
-  const rosidl_dynamic_typesupport_dynamic_type_t &
-  get_rosidl_dynamic_type() const;
-
-  RCLCPP_PUBLIC
-  DynamicSerializationSupport::SharedPtr
-  get_shared_dynamic_serialization_support();
-
-  RCLCPP_PUBLIC
-  DynamicSerializationSupport::ConstSharedPtr
-  get_shared_dynamic_serialization_support() const;
-
-
-  // METHODS =======================================================================================
-  RCLCPP_PUBLIC
-  DynamicMessageType
-  clone(rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  DynamicMessageType::SharedPtr
-  clone_shared(rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  bool
-  equals(const DynamicMessageType & other) const;
-
-  RCLCPP_PUBLIC
-  DynamicMessage
-  build_dynamic_message(rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  std::shared_ptr<DynamicMessage>
-  build_dynamic_message_shared(rcl_allocator_t allocator = rcl_get_default_allocator());
-
 protected:
   // NOTE(methylDragon):
   // This is just here to extend the lifetime of the serialization support
@@ -183,12 +56,6 @@ private:
 
   RCLCPP_PUBLIC
   DynamicMessageType();
-
-  RCLCPP_PUBLIC
-  bool
-  match_serialization_support_(
-    const DynamicSerializationSupport & serialization_support,
-    const rosidl_dynamic_typesupport_dynamic_type_t & rosidl_dynamic_type);
 };
 
 }  // namespace dynamic_typesupport

rclcpp/include/rclcpp/dynamic_typesupport/dynamic_message_type_builder.hpp

@@ -30,347 +30,16 @@ namespace rclcpp
 namespace dynamic_typesupport
 {
 
-class DynamicMessage;
-class DynamicMessageType;
-
 /// Utility wrapper class for `rosidl_dynamic_typesupport_dynamic_type_builder_t *`
-/**
- * This class:
- * - Manages the lifetime of the raw pointer.
- * - Exposes getter methods to get the raw pointer and shared pointers
- * - Exposes the underlying serialization support API
- *
- * Ownership:
- * - This class borrows the rosidl_dynamic_typesupport_serialization_support_t stored in the passed
- *   `DynamicSerializationSupport`.
- *   So it cannot outlive the `DynamicSerializationSupport`.
- * - The `DynamicSerializationSupport`'s `rosidl_dynamic_typesupport_serialization_support_t`
- *   pointer must point to the same location in memory as the stored raw pointer!
- *
- * This class is meant to map to rosidl_dynamic_typesupport_dynamic_type_builder_t, facilitating the
- * construction of dynamic types bottom-up in the C++ layer.
- *
- * The usual method of obtaining a `DynamicMessageType` is through construction of
- * `rosidl_message_type_support_t` via `rcl_dynamic_message_type_support_handle_create()`, then
- * taking ownership of its contents.
- * But `DynamicMessageTypeBuilder` can also be used to obtain `DynamicMessageType` by constructing
- * it bottom-up instead, since it exposes the lower_level rosidl methods.
- */
+/// STUBBED OUT
 class DynamicMessageTypeBuilder : public std::enable_shared_from_this<DynamicMessageTypeBuilder>
 {
 public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(DynamicMessageTypeBuilder)
 
-  // CONSTRUCTION ==================================================================================
-  // All constructors require a passed in `DynamicSerializationSupport::SharedPtr`, to extend the
-  // lifetime of the serialization support.
-  //
-  // In cases where a dynamic type builder pointer is passed, the serialization support composed by
-  // the builder should be the exact same object managed by the `DynamicSerializationSupport`,
-  // otherwise the lifetime management will not work properly.
-
-  /// Construct a new `DynamicMessageTypeBuilder` with the provided serialization support using its
-  /// allocator
-  RCLCPP_PUBLIC
-  DynamicMessageTypeBuilder(
-    DynamicSerializationSupport::SharedPtr serialization_support,
-    const std::string & name);
-
-  /// Construct a new `DynamicMessageTypeBuilder` with the provided serialization support and
-  /// allocator
-  RCLCPP_PUBLIC
-  DynamicMessageTypeBuilder(
-    DynamicSerializationSupport::SharedPtr serialization_support,
-    const std::string & name,
-    rcl_allocator_t allocator);
-
-  /// Assume ownership of struct
-  RCLCPP_PUBLIC
-  DynamicMessageTypeBuilder(
-    DynamicSerializationSupport::SharedPtr serialization_support,
-    rosidl_dynamic_typesupport_dynamic_type_builder_t && dynamic_type_builder);
-
-  /// From description
-  RCLCPP_PUBLIC
-  DynamicMessageTypeBuilder(
-    DynamicSerializationSupport::SharedPtr serialization_support,
-    const rosidl_runtime_c__type_description__TypeDescription & description,
-    rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  /// Move constructor
-  RCLCPP_PUBLIC
-  DynamicMessageTypeBuilder(DynamicMessageTypeBuilder && other) noexcept;
-
-  /// Move assignment
-  RCLCPP_PUBLIC
-  DynamicMessageTypeBuilder & operator=(DynamicMessageTypeBuilder && other) noexcept;
-
   RCLCPP_PUBLIC
   virtual ~DynamicMessageTypeBuilder();
 
-  /// Swaps the serialization support if serialization_support is populated
-  /**
-   * The user can call this with another description to reconfigure the type without changing the
-   * serialization support
-   */
-  RCLCPP_PUBLIC
-  void
-  init_from_description(
-    const rosidl_runtime_c__type_description__TypeDescription & description,
-    rcl_allocator_t allocator = rcl_get_default_allocator(),
-    DynamicSerializationSupport::SharedPtr serialization_support = nullptr);
-
-
-  // GETTERS =======================================================================================
-  RCLCPP_PUBLIC
-  const std::string
-  get_serialization_library_identifier() const;
-
-  RCLCPP_PUBLIC
-  const std::string
-  get_name() const;
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_dynamic_type_builder_t &
-  get_rosidl_dynamic_type_builder();
-
-  RCLCPP_PUBLIC
-  const rosidl_dynamic_typesupport_dynamic_type_builder_t &
-  get_rosidl_dynamic_type_builder() const;
-
-  RCLCPP_PUBLIC
-  DynamicSerializationSupport::SharedPtr
-  get_shared_dynamic_serialization_support();
-
-  RCLCPP_PUBLIC
-  DynamicSerializationSupport::ConstSharedPtr
-  get_shared_dynamic_serialization_support() const;
-
-
-  // METHODS =======================================================================================
-  RCLCPP_PUBLIC
-  void
-  set_name(const std::string & name);
-
-  RCLCPP_PUBLIC
-  DynamicMessageTypeBuilder
-  clone(rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  DynamicMessageTypeBuilder::SharedPtr
-  clone_shared(rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  void
-  clear(rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  DynamicMessage
-  build_dynamic_message(rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  DynamicMessage::SharedPtr
-  build_dynamic_message_shared(rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  DynamicMessageType
-  build_dynamic_message_type(rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  RCLCPP_PUBLIC
-  DynamicMessageType::SharedPtr
-  build_dynamic_message_type_shared(rcl_allocator_t allocator = rcl_get_default_allocator());
-
-
-  // ADD MEMBERS TEMPLATES =========================================================================
-  /**
-   * Since we're in a ROS layer, these should support all ROS interface C++ types as found in:
-   * https://docs.ros.org/en/rolling/Concepts/About-ROS-Interfaces.html
-   *
-   * Explicitly:
-   * - Basic types:        bool, byte, char
-   * - Float types:        float, double
-   * - Int types:          int8_t, int16_t, int32_t, int64_t
-   * - Unsigned int types: uint8_t, uint16_t, uint32_t, uint64_t
-   * - String types:       std::string, std::u16string
-   */
-
-  template<typename MemberT>
-  void
-  add_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    const std::string & default_value = "");
-
-  template<typename MemberT>
-  void
-  add_array_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t array_length,
-    const std::string & default_value = "");
-
-  template<typename MemberT>
-  void
-  add_unbounded_sequence_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    const std::string & default_value = "");
-
-  template<typename MemberT>
-  void
-  add_bounded_sequence_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t sequence_bound,
-    const std::string & default_value = "");
-
-
-  // ADD FIXED STRING MEMBERS ======================================================================
-  RCLCPP_PUBLIC
-  void
-  add_fixed_string_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t string_length,
-    const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_fixed_wstring_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t wstring_length,
-    const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_fixed_string_array_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    size_t string_length, size_t array_length, const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_fixed_wstring_array_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    size_t wstring_length, size_t array_length, const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_fixed_string_unbounded_sequence_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t string_length,
-    const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_fixed_wstring_unbounded_sequence_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t wstring_length,
-    const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_fixed_string_bounded_sequence_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    size_t string_length, size_t sequence_bound, const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_fixed_wstring_bounded_sequence_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    size_t wstring_length, size_t sequence_bound, const std::string & default_value = "");
-
-
-  // ADD BOUNDED STRING MEMBERS ====================================================================
-  RCLCPP_PUBLIC
-  void
-  add_bounded_string_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t string_bound,
-    const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_bounded_wstring_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t wstring_bound,
-    const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_bounded_string_array_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    size_t string_bound, size_t array_length, const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_bounded_wstring_array_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    size_t wstring_bound, size_t array_length, const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_bounded_string_unbounded_sequence_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t string_bound,
-    const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_bounded_wstring_unbounded_sequence_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t wstring_bound,
-    const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_bounded_string_bounded_sequence_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    size_t string_bound, size_t sequence_bound, const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_bounded_wstring_bounded_sequence_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    size_t wstring_bound, size_t sequence_bound, const std::string & default_value = "");
-
-
-  // ADD NESTED MEMBERS ============================================================================
-  RCLCPP_PUBLIC
-  void
-  add_complex_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    DynamicMessageType & nested_type, const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_complex_array_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    DynamicMessageType & nested_type, size_t array_length, const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_complex_unbounded_sequence_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    DynamicMessageType & nested_type, const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_complex_bounded_sequence_member(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    DynamicMessageType & nested_type, size_t sequence_bound,
-    const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_complex_member_builder(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    DynamicMessageTypeBuilder & nested_type_builder, const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_complex_array_member_builder(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    DynamicMessageTypeBuilder & nested_type_builder, size_t array_length,
-    const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_complex_unbounded_sequence_member_builder(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    DynamicMessageTypeBuilder & nested_type_builder, const std::string & default_value = "");
-
-  RCLCPP_PUBLIC
-  void
-  add_complex_bounded_sequence_member_builder(
-    rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-    DynamicMessageTypeBuilder & nested_type_builder, size_t sequence_bound,
-    const std::string & default_value = "");
-
 protected:
   // NOTE(methylDragon):
   // This is just here to extend the lifetime of the serialization support
@@ -387,19 +56,6 @@ private:
 
   RCLCPP_PUBLIC
   DynamicMessageTypeBuilder();
-
-  RCLCPP_PUBLIC
-  void
-  init_from_serialization_support_(
-    DynamicSerializationSupport::SharedPtr serialization_support,
-    const std::string & name,
-    rcl_allocator_t allocator);
-
-  RCLCPP_PUBLIC
-  bool
-  match_serialization_support_(
-    const DynamicSerializationSupport & serialization_support,
-    const rosidl_dynamic_typesupport_dynamic_type_builder_t & dynamic_type_builder);
 };
 
 }  // namespace dynamic_typesupport

rclcpp/include/rclcpp/dynamic_typesupport/dynamic_message_type_support.hpp

@@ -38,115 +38,16 @@ namespace dynamic_typesupport
 {
 
 /// Utility wrapper class for `rosidl_message_type_support_t` containing managed
-/// instances of the typesupport handle impl.
-/**
- *
- * NOTE: This class is the recommended way to obtain the dynamic message type
- *       support struct, instead of `rcl_dynamic_message_type_support_handle_init()`,
- *       because this class will manage the lifetimes for you.
- *
- *       Do NOT call rcl_dynamic_message_type_support_handle_fini
- *
- * This class:
- * - Exposes getter methods for the struct
- * - Stores shared pointers to wrapper classes that expose the underlying
- *   serialization support API
- *
- * Ownership:
- * - This class, similarly to the `rosidl_dynamic_typesupport_serialization_support_t`, must outlive
- *   all downstream usages of the serialization support.
- */
+/// STUBBED OUT
 class DynamicMessageTypeSupport : public std::enable_shared_from_this<DynamicMessageTypeSupport>
 {
 public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(DynamicMessageTypeSupport)
 
-  // CONSTRUCTION ==================================================================================
-  /// From description
-  /// Does NOT take ownership of the description (copies instead.)
-  /// Constructs type support top-down (calling `rcl_dynamic_message_type_support_handle_create()`)
-  RCLCPP_PUBLIC
-  DynamicMessageTypeSupport(
-    const rosidl_runtime_c__type_description__TypeDescription & description,
-    const std::string & serialization_library_name = "",
-    rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  /// From description, for provided serialization support
-  /// Does NOT take ownership of the description (copies instead.)
-  /// Constructs type support top-down (calling `rosidl_dynamic_message_type_support_handle_init()`)
-  RCLCPP_PUBLIC
-  DynamicMessageTypeSupport(
-    DynamicSerializationSupport::SharedPtr serialization_support,
-    const rosidl_runtime_c__type_description__TypeDescription & description,
-    rcl_allocator_t allocator = rcl_get_default_allocator());
-
-  /// Assume ownership of managed types
-  /// Does NOT take ownership of the description (copies instead.)
-  ///
-  /// The serialization support used to construct all managed SharedPtrs must match.
-  /// The structure of the provided `description` must match the `dynamic_message_type`
-  /// The structure of the provided `dynamic_message_type` must match the `dynamic_message
-  ///
-  /// In this case, the user would have constructed the type support bototm-up (by creating the
-  /// respective dynamic members.)
-  RCLCPP_PUBLIC
-  DynamicMessageTypeSupport(
-    DynamicSerializationSupport::SharedPtr serialization_support,
-    DynamicMessageType::SharedPtr dynamic_message_type,
-    DynamicMessage::SharedPtr dynamic_message,
-    const rosidl_runtime_c__type_description__TypeDescription & description,
-    rcl_allocator_t allocator = rcl_get_default_allocator());
-
   RCLCPP_PUBLIC
   virtual ~DynamicMessageTypeSupport();
 
-
-  // GETTERS =======================================================================================
-  RCLCPP_PUBLIC
-  const std::string
-  get_serialization_library_identifier() const;
-
-  RCLCPP_PUBLIC
-  const rosidl_message_type_support_t &
-  get_const_rosidl_message_type_support();
-
-  RCLCPP_PUBLIC
-  const rosidl_message_type_support_t &
-  get_const_rosidl_message_type_support() const;
-
-  RCLCPP_PUBLIC
-  const rosidl_runtime_c__type_description__TypeDescription &
-  get_rosidl_runtime_c_type_description() const;
-
-  RCLCPP_PUBLIC
-  DynamicSerializationSupport::SharedPtr
-  get_shared_dynamic_serialization_support();
-
-  RCLCPP_PUBLIC
-  DynamicSerializationSupport::ConstSharedPtr
-  get_shared_dynamic_serialization_support() const;
-
-  RCLCPP_PUBLIC
-  DynamicMessageType::SharedPtr
-  get_shared_dynamic_message_type();
-
-  RCLCPP_PUBLIC
-  DynamicMessageType::ConstSharedPtr
-  get_shared_dynamic_message_type() const;
-
-  RCLCPP_PUBLIC
-  DynamicMessage::SharedPtr
-  get_shared_dynamic_message();
-
-  RCLCPP_PUBLIC
-  DynamicMessage::ConstSharedPtr
-  get_shared_dynamic_message() const;
-
 protected:
-  RCLCPP_PUBLIC
-  rosidl_message_type_support_t &
-  get_rosidl_message_type_support();
-
   DynamicSerializationSupport::SharedPtr serialization_support_;
   DynamicMessageType::SharedPtr dynamic_message_type_;
   DynamicMessage::SharedPtr dynamic_message_;

rclcpp/include/rclcpp/dynamic_typesupport/dynamic_serialization_support.hpp

@@ -31,60 +31,22 @@ namespace dynamic_typesupport
 {
 
 /// Utility wrapper class for rosidl_dynamic_typesupport_serialization_support_t
-/**
- * This class:
- * - Exposes getter methods for the struct
- * - Exposes the underlying serialization support API
- *
- * Ownership:
- * - This class, similarly to the rosidl_dynamic_typesupport_serialization_support_t, must outlive
- *   all downstream usages of the serialization support.
- */
 class DynamicSerializationSupport : public std::enable_shared_from_this<DynamicSerializationSupport>
 {
 public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(DynamicSerializationSupport)
 
-  // CONSTRUCTION ==================================================================================
   RCLCPP_PUBLIC
   explicit DynamicSerializationSupport(rcl_allocator_t allocator = rcl_get_default_allocator());
 
-  /// Get the rmw middleware implementation specific serialization support (configured by name)
   RCLCPP_PUBLIC
   DynamicSerializationSupport(
     const std::string & serialization_library_name,
     rcl_allocator_t allocator = rcl_get_default_allocator());
 
-  /// Assume ownership of struct
-  RCLCPP_PUBLIC
-  explicit DynamicSerializationSupport(
-    rosidl_dynamic_typesupport_serialization_support_t && rosidl_serialization_support);
-
-  /// Move constructor
-  RCLCPP_PUBLIC
-  DynamicSerializationSupport(DynamicSerializationSupport && other) noexcept;
-
-  /// Move assignment
-  RCLCPP_PUBLIC
-  DynamicSerializationSupport & operator=(DynamicSerializationSupport && other) noexcept;
-
   RCLCPP_PUBLIC
   virtual ~DynamicSerializationSupport();
 
-
-  // GETTERS =======================================================================================
-  RCLCPP_PUBLIC
-  const std::string
-  get_serialization_library_identifier() const;
-
-  RCLCPP_PUBLIC
-  rosidl_dynamic_typesupport_serialization_support_t &
-  get_rosidl_serialization_support();
-
-  RCLCPP_PUBLIC
-  const rosidl_dynamic_typesupport_serialization_support_t &
-  get_rosidl_serialization_support() const;
-
 protected:
   rosidl_dynamic_typesupport_serialization_support_t rosidl_serialization_support_;
 

rclcpp/include/rclcpp/event_handler.hpp

@@ -20,6 +20,7 @@
 #include <mutex>
 #include <stdexcept>
 #include <string>
+#include <vector>
 
 #include "rcl/error_handling.h"
 #include "rcl/event_callback.h"
@@ -221,6 +222,13 @@ public:
     }
   }
 
+  RCLCPP_PUBLIC
+  std::vector<std::shared_ptr<rclcpp::TimerBase>>
+  get_timers() const override
+  {
+    return {};
+  }
+
 protected:
   RCLCPP_PUBLIC
   void
@@ -278,15 +286,15 @@ public:
       RCUTILS_LOG_ERROR_NAMED(
         "rclcpp",
         "Couldn't take event info: %s", rcl_get_error_string().str);
+      rcl_reset_error();
       return nullptr;
     }
     return std::static_pointer_cast<void>(std::make_shared<EventCallbackInfoT>(callback_info));
   }
 
   std::shared_ptr<void>
-  take_data_by_entity_id(size_t id) override
+  take_data_by_entity_id([[maybe_unused]] size_t id) override
   {
-    (void)id;
     return take_data();
   }
 

rclcpp/include/rclcpp/executor.hpp

@@ -287,6 +287,18 @@ public:
    * Adding subscriptions, timers, services, etc. with blocking or long running
    * callbacks may cause the function exceed the max_duration significantly.
    *
+   * Work that is ready to be done is collected only once, and when collecting that work
+   * entities which may have multiple pieces of work ready will only be executed at most
+   * one time.
+   * The reason for this is that it is not possible to tell if, for example, a ready
+   * subscription has only one message ready or multiple without checking again.
+   * Because, in order to find out if there are multiple messages, one message must
+   * be taken and executed before checking again if that subscription is still ready.
+   * However, this function only checks for ready entities to work on once,
+   * and so it will never execute a single entity more than once per call to this function.
+   * See spin_all() variants for a function that will repeatedly work on a single entity
+   * in a single call.
+   *
    * If there is no work to be done when this called, it will return immediately
    * because the collecting of available work is non-blocking.
    * Before each piece of ready work is executed this function checks if the

rclcpp/include/rclcpp/executors/executor_notify_waitable.hpp

@@ -19,6 +19,7 @@
 #include <memory>
 #include <mutex>
 #include <set>
+#include <vector>
 
 #include "rclcpp/guard_condition.hpp"
 #include "rclcpp/waitable.hpp"
@@ -41,7 +42,9 @@ public:
    *   of this waitable has signaled the wait_set.
    */
   RCLCPP_PUBLIC
-  explicit ExecutorNotifyWaitable(std::function<void(void)> on_execute_callback = {});
+  explicit ExecutorNotifyWaitable(
+    std::function<void(void)> on_execute_callback = {}, const rclcpp::Context::SharedPtr & context =
+    rclcpp::contexts::get_global_default_context());
 
   // Destructor
   RCLCPP_PUBLIC
@@ -146,6 +149,14 @@ public:
   size_t
   get_number_of_ready_guard_conditions() override;
 
+  /// Returns the number of used Timers
+  /**
+   * Will always return an empty vector.
+   */
+  RCLCPP_PUBLIC
+  std::vector<std::shared_ptr<rclcpp::TimerBase>>
+  get_timers() const override;
+
 private:
   /// Callback to run when waitable executes
   std::function<void(void)> execute_callback_;
@@ -158,8 +169,17 @@ private:
   std::function<void(size_t)> on_ready_callback_;
 
   /// The collection of guard conditions to be waited on.
-  std::set<rclcpp::GuardCondition::WeakPtr,
-    std::owner_less<rclcpp::GuardCondition::WeakPtr>> notify_guard_conditions_;
+  std::set<rclcpp::GuardCondition::SharedPtr> notify_guard_conditions_;
+
+  /// The indixes were our guard conditions were stored in the
+  /// rcl waitset
+  std::vector<size_t> idxs_of_added_guard_condition_;
+
+  /// set to true, if we got a pending trigger
+  bool needs_processing = false;
+
+  /// A guard condition needed to generate wakeups
+  rclcpp::GuardCondition::SharedPtr guard_condition_;
 };
 
 }  // namespace executors

rclcpp/include/rclcpp/experimental/buffers/ring_buffer_implementation.hpp

@@ -17,6 +17,7 @@
 
 #include <memory>
 #include <mutex>
+#include <shared_mutex>
 #include <stdexcept>
 #include <utility>
 #include <vector>
@@ -69,7 +70,7 @@ public:
    */
   void enqueue(BufferT request) override
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::unique_lock lock(mutex_);
 
     write_index_ = next_(write_index_);
     ring_buffer_[write_index_] = std::move(request);
@@ -95,7 +96,7 @@ public:
    */
   BufferT dequeue() override
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::unique_lock lock(mutex_);
 
     if (!has_data_()) {
       return BufferT();
@@ -134,7 +135,7 @@ public:
    */
   inline size_t next(size_t val)
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::unique_lock lock(mutex_);
     return next_(val);
   }
 
@@ -146,7 +147,7 @@ public:
    */
   inline bool has_data() const override
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::shared_lock lock(mutex_);
     return has_data_();
   }
 
@@ -159,7 +160,7 @@ public:
    */
   inline bool is_full() const
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::shared_lock lock(mutex_);
     return is_full_();
   }
 
@@ -171,13 +172,15 @@ public:
    */
   size_t available_capacity() const override
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::shared_lock lock(mutex_);
     return available_capacity_();
   }
 
   void clear() override
   {
     TRACETOOLS_TRACEPOINT(rclcpp_ring_buffer_clear, static_cast<const void *>(this));
+    std::unique_lock lock(mutex_);
+    clear_();
   }
 
 private:
@@ -227,6 +230,14 @@ private:
     return capacity_ - size_;
   }
 
+  inline void clear_()
+  {
+    ring_buffer_.clear();
+    size_ = 0;
+    read_index_ = 0;
+    write_index_ = capacity_ - 1;
+  }
+
   /// Traits for checking if a type is std::unique_ptr
   template<typename ...>
   struct is_std_unique_ptr final : std::false_type {};
@@ -251,7 +262,7 @@ private:
     void> * = nullptr>
   std::vector<BufferT> get_all_data_impl()
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::unique_lock lock(mutex_);
     std::vector<BufferT> result_vtr;
     result_vtr.reserve(size_);
     for (size_t id = 0; id < size_; ++id) {
@@ -266,7 +277,7 @@ private:
       std::is_copy_constructible<T>::value, void> * = nullptr>
   std::vector<BufferT> get_all_data_impl()
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::unique_lock lock(mutex_);
     std::vector<BufferT> result_vtr;
     result_vtr.reserve(size_);
     for (size_t id = 0; id < size_; ++id) {
@@ -292,7 +303,7 @@ private:
     return {};
   }
 
-  size_t capacity_;
+  const size_t capacity_;
 
   std::vector<BufferT> ring_buffer_;
 
@@ -300,7 +311,7 @@ private:
   size_t read_index_;
   size_t size_;
 
-  mutable std::mutex mutex_;
+  mutable std::shared_mutex mutex_;
 };
 
 }  // namespace buffers

rclcpp/include/rclcpp/experimental/subscription_intra_process_base.hpp

@@ -19,6 +19,7 @@
 #include <memory>
 #include <mutex>
 #include <string>
+#include <vector>
 
 #include "rcl/wait.h"
 #include "rmw/impl/cpp/demangle.hpp"
@@ -78,9 +79,8 @@ public:
   take_data() override = 0;
 
   std::shared_ptr<void>
-  take_data_by_entity_id(size_t id) override
+  take_data_by_entity_id([[maybe_unused]] size_t id) override
   {
-    (void)id;
     return take_data();
   }
 
@@ -180,6 +180,13 @@ public:
     on_new_message_callback_ = nullptr;
   }
 
+  RCLCPP_PUBLIC
+  std::vector<std::shared_ptr<rclcpp::TimerBase>>
+  get_timers() const override
+  {
+    return {};
+  }
+
 protected:
   std::recursive_mutex callback_mutex_;
   std::function<void(size_t)> on_new_message_callback_ {nullptr};

rclcpp/include/rclcpp/experimental/subscription_intra_process_buffer.hpp

@@ -110,9 +110,8 @@ public:
   }
 
   bool
-  is_ready(const rcl_wait_set_t & wait_set) override
+  is_ready([[maybe_unused]] const rcl_wait_set_t & wait_set) override
   {
-    (void) wait_set;
     return buffer_->has_data();
   }
 

rclcpp/include/rclcpp/logger.hpp

@@ -78,34 +78,6 @@ RCLCPP_PUBLIC
 Logger
 get_node_logger(const rcl_node_t * node);
 
-// TODO(ahcorde): Remove deprecated class on the next release (in Rolling after Kilted).
-#if !defined(_WIN32)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#else  // !defined(_WIN32)
-# pragma warning(push)
-# pragma warning(disable: 4996)
-#endif
-/// Get the current logging directory.
-/**
- * For more details of how the logging directory is determined,
- * see rcl_logging_get_logging_directory().
- *
- * \returns the logging directory being used.
- * \throws rclcpp::exceptions::RCLError if an unexpected error occurs.
- */
-[[deprecated("use rclcpp::get_log_directory instead of rclcpp::get_logging_directory")]]
-RCLCPP_PUBLIC
-rcpputils::fs::path
-get_logging_directory();
-
-// remove warning suppression
-#if !defined(_WIN32)
-# pragma GCC diagnostic pop
-#else  // !defined(_WIN32)
-# pragma warning(pop)
-#endif
-
 /// Get the current logging directory.
 /**
  * For more details of how the logging directory is determined,

rclcpp/include/rclcpp/node.hpp

@@ -1559,6 +1559,10 @@ public:
    * which has been created using an existing instance of this class, but which
    * has an additional sub-namespace (short for subordinate namespace)
    * associated with it.
+   * A subordinate node and an instance of this class share all the node interfaces
+   * such as `rclcpp::node_interfaces::NodeParametersInterface`.
+   * Subordinate nodes are primarily used to organize namespaces and provide a
+   * hierarchical structure, but they are not meant to be completely independent nodes.
    * The sub-namespace will extend the node's namespace for the purpose of
    * creating additional entities, such as Publishers, Subscriptions, Service
    * Clients and Servers, and so on.

rclcpp/include/rclcpp/node_impl.hpp

@@ -323,11 +323,9 @@ template<typename ParameterT>
 bool
 Node::get_parameter(const std::string & name, ParameterT & parameter) const
 {
-  std::string sub_name = extend_name_with_sub_namespace(name, this->get_sub_namespace());
-
   rclcpp::Parameter parameter_variant;
 
-  bool result = get_parameter(sub_name, parameter_variant);
+  bool result = get_parameter(name, parameter_variant);
   if (result) {
     parameter = static_cast<ParameterT>(parameter_variant.get_value<ParameterT>());
   }
@@ -342,9 +340,7 @@ Node::get_parameter_or(
   ParameterT & parameter,
   const ParameterT & alternative_value) const
 {
-  std::string sub_name = extend_name_with_sub_namespace(name, this->get_sub_namespace());
-
-  bool got_parameter = get_parameter(sub_name, parameter);
+  bool got_parameter = get_parameter(name, parameter);
   if (!got_parameter) {
     parameter = alternative_value;
   }

rclcpp/include/rclcpp/node_interfaces/node_parameters.hpp

@@ -214,6 +214,10 @@ public:
   const std::map<std::string, rclcpp::ParameterValue> &
   get_parameter_overrides() const override;
 
+  RCLCPP_PUBLIC
+  void
+  enable_parameter_modification() override;
+
   using PreSetCallbacksHandleContainer = std::list<PreSetParametersCallbackHandle::WeakPtr>;
   using OnSetCallbacksHandleContainer = std::list<OnSetParametersCallbackHandle::WeakPtr>;
   using PostSetCallbacksHandleContainer = std::list<PostSetParametersCallbackHandle::WeakPtr>;

rclcpp/include/rclcpp/node_interfaces/node_parameters_interface.hpp

@@ -270,6 +270,26 @@ public:
   virtual
   const std::map<std::string, rclcpp::ParameterValue> &
   get_parameter_overrides() const = 0;
+
+  /// Enable parameter modification recursively during parameter callbacks.
+  /**
+   * This function is used to enable parameter modification during parameter callbacks.
+   *
+   * There are times when it does not allow parameter modification, such as when the parameter
+   * callbacks are being called and tries to modify the parameters with set_parameter and
+   * declare_parameter to avoid recursive parameter modification.
+   * This is protected by rclcpp::node_interfaces::ParameterMutationRecursionGuard.
+   *
+   * This function is explicitly called to allow the recursive parameter operation during
+   * parameter callbacks by the application.
+   * Once it is enabled, the next parameter operation set/declare/undeclare_parameter are
+   * allowed to execute in the parameter callback. But, no more further recursive operation
+   * is allowed, unless user application calls this API again.
+   */
+  RCLCPP_PUBLIC
+  virtual
+  void
+  enable_parameter_modification() = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/parameter_events_filter.hpp

@@ -45,6 +45,7 @@ public:
    * \param[in] names A list of parameter names of interest.
    * \param[in] types A list of the types of parameter events of iterest.
    *    EventType NEW, DELETED, or CHANGED
+   * \throws std::invalid_argument if event is NULL.
    *
    * Example Usage:
    *

rclcpp/include/rclcpp/publisher.hpp

@@ -143,12 +143,9 @@ public:
   post_init_setup(
     rclcpp::node_interfaces::NodeBaseInterface * node_base,
     const std::string & topic,
-    const rclcpp::QoS & qos,
-    const rclcpp::PublisherOptionsWithAllocator<AllocatorT> & options)
+    [[maybe_unused]] const rclcpp::QoS & qos,
+    [[maybe_unused]] const rclcpp::PublisherOptionsWithAllocator<AllocatorT> & options)
   {
-    (void)qos;
-    (void)options;
-
     // If needed, setup intra process communication.
     if (rclcpp::detail::resolve_use_intra_process(options_, *node_base)) {
       auto context = node_base->get_context();

rclcpp/include/rclcpp/qos.hpp

@@ -146,10 +146,18 @@ public:
   QoS(size_t history_depth);  // NOLINT(runtime/explicit): conversion constructor
 
   /// Return the rmw qos profile.
+  /**
+   * The profile consists of various QoS policies such as history, reliability, and durability.
+   * Use the corresponding getter functions to retrieve individual policies.
+   */
   rmw_qos_profile_t &
   get_rmw_qos_profile();
 
   /// Return the rmw qos profile.
+  /**
+   * The profile consists of various QoS policies such as history, reliability, and durability.
+   * Use the corresponding getter functions to retrieve individual policies.
+   */
   const rmw_qos_profile_t &
   get_rmw_qos_profile() const;
 
@@ -475,7 +483,7 @@ public:
   explicit
   RosoutQoS(
     const QoSInitialization & rosout_qos_initialization = (
-      QoSInitialization::from_rmw(rcl_qos_profile_rosout_default)
+      QoSInitialization::from_rmw(rmw_qos_profile_rosout_default)
   ));
 };
 

rclcpp/include/rclcpp/rclcpp.hpp

@@ -133,9 +133,6 @@
  * - Dynamic typesupport
  *   - rclcpp::dynamic_typesupport::DynamicMessageTypeSupport
  *   - rclcpp/dynamic_typesupport/dynamic_message_type_support.hpp
- * - Dynamic subscription
- *   - rclcpp::DynamicSubscription
- *   - rclcpp/dynamic_subscription.hpp
  * - Generic publisher
  *   - rclcpp::Node::create_generic_publisher()
  *   - rclcpp::GenericPublisher
@@ -187,6 +184,4 @@
 #include "rclcpp/waitable.hpp"
 #include "rclcpp/wait_set.hpp"
 
-#include "rclcpp/dynamic_subscription.hpp"
-
 #endif  // RCLCPP__RCLCPP_HPP_

rclcpp/include/rclcpp/service.hpp

@@ -504,6 +504,9 @@ public:
    * \param[in] clock clock to use to generate introspection timestamps
    * \param[in] qos_service_event_pub QoS settings to use when creating the introspection publisher
    * \param[in] introspection_state the state to set introspection to
+   *
+   * \throws anything rclcpp::exceptions::throw_from_rcl_error can throw if
+   *   it failed to configure introspection.
    */
   void
   configure_introspection(

rclcpp/include/rclcpp/strategies/allocator_memory_strategy.hpp

@@ -201,6 +201,7 @@ public:
         RCUTILS_LOG_ERROR_NAMED(
           "rclcpp",
           "Couldn't add subscription to wait set: %s", rcl_get_error_string().str);
+        rcl_reset_error();
         return false;
       }
     }
@@ -210,6 +211,7 @@ public:
         RCUTILS_LOG_ERROR_NAMED(
           "rclcpp",
           "Couldn't add client to wait set: %s", rcl_get_error_string().str);
+        rcl_reset_error();
         return false;
       }
     }
@@ -219,6 +221,7 @@ public:
         RCUTILS_LOG_ERROR_NAMED(
           "rclcpp",
           "Couldn't add service to wait set: %s", rcl_get_error_string().str);
+        rcl_reset_error();
         return false;
       }
     }
@@ -228,6 +231,7 @@ public:
         RCUTILS_LOG_ERROR_NAMED(
           "rclcpp",
           "Couldn't add timer to wait set: %s", rcl_get_error_string().str);
+        rcl_reset_error();
         return false;
       }
     }

rclcpp/include/rclcpp/strategies/message_pool_memory_strategy.hpp

@@ -114,9 +114,9 @@ public:
    * all references.
    * \param[in] msg Shared pointer to the message to return.
    */
-  void return_message(std::shared_ptr<MessageT> & msg)
+  void return_message([[maybe_unused]] std::shared_ptr<MessageT> & msg)
   {
-    (void)msg;
+    // This function is intentionally left empty.
   }
 
 protected:

rclcpp/include/rclcpp/subscription.hpp

@@ -209,13 +209,11 @@ public:
   /// Called after construction to continue setup that requires shared_from_this().
   void
   post_init_setup(
-    rclcpp::node_interfaces::NodeBaseInterface * node_base,
-    const rclcpp::QoS & qos,
-    const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options)
+    [[maybe_unused]] rclcpp::node_interfaces::NodeBaseInterface * node_base,
+    [[maybe_unused]] const rclcpp::QoS & qos,
+    [[maybe_unused]] const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options)
   {
-    (void)node_base;
-    (void)qos;
-    (void)options;
+    // This function is intentionally left empty.
   }
 
   /// Take the next message from the inter-process subscription.
@@ -422,20 +420,17 @@ public:
 
   void
   return_dynamic_message(
-    rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message) override
+    [[maybe_unused]] rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message) override
   {
-    (void) message;
     throw rclcpp::exceptions::UnimplementedError(
             "return_dynamic_message is not implemented for Subscription");
   }
 
   void
   handle_dynamic_message(
-    const rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message,
-    const rclcpp::MessageInfo & message_info) override
+    [[maybe_unused]] const rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message,
+    [[maybe_unused]] const rclcpp::MessageInfo & message_info) override
   {
-    (void) message;
-    (void) message_info;
     throw rclcpp::exceptions::UnimplementedError(
             "handle_dynamic_message is not implemented for Subscription");
   }

rclcpp/include/rclcpp/subscription_base.hpp

@@ -20,8 +20,8 @@
 #include <mutex>
 #include <string>
 #include <unordered_map>
-#include <vector>
 #include <utility>
+#include <vector>
 
 #include "rcl/event_callback.h"
 #include "rcl/subscription.h"
@@ -644,10 +644,6 @@ protected:
 
   rclcpp::node_interfaces::NodeBaseInterface * const node_base_;
 
-  // TODO(methylDragon): Remove if we don't need this
-  // rclcpp::node_interfaces::NodeGraphInterface * const node_graph_;
-  // rclcpp::node_interfaces::NodeServicesInterface * const node_services_;
-
   std::shared_ptr<rcl_node_t> node_handle_;
 
   std::recursive_mutex callback_mutex_;

rclcpp/include/rclcpp/typesupport_helpers.hpp

@@ -21,6 +21,7 @@
 #include <tuple>
 
 #include "rcpputils/shared_library.hpp"
+#include "rosidl_runtime_cpp/action_type_support_decl.hpp"
 #include "rosidl_runtime_cpp/message_type_support_decl.hpp"
 #include "rosidl_runtime_cpp/service_type_support_decl.hpp"
 
@@ -57,7 +58,7 @@ get_message_typesupport_handle(
 
 /// Extract the service type support handle from the library.
 /**
- * The library needs to match the topic type. The shared library must stay loaded for the lifetime of the result.
+ * The library needs to match the service type. The shared library must stay loaded for the lifetime of the result.
  *
  * \param[in] type The service type, e.g. "std_srvs/srv/Empty"
  * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
@@ -72,6 +73,24 @@ get_service_typesupport_handle(
   const std::string & typesupport_identifier,
   rcpputils::SharedLibrary & library);
 
+/// Extract the action type support handle from the library.
+/**
+ * The library needs to match the action type. The shared library must stay loaded for the lifetime
+ * of the result.
+ *
+ * \param[in] type The action type, e.g. "example_interfaces/action/Fibonacci"
+ * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
+ * \param[in] library The shared type support library
+ * \throws std::runtime_error if the symbol of type not found in the library.
+ * \return A action type support handle
+ */
+RCLCPP_PUBLIC
+const rosidl_action_type_support_t *
+get_action_typesupport_handle(
+  const std::string & type,
+  const std::string & typesupport_identifier,
+  rcpputils::SharedLibrary & library);
+
 }  // namespace rclcpp
 
 #endif  // RCLCPP__TYPESUPPORT_HELPERS_HPP_

rclcpp/include/rclcpp/wait_result.hpp

@@ -176,7 +176,9 @@ public:
       for (; ii < wait_set.size_of_timers(); ++ii) {
         if (rcl_wait_set.timers[ii] != nullptr) {
           ret = wait_set.timers(ii);
-          break;
+          if (ret) {
+            break;
+          }
         }
       }
     }
@@ -217,7 +219,9 @@ public:
         if (rcl_wait_set.subscriptions[ii] != nullptr) {
           ret = wait_set.subscriptions(ii);
           rcl_wait_set.subscriptions[ii] = nullptr;
-          break;
+          if (ret) {
+            break;
+          }
         }
       }
     }
@@ -237,7 +241,9 @@ public:
         if (rcl_wait_set.services[ii] != nullptr) {
           ret = wait_set.services(ii);
           rcl_wait_set.services[ii] = nullptr;
-          break;
+          if (ret) {
+            break;
+          }
         }
       }
     }
@@ -257,7 +263,9 @@ public:
         if (rcl_wait_set.clients[ii] != nullptr) {
           ret = wait_set.clients(ii);
           rcl_wait_set.clients[ii] = nullptr;
-          break;
+          if (ret) {
+            break;
+          }
         }
       }
     }

rclcpp/include/rclcpp/wait_set_policies/dynamic_storage.hpp

@@ -216,6 +216,11 @@ public:
       shared_waitables_
     );
 
+    if (this->needs_pruning_) {
+      this->storage_prune_deleted_entities();
+      this->needs_pruning_ = false;
+    }
+
     this->storage_release_ownerships();
   }
 
@@ -455,59 +460,60 @@ public:
 
   size_t size_of_subscriptions() const
   {
-    return shared_subscriptions_.size();
+    return subscriptions_.size();
   }
 
   size_t size_of_timers() const
   {
-    return shared_timers_.size();
+    return timers_.size();
   }
 
   size_t size_of_clients() const
   {
-    return shared_clients_.size();
+    return clients_.size();
   }
 
   size_t size_of_services() const
   {
-    return shared_services_.size();
+    return services_.size();
   }
 
   size_t size_of_waitables() const
   {
-    return shared_waitables_.size();
+    return waitables_.size();
   }
 
   std::shared_ptr<rclcpp::SubscriptionBase>
   subscriptions(size_t ii) const
   {
-    return shared_subscriptions_[ii].subscription;
+    return subscriptions_[ii].lock();
   }
 
   std::shared_ptr<rclcpp::TimerBase>
   timers(size_t ii) const
   {
-    return shared_timers_[ii];
+    return timers_[ii].lock();
   }
 
   std::shared_ptr<rclcpp::ClientBase>
   clients(size_t ii) const
   {
-    return shared_clients_[ii];
+    return clients_[ii].lock();
   }
 
   std::shared_ptr<rclcpp::ServiceBase>
   services(size_t ii) const
   {
-    return shared_services_[ii];
+    return services_[ii].lock();
   }
 
   std::shared_ptr<rclcpp::Waitable>
   waitables(size_t ii) const
   {
-    return shared_waitables_[ii].waitable;
+    return waitables_[ii].lock();
   }
 
+private:
   size_t ownership_reference_counter_ = 0;
 
   SequenceOfWeakSubscriptions subscriptions_;

rclcpp/include/rclcpp/wait_set_policies/static_storage.hpp

@@ -160,6 +160,15 @@ public:
       services_,
       waitables_
     );
+
+    if(this->needs_pruning_) {
+      // we need to throw here, as the indexing of the rcl_waitset is broken,
+      // in case of invalid entries
+
+      throw std::runtime_error(
+            "StaticStorage::storage_rebuild_rcl_wait_set(): entity weak_ptr "
+            "unexpectedly expired in static entity storage");
+    }
   }
 
   // storage_add_subscription() explicitly not declared here

rclcpp/include/rclcpp/wait_set_template.hpp

@@ -734,8 +734,6 @@ private:
     wait_result_dirty_ = false;
     // this method comes from the SynchronizationPolicy
     this->sync_wait_result_acquire();
-    // this method comes from the StoragePolicy
-    this->storage_acquire_ownerships();
   }
 
   /// Called by the WaitResult's destructor to release resources.
@@ -752,8 +750,6 @@ private:
     }
     wait_result_holding_ = false;
     wait_result_dirty_ = false;
-    // this method comes from the StoragePolicy
-    this->storage_release_ownerships();
     // this method comes from the SynchronizationPolicy
     this->sync_wait_result_release();
   }

rclcpp/include/rclcpp/waitable.hpp

@@ -18,6 +18,7 @@
 #include <atomic>
 #include <functional>
 #include <memory>
+#include <vector>
 
 #include "rclcpp/macros.hpp"
 #include "rclcpp/visibility_control.hpp"
@@ -27,6 +28,8 @@
 namespace rclcpp
 {
 
+class TimerBase;
+
 class Waitable
 {
 public:
@@ -258,6 +261,17 @@ public:
   void
   clear_on_ready_callback() = 0;
 
+  /// Returns all timers used by this waitable
+  /**
+   * Must return all timers used within the waitable.
+   * Note, it is not supported, that timers are added
+   * or removed over the lifetime of the waitable.
+   */
+  RCLCPP_PUBLIC
+  virtual
+  std::vector<std::shared_ptr<rclcpp::TimerBase>>
+  get_timers() const = 0;
+
 private:
   std::atomic<bool> in_use_by_wait_set_{false};
 };  // class Waitable

rclcpp/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format2.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="2">
   <name>rclcpp</name>
-  <version>29.3.0</version>
+  <version>29.6.0</version>
   <description>The ROS client library in C++.</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>

rclcpp/src/rclcpp/clock.cpp

@@ -83,16 +83,6 @@ Clock::now() const
   return now;
 }
 
-void
-Clock::cancel_sleep_or_wait()
-{
-  {
-    std::unique_lock lock(impl_->wait_mutex_);
-    impl_->stop_sleeping_ = true;
-  }
-  impl_->cv_.notify_one();
-}
-
 bool
 Clock::sleep_until(
   Time until,
@@ -367,4 +357,245 @@ Clock::create_jump_callback(
   // *INDENT-ON*
 }
 
+class ClockWaiter::ClockWaiterImpl
+{
+private:
+  std::condition_variable cv_;
+
+  rclcpp::Clock::SharedPtr clock_;
+  bool time_source_changed_ = false;
+  std::function<void(const rcl_time_jump_t &)> post_time_jump_callback;
+
+  bool
+  wait_until_system_time(
+    std::unique_lock<std::mutex> & lock,
+    const rclcpp::Time & abs_time, const std::function<bool ()> & pred)
+  {
+    auto system_time = std::chrono::system_clock::time_point(
+    // Cast because system clock resolution is too big for nanoseconds on some systems
+    std::chrono::duration_cast<std::chrono::system_clock::duration>(
+        std::chrono::nanoseconds(abs_time.nanoseconds())));
+
+    return cv_.wait_until(lock, system_time, pred);
+  }
+
+  bool
+  wait_until_steady_time(
+    std::unique_lock<std::mutex> & lock,
+    const rclcpp::Time & abs_time, const std::function<bool ()> & pred)
+  {
+    // Synchronize because RCL steady clock epoch might differ from chrono::steady_clock epoch
+    const rclcpp::Time rcl_entry = clock_->now();
+    const std::chrono::steady_clock::time_point chrono_entry = std::chrono::steady_clock::now();
+    const rclcpp::Duration delta_t = abs_time - rcl_entry;
+    const std::chrono::steady_clock::time_point chrono_until =
+      chrono_entry + std::chrono::nanoseconds(delta_t.nanoseconds());
+
+    return cv_.wait_until(lock, chrono_until, pred);
+  }
+
+
+  bool
+  wait_until_ros_time(
+    std::unique_lock<std::mutex> & lock,
+    const rclcpp::Time & abs_time, const std::function<bool ()> & pred)
+  {
+    // Install jump handler for any amount of time change, for two purposes:
+    // - if ROS time is active, check if time reached on each new clock sample
+    // - Trigger via on_clock_change to detect if time source changes, to invalidate sleep
+    rcl_jump_threshold_t threshold;
+    threshold.on_clock_change = true;
+    // 0 is disable, so -1 and 1 are smallest possible time changes
+    threshold.min_backward.nanoseconds = -1;
+    threshold.min_forward.nanoseconds = 1;
+
+    time_source_changed_ = false;
+
+    post_time_jump_callback = [this, &lock] (const rcl_time_jump_t & jump)
+      {
+        if (jump.clock_change != RCL_ROS_TIME_NO_CHANGE) {
+          std::lock_guard<std::mutex> lk(*lock.mutex());
+          time_source_changed_ = true;
+        }
+        cv_.notify_one();
+      };
+
+    // Note this is a trade-off. Adding the callback for every call
+    // is expensive for high frequency calls. For low frequency waits
+    // its more overhead to have the callback being called all the time.
+    // As we expect the use case to be low frequency calls to wait_until
+    // with relative big pauses between the calls, we install it on demand.
+    auto clock_handler = clock_->create_jump_callback(
+      nullptr,
+      post_time_jump_callback,
+      threshold);
+
+    if (!clock_->ros_time_is_active()) {
+      auto system_time = std::chrono::system_clock::time_point(
+        // Cast because system clock resolution is too big for nanoseconds on some systems
+        std::chrono::duration_cast<std::chrono::system_clock::duration>(
+          std::chrono::nanoseconds(abs_time.nanoseconds())));
+
+      return cv_.wait_until(lock, system_time, [this, &pred] () {
+                 return time_source_changed_ || pred();
+      });
+    }
+
+    // RCL_ROS_TIME with ros_time_is_active.
+    // Just wait without "until" because installed
+    // jump callbacks wake the cv on every new sample.
+    cv_.wait(lock, [this, &pred, &abs_time] () {
+        return clock_->now() >= abs_time || time_source_changed_ || pred();
+    });
+
+    return clock_->now() < abs_time;
+  }
+
+public:
+  explicit ClockWaiterImpl(const rclcpp::Clock::SharedPtr & clock)
+  :clock_(clock)
+  {
+  }
+
+  bool
+  wait_until(
+    std::unique_lock<std::mutex> & lock,
+    const rclcpp::Time & abs_time, const std::function<bool ()> & pred)
+  {
+    switch(clock_->get_clock_type()) {
+      case RCL_CLOCK_UNINITIALIZED:
+        throw std::runtime_error("Error, wait on uninitialized clock called");
+      case RCL_ROS_TIME:
+        return wait_until_ros_time(lock, abs_time, pred);
+        break;
+      case RCL_STEADY_TIME:
+        return wait_until_steady_time(lock, abs_time, pred);
+        break;
+      case RCL_SYSTEM_TIME:
+        return wait_until_system_time(lock, abs_time, pred);
+        break;
+    }
+
+    return false;
+  }
+
+  void
+  notify_one()
+  {
+    cv_.notify_one();
+  }
+};
+
+ClockWaiter::ClockWaiter(const rclcpp::Clock::SharedPtr & clock)
+:impl_(std::make_unique<ClockWaiterImpl>(clock))
+{
+}
+
+ClockWaiter::~ClockWaiter() = default;
+
+bool
+ClockWaiter::wait_until(
+  std::unique_lock<std::mutex> & lock,
+  const rclcpp::Time & abs_time, const std::function<bool ()> & pred)
+{
+  return impl_->wait_until(lock, abs_time, pred);
+}
+
+void
+ClockWaiter::notify_one()
+{
+  impl_->notify_one();
+}
+
+class ClockConditionalVariable::Impl
+{
+  std::mutex pred_mutex_;
+  bool shutdown_ = false;
+  rclcpp::Context::SharedPtr context_;
+  rclcpp::OnShutdownCallbackHandle shutdown_cb_handle_;
+  ClockWaiter::UniquePtr clock_;
+
+public:
+  Impl(const rclcpp::Clock::SharedPtr & clock, rclcpp::Context::SharedPtr context)
+  :context_(context),
+    clock_(std::make_unique<ClockWaiter>(clock))
+  {
+    if (!context_ || !context_->is_valid()) {
+      throw std::runtime_error("context cannot be slept with because it's invalid");
+    }
+    // Wake this thread if the context is shutdown
+    shutdown_cb_handle_ = context_->add_on_shutdown_callback(
+      [this]() {
+        {
+          std::unique_lock lock(pred_mutex_);
+          shutdown_ = true;
+        }
+        clock_->notify_one();
+    });
+  }
+
+  ~Impl()
+  {
+    context_->remove_on_shutdown_callback(shutdown_cb_handle_);
+  }
+
+  bool
+  wait_until(
+    std::unique_lock<std::mutex> & lock, rclcpp::Time until,
+    const std::function<bool ()> & pred)
+  {
+    if(lock.mutex() != &pred_mutex_) {
+      throw std::runtime_error(
+          "ClockConditionalVariable::wait_until: Internal error, given lock does not use"
+          " mutex returned by this->mutex()");
+    }
+
+    clock_->wait_until(lock, until, [this, &pred] () -> bool {
+        return shutdown_ || pred();
+      });
+    return true;
+  }
+
+  void
+  notify_one()
+  {
+    clock_->notify_one();
+  }
+
+  std::mutex &
+  mutex()
+  {
+    return pred_mutex_;
+  }
+};
+
+ClockConditionalVariable::ClockConditionalVariable(
+  const rclcpp::Clock::SharedPtr & clock,
+  rclcpp::Context::SharedPtr context)
+:impl_(std::make_unique<Impl>(clock, context))
+{
+}
+
+ClockConditionalVariable::~ClockConditionalVariable() = default;
+
+void
+ClockConditionalVariable::notify_one()
+{
+  impl_->notify_one();
+}
+
+bool
+ClockConditionalVariable::wait_until(
+  std::unique_lock<std::mutex> & lock, rclcpp::Time until,
+  const std::function<bool ()> & pred)
+{
+  return impl_->wait_until(lock, until, pred);
+}
+
+std::mutex &
+ClockConditionalVariable::mutex()
+{
+  return impl_->mutex();
+}
+
 }  // namespace rclcpp

rclcpp/src/rclcpp/detail/rmw_implementation_specific_publisher_payload.cpp

@@ -23,10 +23,9 @@ namespace detail
 
 void
 RMWImplementationSpecificPublisherPayload::modify_rmw_publisher_options(
-  rmw_publisher_options_t & rmw_publisher_options) const
+  [[maybe_unused]] rmw_publisher_options_t & rmw_publisher_options) const
 {
   // By default, do not mutate the rmw publisher options.
-  (void)rmw_publisher_options;
 }
 
 }  // namespace detail

rclcpp/src/rclcpp/detail/rmw_implementation_specific_subscription_payload.cpp

@@ -23,10 +23,9 @@ namespace detail
 
 void
 RMWImplementationSpecificSubscriptionPayload::modify_rmw_subscription_options(
-  rmw_subscription_options_t & rmw_subscription_options) const
+  [[maybe_unused]] rmw_subscription_options_t & rmw_subscription_options) const
 {
   // By default, do not mutate the rmw subscription options.
-  (void)rmw_subscription_options;
 }
 
 }  // namespace detail

rclcpp/src/rclcpp/detail/utilities.cpp

@@ -31,11 +31,10 @@ namespace detail
 
 std::vector<std::string>
 get_unparsed_ros_arguments(
-  int argc, char const * const * argv,
+  [[maybe_unused]] int argc, char const * const * argv,
   rcl_arguments_t * arguments,
   rcl_allocator_t allocator)
 {
-  (void)argc;
   std::vector<std::string> unparsed_ros_arguments;
   int unparsed_ros_args_count = rcl_arguments_get_count_unparsed_ros(arguments);
   if (unparsed_ros_args_count > 0) {

rclcpp/src/rclcpp/dynamic_subscription.cpp

@@ -1,113 +0,0 @@
-// Copyright 2022 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "rclcpp/dynamic_subscription.hpp"
-
-#include <memory>
-#include <string>
-
-#include "rcl/subscription.h"
-
-#include "rclcpp/exceptions.hpp"
-
-namespace rclcpp
-{
-
-std::shared_ptr<void> DynamicSubscription::create_message()
-{
-  return create_serialized_message();
-}
-
-std::shared_ptr<rclcpp::SerializedMessage> DynamicSubscription::create_serialized_message()
-{
-  return std::make_shared<rclcpp::SerializedMessage>(0);
-}
-
-void DynamicSubscription::handle_message(std::shared_ptr<void> &, const rclcpp::MessageInfo &)
-{
-  throw rclcpp::exceptions::UnimplementedError(
-          "handle_message is not implemented for DynamicSubscription");
-}
-
-void DynamicSubscription::handle_serialized_message(
-  const std::shared_ptr<rclcpp::SerializedMessage> &, const rclcpp::MessageInfo &)
-{
-  throw rclcpp::exceptions::UnimplementedError(
-          "handle_serialized_message is not implemented for DynamicSubscription");
-}
-
-void DynamicSubscription::handle_loaned_message(void *, const rclcpp::MessageInfo &)
-{
-  throw rclcpp::exceptions::UnimplementedError(
-          "handle_loaned_message is not implemented for DynamicSubscription");
-}
-
-void DynamicSubscription::return_message(std::shared_ptr<void> & message)
-{
-  auto typed_message = std::static_pointer_cast<rclcpp::SerializedMessage>(message);
-  return_serialized_message(typed_message);
-}
-
-void DynamicSubscription::return_serialized_message(
-  std::shared_ptr<rclcpp::SerializedMessage> & message)
-{
-  message.reset();
-}
-
-
-// DYNAMIC TYPE ====================================================================================
-// TODO(methylDragon): Re-order later
-
-// Does not clone
-rclcpp::dynamic_typesupport::DynamicMessageType::SharedPtr
-DynamicSubscription::get_shared_dynamic_message_type()
-{
-  return dynamic_message_type_;
-}
-
-// Does not clone
-rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr
-DynamicSubscription::get_shared_dynamic_message()
-{
-  return dynamic_message_;
-}
-
-rclcpp::dynamic_typesupport::DynamicSerializationSupport::SharedPtr
-DynamicSubscription::get_shared_dynamic_serialization_support()
-{
-  return serialization_support_;
-}
-
-rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr
-DynamicSubscription::create_dynamic_message()
-{
-  return dynamic_message_->init_from_type_shared(*dynamic_message_type_);
-}
-
-void
-DynamicSubscription::return_dynamic_message(
-  rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message)
-{
-  message.reset();
-}
-
-void DynamicSubscription::handle_dynamic_message(
-  const rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message,
-  const rclcpp::MessageInfo & message_info)
-{
-  (void) message_info;
-  callback_(message, ts_->get_rosidl_runtime_c_type_description());
-}
-
-}  // namespace rclcpp

rclcpp/src/rclcpp/dynamic_typesupport/dynamic_message.cpp

@@ -36,734 +36,5 @@ using rclcpp::dynamic_typesupport::DynamicMessageType;
 using rclcpp::dynamic_typesupport::DynamicMessageTypeBuilder;
 using rclcpp::dynamic_typesupport::DynamicSerializationSupport;
 
-#ifndef RCLCPP__DYNAMIC_TYPESUPPORT__DETAIL__DYNAMIC_MESSAGE_IMPL_HPP_
-// Template specialization implementations
-#include "rclcpp/dynamic_typesupport/detail/dynamic_message_impl.hpp"
-#endif
-
-
-// CONSTRUCTION ==================================================================================
-DynamicMessage::DynamicMessage(const DynamicMessageTypeBuilder::SharedPtr dynamic_type_builder)
-: DynamicMessage::DynamicMessage(
-    dynamic_type_builder, dynamic_type_builder->get_rosidl_dynamic_type_builder().allocator) {}
-
-
-DynamicMessage::DynamicMessage(
-  const DynamicMessageTypeBuilder::SharedPtr dynamic_type_builder,
-  rcl_allocator_t allocator)
-: serialization_support_(dynamic_type_builder->get_shared_dynamic_serialization_support()),
-  rosidl_dynamic_data_(rosidl_dynamic_typesupport_get_zero_initialized_dynamic_data()),
-  is_loaned_(false),
-  parent_data_(nullptr)
-{
-  if (!serialization_support_) {
-    throw std::runtime_error("dynamic message could not bind serialization support!");
-  }
-  if (!dynamic_type_builder) {
-    throw std::runtime_error("dynamic message type builder cannot be nullptr!");
-  }
-
-  rosidl_dynamic_typesupport_dynamic_type_builder_t rosidl_dynamic_type_builder =
-    dynamic_type_builder->get_rosidl_dynamic_type_builder();
-
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_init_from_dynamic_type_builder(
-    &rosidl_dynamic_type_builder, &allocator, &get_rosidl_dynamic_data());
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error("could not init new dynamic data object from dynamic type builder");
-  }
-}
-
-
-DynamicMessage::DynamicMessage(const DynamicMessageType::SharedPtr dynamic_type)
-: DynamicMessage::DynamicMessage(
-    dynamic_type, dynamic_type->get_rosidl_dynamic_type().allocator) {}
-
-
-DynamicMessage::DynamicMessage(
-  const DynamicMessageType::SharedPtr dynamic_type,
-  rcl_allocator_t allocator)
-: serialization_support_(dynamic_type->get_shared_dynamic_serialization_support()),
-  rosidl_dynamic_data_(rosidl_dynamic_typesupport_get_zero_initialized_dynamic_data()),
-  is_loaned_(false),
-  parent_data_(nullptr)
-{
-  if (!serialization_support_) {
-    throw std::runtime_error("dynamic type could not bind serialization support!");
-  }
-  if (!dynamic_type) {
-    throw std::runtime_error("dynamic message type cannot be nullptr!");
-  }
-
-  rosidl_dynamic_typesupport_dynamic_type_t rosidl_dynamic_type =
-    dynamic_type->get_rosidl_dynamic_type();
-
-  rosidl_dynamic_typesupport_dynamic_data_t rosidl_dynamic_data =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_data();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_init_from_dynamic_type(
-    &rosidl_dynamic_type, &allocator, &rosidl_dynamic_data);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could not init new dynamic data object from dynamic type") +
-            rcl_get_error_string().str);
-  }
-}
-
-
-DynamicMessage::DynamicMessage(
-  DynamicSerializationSupport::SharedPtr serialization_support,
-  rosidl_dynamic_typesupport_dynamic_data_t && rosidl_dynamic_data)
-: serialization_support_(serialization_support),
-  rosidl_dynamic_data_(std::move(rosidl_dynamic_data)),
-  is_loaned_(false),
-  parent_data_(nullptr)
-{
-  if (serialization_support) {
-    if (!match_serialization_support_(*serialization_support, rosidl_dynamic_data)) {
-      throw std::runtime_error(
-              "serialization support library identifier does not match dynamic data's!");
-    }
-  }
-}
-
-
-DynamicMessage::DynamicMessage(
-  DynamicMessage::SharedPtr parent_data,
-  rosidl_dynamic_typesupport_dynamic_data_t && rosidl_loaned_data)
-: serialization_support_(parent_data->get_shared_dynamic_serialization_support()),
-  rosidl_dynamic_data_(std::move(rosidl_loaned_data)),
-  is_loaned_(true),
-  parent_data_(nullptr)
-{
-  if (!parent_data) {
-    throw std::runtime_error("parent dynamic data cannot be nullptr!");
-  }
-  if (serialization_support_) {
-    if (!match_serialization_support_(*serialization_support_, rosidl_loaned_data)) {
-      throw std::runtime_error(
-              "serialization support library identifier does not match loaned dynamic data's!");
-    }
-  }
-  parent_data_ = parent_data;
-}
-
-
-DynamicMessage::DynamicMessage(DynamicMessage && other) noexcept
-: serialization_support_(std::exchange(other.serialization_support_, nullptr)),
-  rosidl_dynamic_data_(std::exchange(
-      other.rosidl_dynamic_data_,
-      rosidl_dynamic_typesupport_get_zero_initialized_dynamic_data())),
-  is_loaned_(other.is_loaned_),
-  parent_data_(std::exchange(other.parent_data_, nullptr))
-{}
-
-
-DynamicMessage &
-DynamicMessage::operator=(DynamicMessage && other) noexcept
-{
-  std::swap(serialization_support_, other.serialization_support_);
-  std::swap(rosidl_dynamic_data_, other.rosidl_dynamic_data_);
-  is_loaned_ = other.is_loaned_;
-  std::swap(parent_data_, other.parent_data_);
-  return *this;
-}
-
-
 DynamicMessage::~DynamicMessage()
-{
-  if (!is_loaned_) {
-    if (rosidl_dynamic_typesupport_dynamic_data_fini(&get_rosidl_dynamic_data()) !=
-      RCUTILS_RET_OK)
-    {
-      RCUTILS_LOG_ERROR("could not fini rosidl dynamic data");
-    }
-    return;
-  }
-
-  // Loaned case
-  if (!parent_data_) {
-    RCUTILS_LOG_ERROR("dynamic data is loaned, but parent is missing!!");
-  } else {
-    rosidl_dynamic_typesupport_dynamic_data_return_loaned_value(
-      &parent_data_->get_rosidl_dynamic_data(), &get_rosidl_dynamic_data());
-  }
-}
-
-
-bool
-DynamicMessage::match_serialization_support_(
-  const DynamicSerializationSupport & serialization_support,
-  const rosidl_dynamic_typesupport_dynamic_data_t & rosidl_dynamic_type_data)
-{
-  if (serialization_support.get_serialization_library_identifier() != std::string(
-      rosidl_dynamic_type_data.serialization_support->serialization_library_identifier))
-  {
-    RCUTILS_LOG_ERROR("serialization support library identifier does not match dynamic data's");
-    return false;
-  }
-  return true;
-}
-
-
-// GETTERS =======================================================================================
-const std::string
-DynamicMessage::get_serialization_library_identifier() const
-{
-  return std::string(
-    get_rosidl_dynamic_data().serialization_support->serialization_library_identifier);
-}
-
-
-const std::string
-DynamicMessage::get_name() const
-{
-  size_t buf_length;
-  const char * buf;
-  if (
-    rosidl_dynamic_typesupport_dynamic_data_get_name(
-      &get_rosidl_dynamic_data(), &buf,
-      &buf_length) !=
-    RCUTILS_RET_OK)
-  {
-    throw std::runtime_error(
-            std::string("could not get name for dynamic data") + rcl_get_error_string().str);
-  }
-  return std::string(buf, buf_length);
-}
-
-
-rosidl_dynamic_typesupport_dynamic_data_t &
-DynamicMessage::get_rosidl_dynamic_data()
-{
-  return rosidl_dynamic_data_;
-}
-
-
-const rosidl_dynamic_typesupport_dynamic_data_t &
-DynamicMessage::get_rosidl_dynamic_data() const
-{
-  return rosidl_dynamic_data_;
-}
-
-
-DynamicSerializationSupport::SharedPtr
-DynamicMessage::get_shared_dynamic_serialization_support()
-{
-  return serialization_support_;
-}
-
-
-DynamicSerializationSupport::ConstSharedPtr
-DynamicMessage::get_shared_dynamic_serialization_support() const
-{
-  return serialization_support_;
-}
-
-
-size_t
-DynamicMessage::get_item_count() const
-{
-  size_t item_count;
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_get_item_count(
-    &get_rosidl_dynamic_data(), &item_count);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error("could not get item count of dynamic data");
-  }
-  return item_count;
-}
-
-
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::get_member_id(size_t index) const
-{
-  rosidl_dynamic_typesupport_member_id_t member_id;
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_get_member_id_at_index(
-    &get_rosidl_dynamic_data(), index, &member_id);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error("could not member id of dynamic data element by index");
-  }
-  return member_id;
-}
-
-
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::get_member_id(const std::string & name) const
-{
-  rosidl_dynamic_typesupport_member_id_t member_id;
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_get_member_id_by_name(
-    &get_rosidl_dynamic_data(), name.c_str(), name.size(), &member_id);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error("could not member id of dynamic data element by name");
-  }
-  return member_id;
-}
-
-
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::get_array_index(size_t index) const
-{
-  rosidl_dynamic_typesupport_member_id_t array_index;
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_get_array_index(
-    &get_rosidl_dynamic_data(), index, &array_index);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error("could not array index of dynamic data element by index");
-  }
-  return array_index;
-}
-
-
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::get_array_index(const std::string & name) const
-{
-  return get_array_index(get_member_id(name));
-}
-
-
-// METHODS =======================================================================================
-DynamicMessage
-DynamicMessage::clone(rcl_allocator_t allocator)
-{
-  rosidl_dynamic_typesupport_dynamic_data_t rosidl_dynamic_data =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_data();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_clone(
-    &get_rosidl_dynamic_data(), &allocator, &rosidl_dynamic_data);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could not clone dynamic data: ") + rcl_get_error_string().str);
-  }
-  return DynamicMessage(get_shared_dynamic_serialization_support(), std::move(rosidl_dynamic_data));
-}
-
-
-DynamicMessage::SharedPtr
-DynamicMessage::clone_shared(rcl_allocator_t allocator)
-{
-  rosidl_dynamic_typesupport_dynamic_data_t rosidl_dynamic_data =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_data();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_clone(
-    &get_rosidl_dynamic_data(), &allocator, &rosidl_dynamic_data);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could not clone dynamic data: ") + rcl_get_error_string().str);
-  }
-  return DynamicMessage::make_shared(
-    get_shared_dynamic_serialization_support(), std::move(rosidl_dynamic_data));
-}
-
-
-DynamicMessage
-DynamicMessage::init_from_type(DynamicMessageType & type, rcl_allocator_t allocator) const
-{
-  rosidl_dynamic_typesupport_dynamic_data_t rosidl_dynamic_data =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_data();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_init_from_dynamic_type(
-    &type.get_rosidl_dynamic_type(), &allocator, &rosidl_dynamic_data);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error("could not init new dynamic data object from dynamic type");
-  }
-  return DynamicMessage(serialization_support_, std::move(rosidl_dynamic_data));
-}
-
-
-DynamicMessage::SharedPtr
-DynamicMessage::init_from_type_shared(DynamicMessageType & type, rcl_allocator_t allocator) const
-{
-  rosidl_dynamic_typesupport_dynamic_data_t rosidl_dynamic_data =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_data();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_init_from_dynamic_type(
-    &type.get_rosidl_dynamic_type(), &allocator, &rosidl_dynamic_data);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error("could not init new dynamic data object from dynamic type");
-  }
-  return DynamicMessage::make_shared(serialization_support_, std::move(rosidl_dynamic_data));
-}
-
-
-bool
-DynamicMessage::equals(const DynamicMessage & other) const
-{
-  if (get_serialization_library_identifier() != other.get_serialization_library_identifier()) {
-    throw std::runtime_error("library identifiers don't match");
-  }
-  bool equals;
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_equals(
-    &get_rosidl_dynamic_data(), &other.get_rosidl_dynamic_data(), &equals);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error("could not equate dynamic messages");
-  }
-  return equals;
-}
-
-
-DynamicMessage::SharedPtr
-DynamicMessage::loan_value(
-  rosidl_dynamic_typesupport_member_id_t id,
-  rcl_allocator_t allocator)
-{
-  rosidl_dynamic_typesupport_dynamic_data_t rosidl_dynamic_data =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_data();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_loan_value(
-    &get_rosidl_dynamic_data(), id, &allocator, &rosidl_dynamic_data);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could not loan dynamic data: ") + rcl_get_error_string().str);
-  }
-  return DynamicMessage::make_shared(shared_from_this(), std::move(rosidl_dynamic_data));
-}
-
-
-DynamicMessage::SharedPtr
-DynamicMessage::loan_value(const std::string & name, rcl_allocator_t allocator)
-{
-  return loan_value(get_member_id(name), allocator);
-}
-
-
-void
-DynamicMessage::clear_all_values()
-{
-  rosidl_dynamic_typesupport_dynamic_data_clear_all_values(&get_rosidl_dynamic_data());
-}
-
-
-void
-DynamicMessage::clear_nonkey_values()
-{
-  rosidl_dynamic_typesupport_dynamic_data_clear_nonkey_values(&get_rosidl_dynamic_data());
-}
-
-
-void
-DynamicMessage::clear_value(rosidl_dynamic_typesupport_member_id_t id)
-{
-  rosidl_dynamic_typesupport_dynamic_data_clear_value(&get_rosidl_dynamic_data(), id);
-}
-
-
-void
-DynamicMessage::clear_value(const std::string & name)
-{
-  clear_value(get_member_id(name));
-}
-
-
-void
-DynamicMessage::clear_sequence()
-{
-  rosidl_dynamic_typesupport_dynamic_data_clear_sequence_data(&get_rosidl_dynamic_data());
-}
-
-
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::insert_sequence_data()
-{
-  rosidl_dynamic_typesupport_member_id_t out;
-  rosidl_dynamic_typesupport_dynamic_data_insert_sequence_data(&get_rosidl_dynamic_data(), &out);
-  return out;
-}
-
-
-void
-DynamicMessage::remove_sequence_data(rosidl_dynamic_typesupport_member_id_t index)
-{
-  rosidl_dynamic_typesupport_dynamic_data_remove_sequence_data(
-    &get_rosidl_dynamic_data(), index);
-}
-
-
-bool
-DynamicMessage::serialize(rcl_serialized_message_t & buffer)
-{
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_serialize(
-    &get_rosidl_dynamic_data(), &buffer);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could serialize loan dynamic data: ") + rcl_get_error_string().str);
-  }
-  return true;
-}
-
-
-bool
-DynamicMessage::deserialize(rcl_serialized_message_t & buffer)
-{
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_data_deserialize(
-    &get_rosidl_dynamic_data(), &buffer);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could deserialize loan dynamic data: ") + rcl_get_error_string().str);
-  }
-  return true;
-}
-
-
-// MEMBER ACCESS ===================================================================================
-// Defined in "detail/dynamic_message_impl.hpp"
-
-
-// FIXED STRING MEMBER ACCESS ======================================================================
-const std::string
-DynamicMessage::get_fixed_string_value(
-  rosidl_dynamic_typesupport_member_id_t id, size_t string_length)
-{
-  size_t buf_length;
-  char * buf = nullptr;
-  rosidl_dynamic_typesupport_dynamic_data_get_fixed_string_value(
-    &get_rosidl_dynamic_data(), id, &buf, &buf_length, string_length);
-  auto out = std::string(buf, buf_length);
-  delete buf;
-  return out;
-}
-
-
-const std::string
-DynamicMessage::get_fixed_string_value(const std::string & name, size_t string_length)
-{
-  return get_fixed_string_value(get_member_id(name), string_length);
-}
-
-
-const std::u16string
-DynamicMessage::get_fixed_wstring_value(
-  rosidl_dynamic_typesupport_member_id_t id, size_t wstring_length)
-{
-  size_t buf_length;
-  char16_t * buf = nullptr;
-  rosidl_dynamic_typesupport_dynamic_data_get_fixed_wstring_value(
-    &get_rosidl_dynamic_data(), id, &buf, &buf_length, wstring_length);
-  auto out = std::u16string(buf, buf_length);
-  delete buf;
-  return out;
-}
-
-
-const std::u16string
-DynamicMessage::get_fixed_wstring_value(const std::string & name, size_t wstring_length)
-{
-  return get_fixed_wstring_value(get_member_id(name), wstring_length);
-}
-
-
-void
-DynamicMessage::set_fixed_string_value(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string value, size_t string_length)
-{
-  rosidl_dynamic_typesupport_dynamic_data_set_fixed_string_value(
-    &get_rosidl_dynamic_data(), id, value.c_str(), value.size(), string_length);
-}
-
-
-void
-DynamicMessage::set_fixed_string_value(
-  const std::string & name, const std::string value, size_t string_length)
-{
-  set_fixed_string_value(get_member_id(name), value, string_length);
-}
-
-
-void
-DynamicMessage::set_fixed_wstring_value(
-  rosidl_dynamic_typesupport_member_id_t id, const std::u16string value, size_t wstring_length)
-{
-  rosidl_dynamic_typesupport_dynamic_data_set_fixed_wstring_value(
-    &get_rosidl_dynamic_data(), id, value.c_str(), value.size(), wstring_length);
-}
-
-
-void
-DynamicMessage::set_fixed_wstring_value(
-  const std::string & name, const std::u16string value, size_t wstring_length)
-{
-  set_fixed_wstring_value(get_member_id(name), value, wstring_length);
-}
-
-
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::insert_fixed_string_value(const std::string value, size_t string_length)
-{
-  rosidl_dynamic_typesupport_member_id_t out;
-  rosidl_dynamic_typesupport_dynamic_data_insert_fixed_string_value(
-    &get_rosidl_dynamic_data(), value.c_str(), value.size(), string_length, &out);
-  return out;
-}
-
-
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::insert_fixed_wstring_value(const std::u16string value, size_t wstring_length)
-{
-  rosidl_dynamic_typesupport_member_id_t out;
-  rosidl_dynamic_typesupport_dynamic_data_insert_fixed_wstring_value(
-    &get_rosidl_dynamic_data(), value.c_str(), value.size(), wstring_length, &out);
-  return out;
-}
-
-
-// BOUNDED STRING MEMBER ACCESS ====================================================================
-const std::string
-DynamicMessage::get_bounded_string_value(
-  rosidl_dynamic_typesupport_member_id_t id, size_t string_bound)
-{
-  size_t buf_length;
-  char * buf = nullptr;
-  rosidl_dynamic_typesupport_dynamic_data_get_bounded_string_value(
-    &get_rosidl_dynamic_data(), id, &buf, &buf_length, string_bound);
-  auto out = std::string(buf, buf_length);
-  delete buf;
-  return out;
-}
-
-
-const std::string
-DynamicMessage::get_bounded_string_value(const std::string & name, size_t string_bound)
-{
-  return get_bounded_string_value(get_member_id(name), string_bound);
-}
-
-
-const std::u16string
-DynamicMessage::get_bounded_wstring_value(
-  rosidl_dynamic_typesupport_member_id_t id, size_t wstring_bound)
-{
-  size_t buf_length;
-  char16_t * buf = nullptr;
-  rosidl_dynamic_typesupport_dynamic_data_get_bounded_wstring_value(
-    &get_rosidl_dynamic_data(), id, &buf, &buf_length, wstring_bound);
-  auto out = std::u16string(buf, buf_length);
-  delete buf;
-  return out;
-}
-
-
-const std::u16string
-DynamicMessage::get_bounded_wstring_value(const std::string & name, size_t wstring_bound)
-{
-  return get_bounded_wstring_value(get_member_id(name), wstring_bound);
-}
-
-
-void
-DynamicMessage::set_bounded_string_value(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string value, size_t string_bound)
-{
-  rosidl_dynamic_typesupport_dynamic_data_set_bounded_string_value(
-    &get_rosidl_dynamic_data(), id, value.c_str(), value.size(), string_bound);
-}
-
-
-void
-DynamicMessage::set_bounded_string_value(
-  const std::string & name, const std::string value, size_t string_bound)
-{
-  set_bounded_string_value(get_member_id(name), value, string_bound);
-}
-
-
-void
-DynamicMessage::set_bounded_wstring_value(
-  rosidl_dynamic_typesupport_member_id_t id, const std::u16string value, size_t wstring_bound)
-{
-  rosidl_dynamic_typesupport_dynamic_data_set_bounded_wstring_value(
-    &get_rosidl_dynamic_data(), id, value.c_str(), value.size(), wstring_bound);
-}
-
-
-void
-DynamicMessage::set_bounded_wstring_value(
-  const std::string & name, const std::u16string value, size_t wstring_bound)
-{
-  set_bounded_wstring_value(get_member_id(name), value, wstring_bound);
-}
-
-
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::insert_bounded_string_value(const std::string value, size_t string_bound)
-{
-  rosidl_dynamic_typesupport_member_id_t out;
-  rosidl_dynamic_typesupport_dynamic_data_insert_bounded_string_value(
-    &get_rosidl_dynamic_data(), value.c_str(), value.size(), string_bound, &out);
-  return out;
-}
-
-
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::insert_bounded_wstring_value(const std::u16string value, size_t wstring_bound)
-{
-  rosidl_dynamic_typesupport_member_id_t out;
-  rosidl_dynamic_typesupport_dynamic_data_insert_bounded_wstring_value(
-    &get_rosidl_dynamic_data(), value.c_str(), value.size(), wstring_bound, &out);
-  return out;
-}
-
-
-// NESTED MEMBER ACCESS ============================================================================
-DynamicMessage
-DynamicMessage::get_nested_data(
-  rosidl_dynamic_typesupport_member_id_t id, rcl_allocator_t allocator)
-{
-  rosidl_dynamic_typesupport_dynamic_data_t out =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_data();
-  rosidl_dynamic_typesupport_dynamic_data_get_nested_data(
-    &get_rosidl_dynamic_data(), id, &allocator, &out);
-  return DynamicMessage(get_shared_dynamic_serialization_support(), std::move(out));
-}
-
-
-DynamicMessage
-DynamicMessage::get_nested_data(const std::string & name, rcl_allocator_t allocator)
-{
-  return get_nested_data(get_member_id(name), allocator);
-}
-
-
-DynamicMessage::SharedPtr
-DynamicMessage::get_nested_data_shared(
-  rosidl_dynamic_typesupport_member_id_t id, rcl_allocator_t allocator)
-{
-  rosidl_dynamic_typesupport_dynamic_data_t out =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_data();
-  rosidl_dynamic_typesupport_dynamic_data_get_nested_data(
-    &get_rosidl_dynamic_data(), id, &allocator, &out);
-  return DynamicMessage::make_shared(get_shared_dynamic_serialization_support(), std::move(out));
-}
-
-
-DynamicMessage::SharedPtr
-DynamicMessage::get_nested_data_shared(const std::string & name, rcl_allocator_t allocator)
-{
-  return get_nested_data_shared(get_member_id(name), allocator);
-}
-
-
-void
-DynamicMessage::set_nested_data(
-  rosidl_dynamic_typesupport_member_id_t id, DynamicMessage & value)
-{
-  rosidl_dynamic_typesupport_dynamic_data_set_nested_data(
-    &get_rosidl_dynamic_data(), id, &value.get_rosidl_dynamic_data());
-}
-
-
-void
-DynamicMessage::set_nested_data(const std::string & name, DynamicMessage & value)
-{
-  set_nested_data(get_member_id(name), value);
-}
-
-
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::insert_nested_data_copy(const DynamicMessage & value)
-{
-  rosidl_dynamic_typesupport_member_id_t out;
-  rosidl_dynamic_typesupport_dynamic_data_insert_nested_data_copy(
-    &get_rosidl_dynamic_data(), &value.get_rosidl_dynamic_data(), &out);
-  return out;
-}
-
-
-rosidl_dynamic_typesupport_member_id_t
-DynamicMessage::insert_nested_data(DynamicMessage & value)
-{
-  rosidl_dynamic_typesupport_member_id_t out;
-  rosidl_dynamic_typesupport_dynamic_data_insert_nested_data(
-    &get_rosidl_dynamic_data(), &value.get_rosidl_dynamic_data(), &out);
-  return out;
-}
+{}  // STUBBED

rclcpp/src/rclcpp/dynamic_typesupport/dynamic_message_type.cpp

@@ -34,248 +34,5 @@ using rclcpp::dynamic_typesupport::DynamicMessageType;
 using rclcpp::dynamic_typesupport::DynamicMessageTypeBuilder;
 using rclcpp::dynamic_typesupport::DynamicSerializationSupport;
 
-
-// CONSTRUCTION ====================================================================================
-DynamicMessageType::DynamicMessageType(DynamicMessageTypeBuilder::SharedPtr dynamic_type_builder)
-: DynamicMessageType::DynamicMessageType(
-    dynamic_type_builder, dynamic_type_builder->get_rosidl_dynamic_type_builder().allocator) {}
-
-
-DynamicMessageType::DynamicMessageType(
-  DynamicMessageTypeBuilder::SharedPtr dynamic_type_builder,
-  rcl_allocator_t allocator)
-: serialization_support_(dynamic_type_builder->get_shared_dynamic_serialization_support()),
-  rosidl_dynamic_type_(rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type())
-{
-  if (!serialization_support_) {
-    throw std::runtime_error("dynamic type could not bind serialization support!");
-  }
-
-  rosidl_dynamic_typesupport_dynamic_type_builder_t rosidl_dynamic_type_builder =
-    dynamic_type_builder->get_rosidl_dynamic_type_builder();
-
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_type_init_from_dynamic_type_builder(
-    &rosidl_dynamic_type_builder, &allocator, &get_rosidl_dynamic_type());
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error("could not init new dynamic type object");
-  }
-}
-
-
-DynamicMessageType::DynamicMessageType(
-  DynamicSerializationSupport::SharedPtr serialization_support,
-  rosidl_dynamic_typesupport_dynamic_type_t && rosidl_dynamic_type)
-: serialization_support_(serialization_support),
-  rosidl_dynamic_type_(std::move(rosidl_dynamic_type))
-{
-  if (serialization_support) {
-    if (!match_serialization_support_(*serialization_support, rosidl_dynamic_type)) {
-      throw std::runtime_error(
-              "serialization support library identifier does not match dynamic type's!");
-    }
-  }
-}
-
-
-DynamicMessageType::DynamicMessageType(
-  DynamicSerializationSupport::SharedPtr serialization_support,
-  const rosidl_runtime_c__type_description__TypeDescription & description,
-  rcl_allocator_t allocator)
-: serialization_support_(serialization_support),
-  rosidl_dynamic_type_(rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type())
-{
-  init_from_description(description, allocator, serialization_support);
-}
-
-
-DynamicMessageType::DynamicMessageType(DynamicMessageType && other) noexcept
-: serialization_support_(std::exchange(other.serialization_support_, nullptr)),
-  rosidl_dynamic_type_(std::exchange(
-      other.rosidl_dynamic_type_, rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type()))
-{}
-
-
-DynamicMessageType &
-DynamicMessageType::operator=(DynamicMessageType && other) noexcept
-{
-  std::swap(serialization_support_, other.serialization_support_);
-  std::swap(rosidl_dynamic_type_, other.rosidl_dynamic_type_);
-  return *this;
-}
-
-
 DynamicMessageType::~DynamicMessageType()
-{
-  if (rosidl_dynamic_typesupport_dynamic_type_fini(&get_rosidl_dynamic_type()) != RCUTILS_RET_OK) {
-    RCUTILS_LOG_ERROR("could not fini rosidl dynamic type");
-  }
-}
-
-
-void
-DynamicMessageType::init_from_description(
-  const rosidl_runtime_c__type_description__TypeDescription & description,
-  rcl_allocator_t allocator,
-  DynamicSerializationSupport::SharedPtr serialization_support)
-{
-  if (serialization_support) {
-    // Swap serialization support if serialization support is given
-    serialization_support_ = serialization_support;
-  }
-
-  rosidl_dynamic_typesupport_dynamic_type_t rosidl_dynamic_type =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_type_init_from_description(
-    &serialization_support_->get_rosidl_serialization_support(),
-    &description,
-    &allocator,
-    &rosidl_dynamic_type);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error("could not init new dynamic type object");
-  }
-
-  rosidl_dynamic_type_ = std::move(rosidl_dynamic_type);
-}
-
-
-bool
-DynamicMessageType::match_serialization_support_(
-  const DynamicSerializationSupport & serialization_support,
-  const rosidl_dynamic_typesupport_dynamic_type_t & rosidl_dynamic_type)
-{
-  if (serialization_support.get_serialization_library_identifier() != std::string(
-      rosidl_dynamic_type.serialization_support->serialization_library_identifier))
-  {
-    RCUTILS_LOG_ERROR(
-      "serialization support library identifier does not match dynamic type's (%s vs %s)",
-      serialization_support.get_serialization_library_identifier().c_str(),
-      rosidl_dynamic_type.serialization_support->serialization_library_identifier);
-    return false;
-  }
-  return true;
-}
-
-
-// GETTERS =========================================================================================
-const std::string
-DynamicMessageType::get_serialization_library_identifier() const
-{
-  return std::string(
-    get_rosidl_dynamic_type().serialization_support->serialization_library_identifier);
-}
-
-
-const std::string
-DynamicMessageType::get_name() const
-{
-  size_t buf_length;
-  const char * buf;
-  rosidl_dynamic_typesupport_dynamic_type_get_name(&get_rosidl_dynamic_type(), &buf, &buf_length);
-  return std::string(buf, buf_length);
-}
-
-
-size_t
-DynamicMessageType::get_member_count() const
-{
-  size_t out;
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_type_get_member_count(
-    &get_rosidl_dynamic_type(), &out);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could not get member count: ") + rcl_get_error_string().str);
-  }
-  return out;
-}
-
-
-rosidl_dynamic_typesupport_dynamic_type_t &
-DynamicMessageType::get_rosidl_dynamic_type()
-{
-  return rosidl_dynamic_type_;
-}
-
-
-const rosidl_dynamic_typesupport_dynamic_type_t &
-DynamicMessageType::get_rosidl_dynamic_type() const
-{
-  return rosidl_dynamic_type_;
-}
-
-
-DynamicSerializationSupport::SharedPtr
-DynamicMessageType::get_shared_dynamic_serialization_support()
-{
-  return serialization_support_;
-}
-
-
-DynamicSerializationSupport::ConstSharedPtr
-DynamicMessageType::get_shared_dynamic_serialization_support() const
-{
-  return serialization_support_;
-}
-
-
-// METHODS =========================================================================================
-DynamicMessageType
-DynamicMessageType::clone(rcl_allocator_t allocator)
-{
-  rosidl_dynamic_typesupport_dynamic_type_t rosidl_dynamic_type =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_type_clone(
-    &get_rosidl_dynamic_type(), &allocator, &rosidl_dynamic_type);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could not clone dynamic type: ") + rcl_get_error_string().str);
-  }
-  return DynamicMessageType(
-    get_shared_dynamic_serialization_support(), std::move(rosidl_dynamic_type));
-}
-
-
-DynamicMessageType::SharedPtr
-DynamicMessageType::clone_shared(rcl_allocator_t allocator)
-{
-  rosidl_dynamic_typesupport_dynamic_type_t rosidl_dynamic_type =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_type_clone(
-    &get_rosidl_dynamic_type(), &allocator, &rosidl_dynamic_type);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could not clone dynamic type: ") + rcl_get_error_string().str);
-  }
-  return DynamicMessageType::make_shared(
-    get_shared_dynamic_serialization_support(), std::move(rosidl_dynamic_type));
-}
-
-
-bool
-DynamicMessageType::equals(const DynamicMessageType & other) const
-{
-  if (get_serialization_library_identifier() != other.get_serialization_library_identifier()) {
-    throw std::runtime_error("library identifiers don't match");
-  }
-  bool out;
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_type_equals(
-    &get_rosidl_dynamic_type(), &other.get_rosidl_dynamic_type(), &out);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could not equate dynamic message types: ") + rcl_get_error_string().str);
-  }
-  return out;
-}
-
-
-DynamicMessage
-DynamicMessageType::build_dynamic_message(rcl_allocator_t allocator)
-{
-  return DynamicMessage(shared_from_this(), allocator);
-}
-
-
-DynamicMessage::SharedPtr
-DynamicMessageType::build_dynamic_message_shared(rcl_allocator_t allocator)
-{
-  return DynamicMessage::make_shared(shared_from_this(), allocator);
-}
+{}  // STUBBED

rclcpp/src/rclcpp/dynamic_typesupport/dynamic_message_type_builder.cpp

@@ -33,582 +33,5 @@ using rclcpp::dynamic_typesupport::DynamicMessageType;
 using rclcpp::dynamic_typesupport::DynamicMessageTypeBuilder;
 using rclcpp::dynamic_typesupport::DynamicSerializationSupport;
 
-#ifndef RCLCPP__DYNAMIC_TYPESUPPORT__DETAIL__DYNAMIC_MESSAGE_TYPE_BUILDER_IMPL_HPP_
-// Template specialization implementations
-#include "rclcpp/dynamic_typesupport/detail/dynamic_message_type_builder_impl.hpp"
-#endif
-
-// CONSTRUCTION ====================================================================================
-DynamicMessageTypeBuilder::DynamicMessageTypeBuilder(
-  DynamicSerializationSupport::SharedPtr serialization_support, const std::string & name)
-: DynamicMessageTypeBuilder::DynamicMessageTypeBuilder(
-    serialization_support,
-    name,
-    serialization_support->get_rosidl_serialization_support().allocator) {}
-
-
-DynamicMessageTypeBuilder::DynamicMessageTypeBuilder(
-  DynamicSerializationSupport::SharedPtr serialization_support,
-  const std::string & name,
-  rcl_allocator_t allocator)
-: serialization_support_(serialization_support),
-  rosidl_dynamic_type_builder_(
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type_builder())
-{
-  init_from_serialization_support_(serialization_support, name, allocator);
-}
-
-
-DynamicMessageTypeBuilder::DynamicMessageTypeBuilder(
-  DynamicSerializationSupport::SharedPtr serialization_support,
-  rosidl_dynamic_typesupport_dynamic_type_builder_t && rosidl_dynamic_type_builder)
-: serialization_support_(serialization_support),
-  rosidl_dynamic_type_builder_(
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type_builder())
-{
-  if (!serialization_support) {
-    throw std::runtime_error("serialization support cannot be nullptr!");
-  }
-  if (!match_serialization_support_(*serialization_support, rosidl_dynamic_type_builder)) {
-    throw std::runtime_error(
-            "serialization support library does not match dynamic type builder's!");
-  }
-}
-
-
-DynamicMessageTypeBuilder::DynamicMessageTypeBuilder(
-  DynamicSerializationSupport::SharedPtr serialization_support,
-  const rosidl_runtime_c__type_description__TypeDescription & description,
-  rcl_allocator_t allocator)
-: serialization_support_(serialization_support),
-  rosidl_dynamic_type_builder_(
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type_builder())
-{
-  if (!serialization_support) {
-    throw std::runtime_error("serialization support cannot be nullptr!");
-  }
-  init_from_description(description, allocator, serialization_support);
-}
-
-
-DynamicMessageTypeBuilder::DynamicMessageTypeBuilder(DynamicMessageTypeBuilder && other) noexcept
-: serialization_support_(std::exchange(other.serialization_support_, nullptr)),
-  rosidl_dynamic_type_builder_(std::exchange(
-      other.rosidl_dynamic_type_builder_,
-      rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type_builder())) {}
-
-
-DynamicMessageTypeBuilder &
-DynamicMessageTypeBuilder::operator=(DynamicMessageTypeBuilder && other) noexcept
-{
-  std::swap(serialization_support_, other.serialization_support_);
-  std::swap(rosidl_dynamic_type_builder_, other.rosidl_dynamic_type_builder_);
-  return *this;
-}
-
-
 DynamicMessageTypeBuilder::~DynamicMessageTypeBuilder()
-{
-  if (rosidl_dynamic_typesupport_dynamic_type_builder_fini(&get_rosidl_dynamic_type_builder()) !=
-    RCUTILS_RET_OK)
-  {
-    RCUTILS_LOG_ERROR("could not fini rosidl dynamic type builder");
-  }
-}
-
-
-void
-DynamicMessageTypeBuilder::init_from_description(
-  const rosidl_runtime_c__type_description__TypeDescription & description,
-  rcl_allocator_t allocator,
-  DynamicSerializationSupport::SharedPtr serialization_support)
-{
-  if (serialization_support) {
-    // Swap serialization support if serialization support is given
-    serialization_support_ = serialization_support;
-  }
-
-  rosidl_dynamic_typesupport_dynamic_type_builder_t rosidl_dynamic_type_builder =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type_builder();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_type_builder_init_from_description(
-    &serialization_support_->get_rosidl_serialization_support(),
-    &description,
-    &allocator,
-    &rosidl_dynamic_type_builder);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error("could not init new dynamic type builder object");
-  }
-
-  rosidl_dynamic_type_builder_ = std::move(rosidl_dynamic_type_builder);
-}
-
-
-void
-DynamicMessageTypeBuilder::init_from_serialization_support_(
-  DynamicSerializationSupport::SharedPtr serialization_support,
-  const std::string & name,
-  rcl_allocator_t allocator)
-{
-  if (!serialization_support) {
-    throw std::runtime_error("serialization support cannot be nullptr!");
-  }
-  if (!&serialization_support->get_rosidl_serialization_support()) {
-    throw std::runtime_error("serialization support raw pointer cannot be nullptr!");
-  }
-
-  rosidl_dynamic_typesupport_dynamic_type_builder_t rosidl_dynamic_type_builder =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type_builder();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_type_builder_init(
-    &serialization_support->get_rosidl_serialization_support(),
-    name.c_str(), name.size(),
-    &allocator,
-    &rosidl_dynamic_type_builder);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could not init dynamic type builder: ") + rcl_get_error_string().str);
-  }
-}
-
-
-bool
-DynamicMessageTypeBuilder::match_serialization_support_(
-  const DynamicSerializationSupport & serialization_support,
-  const rosidl_dynamic_typesupport_dynamic_type_builder_t & rosidl_dynamic_type_builder)
-{
-  if (serialization_support.get_serialization_library_identifier() != std::string(
-      rosidl_dynamic_type_builder.serialization_support->serialization_library_identifier))
-  {
-    RCUTILS_LOG_ERROR(
-      "serialization support library identifier does not match dynamic type builder's");
-    return false;
-  }
-  return true;
-}
-
-
-// GETTERS =======================================================================================
-const std::string
-DynamicMessageTypeBuilder::get_serialization_library_identifier() const
-{
-  return std::string(
-    get_rosidl_dynamic_type_builder().serialization_support->serialization_library_identifier);
-}
-
-
-const std::string
-DynamicMessageTypeBuilder::get_name() const
-{
-  size_t buf_length;
-  const char * buf;
-  rosidl_dynamic_typesupport_dynamic_type_builder_get_name(
-    &get_rosidl_dynamic_type_builder(), &buf, &buf_length);
-  return std::string(buf, buf_length);
-}
-
-
-rosidl_dynamic_typesupport_dynamic_type_builder_t &
-DynamicMessageTypeBuilder::get_rosidl_dynamic_type_builder()
-{
-  return rosidl_dynamic_type_builder_;
-}
-
-
-const rosidl_dynamic_typesupport_dynamic_type_builder_t &
-DynamicMessageTypeBuilder::get_rosidl_dynamic_type_builder() const
-{
-  return rosidl_dynamic_type_builder_;
-}
-
-
-DynamicSerializationSupport::SharedPtr
-DynamicMessageTypeBuilder::get_shared_dynamic_serialization_support()
-{
-  return serialization_support_;
-}
-
-
-DynamicSerializationSupport::ConstSharedPtr
-DynamicMessageTypeBuilder::get_shared_dynamic_serialization_support() const
-{
-  return serialization_support_;
-}
-
-
-// METHODS =======================================================================================
-void
-DynamicMessageTypeBuilder::set_name(const std::string & name)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_set_name(
-    &get_rosidl_dynamic_type_builder(), name.c_str(), name.size());
-}
-
-
-DynamicMessageTypeBuilder
-DynamicMessageTypeBuilder::clone(rcl_allocator_t allocator)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_t rosidl_dynamic_type_builder =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type_builder();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_type_builder_clone(
-    &get_rosidl_dynamic_type_builder(), &allocator, &rosidl_dynamic_type_builder);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could not clone dynamic type builder: ") + rcl_get_error_string().str);
-  }
-  return DynamicMessageTypeBuilder(
-    get_shared_dynamic_serialization_support(), std::move(rosidl_dynamic_type_builder));
-}
-
-
-DynamicMessageTypeBuilder::SharedPtr
-DynamicMessageTypeBuilder::clone_shared(rcl_allocator_t allocator)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_t rosidl_dynamic_type_builder =
-    rosidl_dynamic_typesupport_get_zero_initialized_dynamic_type_builder();
-  rcutils_ret_t ret = rosidl_dynamic_typesupport_dynamic_type_builder_clone(
-    &get_rosidl_dynamic_type_builder(), &allocator, &rosidl_dynamic_type_builder);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error(
-            std::string("could not clone dynamic type builder: ") + rcl_get_error_string().str);
-  }
-  return DynamicMessageTypeBuilder::make_shared(
-    get_shared_dynamic_serialization_support(), std::move(rosidl_dynamic_type_builder));
-}
-
-
-void
-DynamicMessageTypeBuilder::clear(rcl_allocator_t allocator)
-{
-  if (!serialization_support_) {
-    throw std::runtime_error(
-            "cannot call clear() on a dynamic type builder with uninitialized serialization support"
-    );
-  }
-
-  const std::string & name = get_name();
-  init_from_serialization_support_(serialization_support_, name, allocator);
-}
-
-
-DynamicMessage
-DynamicMessageTypeBuilder::build_dynamic_message(rcl_allocator_t allocator)
-{
-  return DynamicMessage(shared_from_this(), allocator);
-}
-
-
-DynamicMessage::SharedPtr
-DynamicMessageTypeBuilder::build_dynamic_message_shared(rcl_allocator_t allocator)
-{
-  return DynamicMessage::make_shared(shared_from_this(), allocator);
-}
-
-
-DynamicMessageType
-DynamicMessageTypeBuilder::build_dynamic_message_type(rcl_allocator_t allocator)
-{
-  return DynamicMessageType(shared_from_this(), allocator);
-}
-
-
-DynamicMessageType::SharedPtr
-DynamicMessageTypeBuilder::build_dynamic_message_type_shared(rcl_allocator_t allocator)
-{
-  return DynamicMessageType::make_shared(shared_from_this(), allocator);
-}
-
-
-// ADD MEMBERS =====================================================================================
-// Defined in "detail/dynamic_message_type_builder_impl.hpp"
-
-
-// ADD FIXED STRING MEMBERS ========================================================================
-void
-DynamicMessageTypeBuilder::add_fixed_string_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t string_length,
-  const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_fixed_string_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    string_length);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_fixed_wstring_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t wstring_length,
-  const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_fixed_wstring_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    wstring_length);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_fixed_string_array_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  size_t string_length, size_t array_length, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_fixed_string_array_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    string_length, array_length);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_fixed_wstring_array_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  size_t wstring_length, size_t array_length, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_fixed_wstring_array_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    wstring_length, array_length);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_fixed_string_unbounded_sequence_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t string_length,
-  const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_fixed_string_unbounded_sequence_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    string_length);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_fixed_wstring_unbounded_sequence_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t wstring_length,
-  const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_fixed_wstring_unbounded_sequence_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    wstring_length);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_fixed_string_bounded_sequence_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  size_t string_length, size_t sequence_bound, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_fixed_string_bounded_sequence_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    string_length, sequence_bound);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_fixed_wstring_bounded_sequence_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  size_t wstring_length, size_t sequence_bound, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_fixed_wstring_bounded_sequence_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    wstring_length, sequence_bound);
-}
-
-
-// ADD BOUNDED STRING MEMBERS ======================================================================
-void
-DynamicMessageTypeBuilder::add_bounded_string_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t string_bound,
-  const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_bounded_string_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    string_bound);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_bounded_wstring_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t wstring_bound,
-  const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_bounded_wstring_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    wstring_bound);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_bounded_string_array_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  size_t string_bound, size_t array_length, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_bounded_string_array_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    string_bound, array_length);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_bounded_wstring_array_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  size_t wstring_bound, size_t array_length, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_bounded_wstring_array_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    wstring_bound, array_length);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_bounded_string_unbounded_sequence_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t string_bound,
-  const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_bounded_string_unbounded_sequence_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    string_bound);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_bounded_wstring_unbounded_sequence_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name, size_t wstring_bound,
-  const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_bounded_wstring_unbounded_sequence_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    wstring_bound);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_bounded_string_bounded_sequence_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  size_t string_bound, size_t sequence_bound, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_bounded_string_bounded_sequence_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    string_bound, sequence_bound);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_bounded_wstring_bounded_sequence_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  size_t wstring_bound, size_t sequence_bound, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_bounded_wstring_bounded_sequence_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    wstring_bound, sequence_bound);
-}
-
-
-// ADD NESTED MEMBERS ==============================================================================
-void
-DynamicMessageTypeBuilder::add_complex_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  DynamicMessageType & nested_type, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_complex_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    &nested_type.get_rosidl_dynamic_type());
-}
-
-
-void
-DynamicMessageTypeBuilder::add_complex_array_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  DynamicMessageType & nested_type, size_t array_length, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_complex_array_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    &nested_type.get_rosidl_dynamic_type(), array_length);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_complex_unbounded_sequence_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  DynamicMessageType & nested_type, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_complex_unbounded_sequence_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    &nested_type.get_rosidl_dynamic_type());
-}
-
-
-void
-DynamicMessageTypeBuilder::add_complex_bounded_sequence_member(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  DynamicMessageType & nested_type, size_t sequence_bound, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_complex_bounded_sequence_member(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    &nested_type.get_rosidl_dynamic_type(), sequence_bound);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_complex_member_builder(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  DynamicMessageTypeBuilder & nested_type_builder, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_complex_member_builder(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    &nested_type_builder.get_rosidl_dynamic_type_builder());
-}
-
-
-void
-DynamicMessageTypeBuilder::add_complex_array_member_builder(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  DynamicMessageTypeBuilder & nested_type_builder, size_t array_length,
-  const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_complex_array_member_builder(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    &nested_type_builder.get_rosidl_dynamic_type_builder(), array_length);
-}
-
-
-void
-DynamicMessageTypeBuilder::add_complex_unbounded_sequence_member_builder(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  DynamicMessageTypeBuilder & nested_type_builder, const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_complex_unbounded_sequence_member_builder(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    &nested_type_builder.get_rosidl_dynamic_type_builder());
-}
-
-
-void
-DynamicMessageTypeBuilder::add_complex_bounded_sequence_member_builder(
-  rosidl_dynamic_typesupport_member_id_t id, const std::string & name,
-  DynamicMessageTypeBuilder & nested_type_builder, size_t sequence_bound,
-  const std::string & default_value)
-{
-  rosidl_dynamic_typesupport_dynamic_type_builder_add_complex_bounded_sequence_member_builder(
-    &get_rosidl_dynamic_type_builder(),
-    id, name.c_str(), name.size(), default_value.c_str(), default_value.size(),
-    &nested_type_builder.get_rosidl_dynamic_type_builder(), sequence_bound);
-}
+{}  // STUBBED

rclcpp/src/rclcpp/dynamic_typesupport/dynamic_message_type_support.cpp

@@ -45,273 +45,5 @@ using rclcpp::dynamic_typesupport::DynamicMessageType;
 using rclcpp::dynamic_typesupport::DynamicMessageTypeSupport;
 using rclcpp::dynamic_typesupport::DynamicSerializationSupport;
 
-// CONSTRUCTION ====================================================================================
-DynamicMessageTypeSupport::DynamicMessageTypeSupport(
-  const rosidl_runtime_c__type_description__TypeDescription & description,
-  const std::string & serialization_library_name,
-  rcl_allocator_t allocator)
-: serialization_support_(nullptr),
-  dynamic_message_type_(nullptr),
-  dynamic_message_(nullptr),
-  rosidl_message_type_support_(rosidl_get_zero_initialized_message_type_support_handle())
-{
-  rcl_ret_t ret;
-  if (serialization_library_name.empty()) {
-    ret = rcl_dynamic_message_type_support_handle_init(
-      nullptr, &description, &allocator, &rosidl_message_type_support_);
-  } else {
-    ret = rcl_dynamic_message_type_support_handle_init(
-      serialization_library_name.c_str(), &description, &allocator, &rosidl_message_type_support_);
-  }
-  if (ret != RCL_RET_OK) {
-    std::string error_msg =
-      std::string("error initializing rosidl message type support: ") + rcl_get_error_string().str;
-    rcl_reset_error();
-    throw std::runtime_error(error_msg);
-  }
-  if (rosidl_message_type_support_.typesupport_identifier !=
-    rosidl_get_dynamic_typesupport_identifier())
-  {
-    throw std::runtime_error("rosidl message type support is of the wrong type");
-  }
-
-  auto ts_impl = static_cast<rosidl_dynamic_message_type_support_impl_t *>(const_cast<void *>(
-      rosidl_message_type_support_.data));
-
-  serialization_support_ = DynamicSerializationSupport::make_shared(
-    std::move(ts_impl->serialization_support));
-
-  dynamic_message_type_ = DynamicMessageType::make_shared(
-    get_shared_dynamic_serialization_support(), std::move(*ts_impl->dynamic_message_type));
-
-  dynamic_message_ = DynamicMessage::make_shared(
-    get_shared_dynamic_serialization_support(), std::move(*ts_impl->dynamic_message));
-}
-
-DynamicMessageTypeSupport::DynamicMessageTypeSupport(
-  DynamicSerializationSupport::SharedPtr serialization_support,
-  const rosidl_runtime_c__type_description__TypeDescription & description,
-  rcl_allocator_t allocator)
-: serialization_support_(serialization_support),
-  dynamic_message_type_(nullptr),
-  dynamic_message_(nullptr),
-  rosidl_message_type_support_(rosidl_get_zero_initialized_message_type_support_handle())
-{
-  // Check null
-  if (!serialization_support) {
-    throw std::runtime_error("serialization_support cannot be nullptr.");
-  }
-
-  rosidl_type_hash_t type_hash;
-  rcutils_ret_t hash_ret = rcl_calculate_type_hash(
-    // TODO(methylDragon): Swap this out with the conversion function when it is ready
-    reinterpret_cast<const type_description_interfaces__msg__TypeDescription *>(&description),
-    &type_hash);
-  if (hash_ret != RCL_RET_OK) {
-    throw std::runtime_error("failed to get type hash");
-  }
-
-  rcutils_ret_t ret = rosidl_dynamic_message_type_support_handle_init(
-    &serialization_support->get_rosidl_serialization_support(),
-    &type_hash,       // type_hash
-    &description,     // type_description
-    nullptr,          // type_description_sources (not implemented for dynamic types)
-    &allocator,
-    &rosidl_message_type_support_);
-  if (ret != RCUTILS_RET_OK) {
-    throw std::runtime_error("could not init rosidl message type support");
-  }
-  if (rosidl_message_type_support_.typesupport_identifier !=
-    rosidl_get_dynamic_typesupport_identifier())
-  {
-    throw std::runtime_error("rosidl message type support is of the wrong type");
-  }
-
-  auto ts_impl = static_cast<const rosidl_dynamic_message_type_support_impl_t *>(
-    rosidl_message_type_support_.data);
-
-  dynamic_message_type_ = DynamicMessageType::make_shared(
-    get_shared_dynamic_serialization_support(), std::move(*ts_impl->dynamic_message_type));
-
-  dynamic_message_ = DynamicMessage::make_shared(
-    get_shared_dynamic_serialization_support(), std::move(*ts_impl->dynamic_message));
-}
-
-DynamicMessageTypeSupport::DynamicMessageTypeSupport(
-  DynamicSerializationSupport::SharedPtr serialization_support,
-  DynamicMessageType::SharedPtr dynamic_message_type,
-  DynamicMessage::SharedPtr dynamic_message,
-  const rosidl_runtime_c__type_description__TypeDescription & description,
-  rcl_allocator_t allocator)
-: serialization_support_(serialization_support),
-  dynamic_message_type_(dynamic_message_type),
-  dynamic_message_(dynamic_message),
-  rosidl_message_type_support_(rosidl_get_zero_initialized_message_type_support_handle())
-{
-  // Check null
-  if (!serialization_support) {
-    throw std::runtime_error("serialization_support cannot be nullptr.");
-  }
-  if (!dynamic_message_type) {
-    throw std::runtime_error("dynamic_message_type cannot be nullptr.");
-  }
-  if (!dynamic_message) {
-    throw std::runtime_error("dynamic_message cannot be nullptr.");
-  }
-
-  // Check identifiers
-  if (serialization_support->get_serialization_library_identifier() !=
-    dynamic_message_type->get_serialization_library_identifier())
-  {
-    throw std::runtime_error(
-            "serialization support library identifier does not match "
-            "dynamic message type library identifier.");
-  }
-  if (dynamic_message_type->get_serialization_library_identifier() !=
-    dynamic_message->get_serialization_library_identifier())
-  {
-    throw std::runtime_error(
-            "dynamic message type library identifier does not match "
-            "dynamic message library identifier.");
-  }
-
-  rosidl_type_hash_t type_hash;
-  rcutils_ret_t hash_ret = rcl_calculate_type_hash(
-    // TODO(methylDragon): Swap this out with the conversion function when it is ready
-    //   from https://github.com/ros2/rcl/pull/1052
-    reinterpret_cast<const type_description_interfaces__msg__TypeDescription *>(&description),
-    &type_hash);
-  if (hash_ret != RCL_RET_OK) {
-    std::string error_msg = std::string("failed to get type hash: ") + rcl_get_error_string().str;
-    rcl_reset_error();
-    throw std::runtime_error(error_msg);
-  }
-
-  auto ts_impl = static_cast<rosidl_dynamic_message_type_support_impl_t *>(
-    allocator.zero_allocate(1, sizeof(rosidl_dynamic_message_type_support_impl_t), allocator.state)
-  );
-  if (!ts_impl) {
-    throw std::runtime_error("could not allocate rosidl_message_type_support_t");
-  }
-
-  ts_impl->allocator = allocator;
-  ts_impl->type_hash = type_hash;
-  if (!rosidl_runtime_c__type_description__TypeDescription__copy(
-      &description, &ts_impl->type_description))
-  {
-    throw std::runtime_error("could not copy type description");
-  }
-  // ts_impl->type_description_sources  = // Not used
-
-  ts_impl->serialization_support = serialization_support->get_rosidl_serialization_support();
-  ts_impl->dynamic_message_type = &dynamic_message_type->get_rosidl_dynamic_type();
-  ts_impl->dynamic_message = &dynamic_message->get_rosidl_dynamic_data();
-
-  rosidl_message_type_support_ = {
-    rosidl_get_dynamic_typesupport_identifier(),            // typesupport_identifier
-    ts_impl,                                                // data
-    get_message_typesupport_handle_function,                // func
-    // get_type_hash_func
-    rosidl_get_dynamic_message_type_support_type_hash_function,
-    // get_type_description_func
-    rosidl_get_dynamic_message_type_support_type_description_function,
-    // get_type_description_sources_func
-    rosidl_get_dynamic_message_type_support_type_description_sources_function
-  };
-}
-
 DynamicMessageTypeSupport::~DynamicMessageTypeSupport()
-{
-  // These must go first
-  serialization_support_.reset();
-  dynamic_message_type_.reset();
-  dynamic_message_.reset();
-
-  // Early return if type support isn't populated to avoid segfaults
-  if (!rosidl_message_type_support_.data) {
-    return;
-  }
-
-  // We only partially finalize the rosidl_message_type_support->data since its pointer members are
-  // managed by their respective SharedPtr wrapper classes.
-  auto ts_impl = static_cast<rosidl_dynamic_message_type_support_impl_t *>(
-    const_cast<void *>(rosidl_message_type_support_.data)
-  );
-  rcutils_allocator_t allocator = ts_impl->allocator;
-
-  rosidl_runtime_c__type_description__TypeDescription__fini(&ts_impl->type_description);
-  rosidl_runtime_c__type_description__TypeSource__Sequence__fini(
-    &ts_impl->type_description_sources);
-  allocator.deallocate(static_cast<void *>(ts_impl), allocator.state);  // Always C allocated
-}
-
-
-// GETTERS =========================================================================================
-const std::string
-DynamicMessageTypeSupport::get_serialization_library_identifier() const
-{
-  return serialization_support_->get_serialization_library_identifier();
-}
-
-rosidl_message_type_support_t &
-DynamicMessageTypeSupport::get_rosidl_message_type_support()
-{
-  return rosidl_message_type_support_;
-}
-
-const rosidl_message_type_support_t &
-DynamicMessageTypeSupport::get_const_rosidl_message_type_support()
-{
-  return rosidl_message_type_support_;
-}
-
-const rosidl_message_type_support_t &
-DynamicMessageTypeSupport::get_const_rosidl_message_type_support() const
-{
-  return rosidl_message_type_support_;
-}
-
-const rosidl_runtime_c__type_description__TypeDescription &
-DynamicMessageTypeSupport::get_rosidl_runtime_c_type_description() const
-{
-  auto ts_impl = static_cast<const rosidl_dynamic_message_type_support_impl_t *>(
-    get_const_rosidl_message_type_support().data
-  );
-  return ts_impl->type_description;
-}
-
-DynamicSerializationSupport::SharedPtr
-DynamicMessageTypeSupport::get_shared_dynamic_serialization_support()
-{
-  return serialization_support_;
-}
-
-DynamicSerializationSupport::ConstSharedPtr
-DynamicMessageTypeSupport::get_shared_dynamic_serialization_support() const
-{
-  return serialization_support_;
-}
-
-DynamicMessageType::SharedPtr
-DynamicMessageTypeSupport::get_shared_dynamic_message_type()
-{
-  return dynamic_message_type_;
-}
-
-DynamicMessageType::ConstSharedPtr
-DynamicMessageTypeSupport::get_shared_dynamic_message_type() const
-{
-  return dynamic_message_type_;
-}
-
-DynamicMessage::SharedPtr
-DynamicMessageTypeSupport::get_shared_dynamic_message()
-{
-  return dynamic_message_;
-}
-
-DynamicMessage::ConstSharedPtr
-DynamicMessageTypeSupport::get_shared_dynamic_message() const
-{
-  return dynamic_message_;
-}
+{}  // STUBBED

rclcpp/src/rclcpp/dynamic_typesupport/dynamic_serialization_support.cpp

@@ -28,71 +28,19 @@ using rclcpp::dynamic_typesupport::DynamicSerializationSupport;
 
 // CONSTRUCTION ====================================================================================
 DynamicSerializationSupport::DynamicSerializationSupport(rcl_allocator_t allocator)
-: DynamicSerializationSupport::DynamicSerializationSupport("", allocator) {}
+: DynamicSerializationSupport::DynamicSerializationSupport("", allocator)
+{
+  throw std::runtime_error("Unimplemented");
+}
 
 DynamicSerializationSupport::DynamicSerializationSupport(
-  const std::string & serialization_library_name,
-  rcl_allocator_t allocator)
+  const std::string & /*serialization_library_name*/,
+  rcl_allocator_t /*allocator*/)
 : rosidl_serialization_support_(
     rosidl_dynamic_typesupport_get_zero_initialized_serialization_support())
 {
-  rmw_ret_t ret = RMW_RET_ERROR;
-
-  if (serialization_library_name.empty()) {
-    ret = rmw_serialization_support_init(NULL, &allocator, &rosidl_serialization_support_);
-  } else {
-    ret = rmw_serialization_support_init(
-      serialization_library_name.c_str(), &allocator, &rosidl_serialization_support_);
-  }
-  if (ret != RCL_RET_OK) {
-    std::string error_msg =
-      std::string("could not initialize new serialization support object: ") +
-      rcl_get_error_string().str;
-    rcl_reset_error();
-    throw std::runtime_error(error_msg);
-  }
-}
-
-DynamicSerializationSupport::DynamicSerializationSupport(
-  rosidl_dynamic_typesupport_serialization_support_t && rosidl_serialization_support)
-: rosidl_serialization_support_(std::move(rosidl_serialization_support)) {}
-
-DynamicSerializationSupport::DynamicSerializationSupport(
-  DynamicSerializationSupport && other) noexcept
-: rosidl_serialization_support_(std::exchange(
-      other.rosidl_serialization_support_,
-      rosidl_dynamic_typesupport_get_zero_initialized_serialization_support())) {}
-
-DynamicSerializationSupport &
-DynamicSerializationSupport::operator=(DynamicSerializationSupport && other) noexcept
-{
-  std::swap(rosidl_serialization_support_, other.rosidl_serialization_support_);
-  return *this;
+  throw std::runtime_error("Unimplemented");
 }
 
 DynamicSerializationSupport::~DynamicSerializationSupport()
-{
-  rosidl_dynamic_typesupport_serialization_support_fini(&rosidl_serialization_support_);
-}
-
-
-// GETTERS =========================================================================================
-const std::string
-DynamicSerializationSupport::get_serialization_library_identifier() const
-{
-  return std::string(
-    rosidl_dynamic_typesupport_serialization_support_get_library_identifier(
-      &rosidl_serialization_support_));
-}
-
-rosidl_dynamic_typesupport_serialization_support_t &
-DynamicSerializationSupport::get_rosidl_serialization_support()
-{
-  return rosidl_serialization_support_;
-}
-
-const rosidl_dynamic_typesupport_serialization_support_t &
-DynamicSerializationSupport::get_rosidl_serialization_support() const
-{
-  return rosidl_serialization_support_;
-}
+{}  // STUBBED

rclcpp/src/rclcpp/exceptions/exceptions.cpp

@@ -93,7 +93,9 @@ throw_from_rcl_error(
 RCLErrorBase::RCLErrorBase(rcl_ret_t ret, const rcl_error_state_t * error_state)
 : ret(ret), message(error_state->message), file(error_state->file), line(error_state->line_number),
   formatted_message(rcl_get_error_string().str)
-{}
+{
+  rcl_reset_error();
+}
 
 RCLError::RCLError(
   rcl_ret_t ret,

rclcpp/src/rclcpp/executor.cpp

@@ -66,7 +66,7 @@ Executor::Executor(const rclcpp::ExecutorOptions & options)
   notify_waitable_(std::make_shared<rclcpp::executors::ExecutorNotifyWaitable>(
       [this]() {
         this->entities_need_rebuild_.store(true);
-      })),
+      }, options.context)),
   entities_need_rebuild_(true),
   collector_(notify_waitable_),
   wait_set_({}, {}, {}, {}, {}, {}, options.context),
@@ -84,7 +84,9 @@ Executor::Executor(const rclcpp::ExecutorOptions & options)
   notify_waitable_->add_guard_condition(interrupt_guard_condition_);
   notify_waitable_->add_guard_condition(shutdown_guard_condition_);
 
-  wait_set_.add_waitable(notify_waitable_);
+  // we need to initially rebuild the collection,
+  // so that the notify_waitable_ is added
+  collect_entities();
 }
 
 Executor::~Executor()
@@ -167,10 +169,9 @@ Executor::get_automatically_added_callback_groups_from_nodes()
 void
 Executor::add_callback_group(
   rclcpp::CallbackGroup::SharedPtr group_ptr,
-  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
+  [[maybe_unused]] rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
   bool notify)
 {
-  (void) node_ptr;
   this->collector_.add_callback_group(group_ptr);
 
   try {
@@ -371,7 +372,14 @@ Executor::spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive)
   // both spin_some and spin_all wait for work at the beginning
   wait_result_.reset();
   wait_for_work(std::chrono::milliseconds(0));
-  bool just_waited = true;
+  bool entity_states_fully_polled = true;
+
+  if (entities_need_rebuild_) {
+    // if the last wait triggered a collection rebuild, we need to call
+    // wait_for_work once more, in order to do a collection rebuild and collect
+    // events from the just added entities
+    entity_states_fully_polled = false;
+  }
 
   // The logic of this while loop is as follows:
   //
@@ -393,12 +401,14 @@ Executor::spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive)
     AnyExecutable any_exec;
     if (get_next_ready_executable(any_exec)) {
       execute_any_executable(any_exec);
-      just_waited = false;
+      // during the execution some entity might got ready therefore we need
+      // to repoll the states of all entities
+      entity_states_fully_polled = false;
     } else {
       // if nothing is ready, reset the result to clear it
       wait_result_.reset();
 
-      if (just_waited) {
+      if (entity_states_fully_polled) {
         // there was no work after just waiting, always exit in this case
         // before the exhaustive condition can be checked
         break;
@@ -408,7 +418,13 @@ Executor::spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive)
         // if exhaustive, wait for work again
         // this only happens for spin_all; spin_some only waits at the start
         wait_for_work(std::chrono::milliseconds(0));
-        just_waited = true;
+        entity_states_fully_polled = true;
+        if (entities_need_rebuild_) {
+          // if the last wait triggered a collection rebuild, we need to call
+          // wait_for_work once more, in order to do a collection rebuild and
+          // collect events from the just added entities
+          entity_states_fully_polled = false;
+        }
       } else {
         break;
       }
@@ -568,6 +584,7 @@ Executor::execute_subscription(rclcpp::SubscriptionBase::SharedPtr subscription)
                 "rcl_return_loaned_message_from_subscription() failed for subscription on topic "
                 "'%s': %s",
                 subscription->get_topic_name(), rcl_get_error_string().str);
+              rcl_reset_error();
             }
             loaned_msg = nullptr;
           }
@@ -610,25 +627,10 @@ Executor::execute_subscription(rclcpp::SubscriptionBase::SharedPtr subscription)
       }
 
     // DYNAMIC SUBSCRIPTION ========================================================================
-    // If a subscription is dynamic, then it will use its serialization-specific dynamic data.
-    //
-    // Two cases:
-    // - Dynamic type subscription using dynamic type stored in its own internal type support struct
-    // - Non-dynamic type subscription with no stored dynamic type
-    //   - Subscriptions of this type must be able to lookup the local message description to
-    //     generate a dynamic type at runtime!
-    //   - TODO(methylDragon): I won't be handling this case yet
+    // Deliver dynamic message
     case rclcpp::DeliveredMessageKind::DYNAMIC_MESSAGE:
       {
-        DynamicMessage::SharedPtr dynamic_message = subscription->create_dynamic_message();
-        take_and_do_error_handling(
-          "taking a dynamic message from topic",
-          subscription->get_topic_name(),
-          // This modifies the stored dynamic data in the DynamicMessage in-place
-          [&]() {return subscription->take_dynamic_message(*dynamic_message, message_info);},
-          [&]() {subscription->handle_dynamic_message(dynamic_message, message_info);});
-        subscription->return_dynamic_message(dynamic_message);
-        break;
+        throw std::runtime_error("Unimplemented");
       }
 
     default:
@@ -744,33 +746,16 @@ Executor::wait_for_work(std::chrono::nanoseconds timeout)
   // Clear any previous wait result
   this->wait_result_.reset();
 
-  // we need to make sure that callback groups don't get out of scope
-  // during the wait. As in jazzy, they are not covered by the DynamicStorage,
-  // we explicitly hold them here as a bugfix
-  std::vector<rclcpp::CallbackGroup::SharedPtr> cbgs;
-
   {
     std::lock_guard<std::mutex> guard(mutex_);
 
     if (this->entities_need_rebuild_.exchange(false) || current_collection_.empty()) {
       this->collect_entities();
     }
-
-    auto callback_groups = this->collector_.get_all_callback_groups();
-    cbgs.resize(callback_groups.size());
-    for(const auto & w_ptr : callback_groups) {
-      auto shr_ptr = w_ptr.lock();
-      if(shr_ptr) {
-        cbgs.push_back(std::move(shr_ptr));
-      }
-    }
   }
 
   this->wait_result_.emplace(wait_set_.wait(timeout));
 
-  // drop references to the callback groups, before trying to execute anything
-  cbgs.clear();
-
   if (!this->wait_result_ || this->wait_result_->kind() == WaitResultKind::Empty) {
     RCUTILS_LOG_WARN_NAMED(
       "rclcpp",

rclcpp/src/rclcpp/executors/executor_notify_waitable.cpp

@@ -20,8 +20,11 @@ namespace rclcpp
 namespace executors
 {
 
-ExecutorNotifyWaitable::ExecutorNotifyWaitable(std::function<void(void)> on_execute_callback)
-: execute_callback_(on_execute_callback)
+ExecutorNotifyWaitable::ExecutorNotifyWaitable(
+  std::function<void(void)> on_execute_callback,
+  const rclcpp::Context::SharedPtr & context)
+: execute_callback_(on_execute_callback),
+  guard_condition_(std::make_shared<rclcpp::GuardCondition>(context))
 {
 }
 
@@ -30,6 +33,9 @@ ExecutorNotifyWaitable::ExecutorNotifyWaitable(ExecutorNotifyWaitable & other)
   std::lock_guard<std::mutex> lock(other.guard_condition_mutex_);
   this->execute_callback_ = other.execute_callback_;
   this->notify_guard_conditions_ = other.notify_guard_conditions_;
+  this->guard_condition_ = other.guard_condition_;
+  this->idxs_of_added_guard_condition_ = other.idxs_of_added_guard_condition_;
+  this->needs_processing = other.needs_processing;
 }
 
 ExecutorNotifyWaitable & ExecutorNotifyWaitable::operator=(ExecutorNotifyWaitable & other)
@@ -38,6 +44,9 @@ ExecutorNotifyWaitable & ExecutorNotifyWaitable::operator=(ExecutorNotifyWaitabl
     std::lock_guard<std::mutex> lock(other.guard_condition_mutex_);
     this->execute_callback_ = other.execute_callback_;
     this->notify_guard_conditions_ = other.notify_guard_conditions_;
+    this->guard_condition_ = other.guard_condition_;
+    this->idxs_of_added_guard_condition_ = other.idxs_of_added_guard_condition_;
+    this->needs_processing = other.needs_processing;
   }
   return *this;
 }
@@ -47,21 +56,42 @@ ExecutorNotifyWaitable::add_to_wait_set(rcl_wait_set_t & wait_set)
 {
   std::lock_guard<std::mutex> lock(guard_condition_mutex_);
 
-  // Note: no guard conditions need to be re-triggered, since the guard
-  // conditions in this class are not tracking a stateful condition, but instead
-  // only serve to interrupt the wait set when new information is available to
-  // consider.
-  for (auto weak_guard_condition : this->notify_guard_conditions_) {
-    auto guard_condition = weak_guard_condition.lock();
-    if (!guard_condition) {continue;}
+  idxs_of_added_guard_condition_.clear();
+  idxs_of_added_guard_condition_.reserve(notify_guard_conditions_.size());
 
-    rcl_guard_condition_t * cond = &guard_condition->get_rcl_guard_condition();
-    rcl_ret_t ret = rcl_wait_set_add_guard_condition(&wait_set, cond, NULL);
+  if(needs_processing) {
+    rcl_guard_condition_t * cond = &guard_condition_->get_rcl_guard_condition();
+    size_t rcl_index;
+    rcl_ret_t ret = rcl_wait_set_add_guard_condition(&wait_set, cond, &rcl_index);
 
     if (RCL_RET_OK != ret) {
       rclcpp::exceptions::throw_from_rcl_error(
         ret, "failed to add guard condition to wait set");
     }
+
+    idxs_of_added_guard_condition_.push_back(rcl_index);
+
+    // we want to directly wake up any way, not need to add the other guard conditions
+    guard_condition_->trigger();
+
+    return;
+  }
+
+  // Note: no guard conditions need to be re-triggered, since the guard
+  // conditions in this class are not tracking a stateful condition, but instead
+  // only serve to interrupt the wait set when new information is available to
+  // consider.
+  for (const auto & guard_condition : this->notify_guard_conditions_) {
+    rcl_guard_condition_t * cond = &guard_condition->get_rcl_guard_condition();
+    size_t rcl_index;
+    rcl_ret_t ret = rcl_wait_set_add_guard_condition(&wait_set, cond, &rcl_index);
+
+    if (RCL_RET_OK != ret) {
+      rclcpp::exceptions::throw_from_rcl_error(
+        ret, "failed to add guard condition to wait set");
+    }
+
+    idxs_of_added_guard_condition_.push_back(rcl_index);
   }
 }
 
@@ -71,20 +101,23 @@ ExecutorNotifyWaitable::is_ready(const rcl_wait_set_t & wait_set)
   std::lock_guard<std::mutex> lock(guard_condition_mutex_);
 
   bool any_ready = false;
-  for (size_t ii = 0; ii < wait_set.size_of_guard_conditions; ++ii) {
-    const auto * rcl_guard_condition = wait_set.guard_conditions[ii];
+  for (size_t rcl_index : idxs_of_added_guard_condition_) {
+    if(rcl_index >= wait_set.size_of_guard_conditions) {
+      throw std::runtime_error(
+            "ExecutorNotifyWaitable::is_ready: Internal error, got index out of range");
+    }
+
+    const auto * rcl_guard_condition = wait_set.guard_conditions[rcl_index];
 
     if (nullptr == rcl_guard_condition) {
       continue;
     }
-    for (const auto & weak_guard_condition : this->notify_guard_conditions_) {
-      auto guard_condition = weak_guard_condition.lock();
-      if (guard_condition && &guard_condition->get_rcl_guard_condition() == rcl_guard_condition) {
-        any_ready = true;
-        break;
-      }
-    }
+
+    any_ready = true;
+    needs_processing = true;
+    break;
   }
+
   return any_ready;
 }
 
@@ -92,6 +125,9 @@ void
 ExecutorNotifyWaitable::execute(const std::shared_ptr<void> & /*data*/)
 {
   std::lock_guard<std::mutex> lock(execute_mutex_);
+
+  needs_processing = false;
+
   this->execute_callback_();
 }
 
@@ -102,9 +138,8 @@ ExecutorNotifyWaitable::take_data()
 }
 
 std::shared_ptr<void>
-ExecutorNotifyWaitable::take_data_by_entity_id(size_t id)
+ExecutorNotifyWaitable::take_data_by_entity_id([[maybe_unused]] size_t id)
 {
-  (void) id;
   return nullptr;
 }
 
@@ -122,11 +157,7 @@ ExecutorNotifyWaitable::set_on_ready_callback(std::function<void(size_t, int)> c
   std::lock_guard<std::mutex> lock(guard_condition_mutex_);
 
   on_ready_callback_ = gc_callback;
-  for (auto weak_gc : notify_guard_conditions_) {
-    auto gc = weak_gc.lock();
-    if (!gc) {
-      continue;
-    }
+  for (const auto & gc : notify_guard_conditions_) {
     gc->set_on_trigger_callback(on_ready_callback_);
   }
 }
@@ -138,11 +169,7 @@ ExecutorNotifyWaitable::clear_on_ready_callback()
   std::lock_guard<std::mutex> lock(guard_condition_mutex_);
 
   on_ready_callback_ = nullptr;
-  for (auto weak_gc : notify_guard_conditions_) {
-    auto gc = weak_gc.lock();
-    if (!gc) {
-      continue;
-    }
+  for (const auto & gc : notify_guard_conditions_) {
     gc->set_on_trigger_callback(nullptr);
   }
 }
@@ -159,9 +186,9 @@ void
 ExecutorNotifyWaitable::add_guard_condition(rclcpp::GuardCondition::WeakPtr weak_guard_condition)
 {
   std::lock_guard<std::mutex> lock(guard_condition_mutex_);
-  auto guard_condition = weak_guard_condition.lock();
-  if (guard_condition && notify_guard_conditions_.count(weak_guard_condition) == 0) {
-    notify_guard_conditions_.insert(weak_guard_condition);
+  const auto & guard_condition = weak_guard_condition.lock();
+  if (guard_condition && notify_guard_conditions_.count(guard_condition) == 0) {
+    notify_guard_conditions_.insert(guard_condition);
     if (on_ready_callback_) {
       guard_condition->set_on_trigger_callback(on_ready_callback_);
     }
@@ -172,11 +199,17 @@ void
 ExecutorNotifyWaitable::remove_guard_condition(rclcpp::GuardCondition::WeakPtr weak_guard_condition)
 {
   std::lock_guard<std::mutex> lock(guard_condition_mutex_);
-  if (notify_guard_conditions_.count(weak_guard_condition) != 0) {
-    notify_guard_conditions_.erase(weak_guard_condition);
-    auto guard_condition = weak_guard_condition.lock();
+  const auto & guard_condition = weak_guard_condition.lock();
+  if (!guard_condition) {
+    // If the lock did not work, the guard condition can't be
+    // saved in the sets, therefore we don't need to remove it
+    return;
+  }
+  auto it = notify_guard_conditions_.find(guard_condition);
+  if (it != notify_guard_conditions_.end()) {
+    notify_guard_conditions_.erase(it);
     // If this notify waitable doesn't have an on_ready_callback, then there's nothing to unset
-    if (guard_condition && on_ready_callback_) {
+    if (on_ready_callback_) {
       guard_condition->set_on_trigger_callback(nullptr);
     }
   }
@@ -189,5 +222,12 @@ ExecutorNotifyWaitable::get_number_of_ready_guard_conditions()
   return notify_guard_conditions_.size();
 }
 
+std::vector<std::shared_ptr<rclcpp::TimerBase>>
+ExecutorNotifyWaitable::get_timers() const
+{
+  return {};
+}
+
+
 }  // namespace executors
 }  // namespace rclcpp

rclcpp/src/rclcpp/executors/multi_threaded_executor.cpp

@@ -79,9 +79,8 @@ MultiThreadedExecutor::get_number_of_threads()
 }
 
 void
-MultiThreadedExecutor::run(size_t this_thread_number)
+MultiThreadedExecutor::run([[maybe_unused]] size_t this_thread_number)
 {
-  (void)this_thread_number;
   while (rclcpp::ok(this->context_) && spinning.load()) {
     rclcpp::AnyExecutable any_exec;
     {

rclcpp/src/rclcpp/experimental/executors/events_executor/events_executor.cpp

@@ -318,10 +318,8 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
 }
 
 void
-EventsExecutor::handle_updated_entities(bool notify)
+EventsExecutor::handle_updated_entities([[maybe_unused]] bool notify)
 {
-  (void)notify;
-
   // Do not rebuild if we don't need to.
   // A rebuild event could be generated, but then
   // this function could end up being called from somewhere else
@@ -408,8 +406,16 @@ EventsExecutor::refresh_current_collection(
     [this](auto waitable) {
       waitable->set_on_ready_callback(
         this->create_waitable_callback(waitable.get()));
+      for (const auto & t : waitable->get_timers()) {
+        timers_manager_->add_timer(t);
+      }
     },
-    [](auto waitable) {waitable->clear_on_ready_callback();});
+    [this](auto waitable) {
+      waitable->clear_on_ready_callback();
+      for (const auto & t : waitable->get_timers()) {
+        timers_manager_->remove_timer(t);
+      }
+    });
 }
 
 std::function<void(size_t)>

rclcpp/src/rclcpp/generic_subscription.cpp

@@ -46,7 +46,8 @@ GenericSubscription::handle_message(
           "handle_message is not implemented for GenericSubscription");
 }
 
-void GenericSubscription::handle_serialized_message(
+void
+GenericSubscription::handle_serialized_message(
   const std::shared_ptr<rclcpp::SerializedMessage> & message,
   const rclcpp::MessageInfo & message_info)
 {
@@ -55,10 +56,9 @@ void GenericSubscription::handle_serialized_message(
 
 void
 GenericSubscription::handle_loaned_message(
-  void * message, const rclcpp::MessageInfo & message_info)
+  [[maybe_unused]] void * message,
+  [[maybe_unused]] const rclcpp::MessageInfo & message_info)
 {
-  (void) message;
-  (void) message_info;
   throw rclcpp::exceptions::UnimplementedError(
           "handle_loaned_message is not implemented for GenericSubscription");
 }
@@ -110,20 +110,17 @@ GenericSubscription::create_dynamic_message()
 
 void
 GenericSubscription::return_dynamic_message(
-  rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message)
+  [[maybe_unused]] rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message)
 {
-  (void) message;
   throw rclcpp::exceptions::UnimplementedError(
           "return_dynamic_message is not implemented for GenericSubscription");
 }
 
 void
 GenericSubscription::handle_dynamic_message(
-  const rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message,
-  const rclcpp::MessageInfo & message_info)
+  [[maybe_unused]] const rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message,
+  [[maybe_unused]] const rclcpp::MessageInfo & message_info)
 {
-  (void) message;
-  (void) message_info;
   throw rclcpp::exceptions::UnimplementedError(
           "handle_dynamic_message is not implemented for GenericSubscription");
 }

rclcpp/src/rclcpp/logger.cpp

@@ -55,34 +55,6 @@ get_node_logger(const rcl_node_t * node)
   return rclcpp::get_logger(logger_name);
 }
 
-// TODO(ahcorde): Remove deprecated class on the next release (in Rolling after Kilted).
-#if !defined(_WIN32)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#else  // !defined(_WIN32)
-# pragma warning(push)
-# pragma warning(disable: 4996)
-#endif
-rcpputils::fs::path
-get_logging_directory()
-{
-  char * log_dir = NULL;
-  auto allocator = rcutils_get_default_allocator();
-  rcl_logging_ret_t ret = rcl_logging_get_logging_directory(allocator, &log_dir);
-  if (RCL_LOGGING_RET_OK != ret) {
-    rclcpp::exceptions::throw_from_rcl_error(ret);
-  }
-  std::string path{log_dir};
-  allocator.deallocate(log_dir, allocator.state);
-  return path;
-}
-// remove warning suppression
-#if !defined(_WIN32)
-# pragma GCC diagnostic pop
-#else  // !defined(_WIN32)
-# pragma warning(pop)
-#endif
-
 std::filesystem::path
 get_log_directory()
 {

rclcpp/src/rclcpp/node.cpp

@@ -689,7 +689,7 @@ Node::create_generic_client(
     node_base_,
     node_graph_,
     node_services_,
-    service_name,
+    extend_name_with_sub_namespace(service_name, this->get_sub_namespace()),
     service_type,
     qos,
     group);

rclcpp/src/rclcpp/node_interfaces/node_base.cpp

@@ -132,6 +132,7 @@ NodeBase::NodeBase(
             RCUTILS_LOG_ERROR_NAMED(
               "rclcpp",
               "Error in destruction of rosout publisher: %s", rcl_get_error_string().str);
+            rcl_reset_error();
           }
         }
       }
@@ -139,6 +140,7 @@ NodeBase::NodeBase(
         RCUTILS_LOG_ERROR_NAMED(
           "rclcpp",
           "Error in destruction of rcl node handle: %s", rcl_get_error_string().str);
+        rcl_reset_error();
       }
       delete node;
     });

rclcpp/src/rclcpp/node_interfaces/node_parameters.cpp

@@ -192,6 +192,65 @@ format_range_reason(const std::string & name, const char * range_type)
   return ss.str();
 }
 
+RCLCPP_LOCAL
+rcl_interfaces::msg::SetParametersResult
+__check_integer_range(
+  const rcl_interfaces::msg::ParameterDescriptor & descriptor,
+  const int64_t value)
+{
+  rcl_interfaces::msg::SetParametersResult result;
+  result.successful = true;
+  auto integer_range = descriptor.integer_range.at(0);
+  if (value == integer_range.from_value || value == integer_range.to_value) {
+    return result;
+  }
+  if ((value < integer_range.from_value) || (value > integer_range.to_value)) {
+    result.successful = false;
+    result.reason = format_range_reason(descriptor.name, "integer");
+    return result;
+  }
+  if (integer_range.step == 0) {
+    return result;
+  }
+  if (((value - integer_range.from_value) % integer_range.step) == 0) {
+    return result;
+  }
+  result.successful = false;
+  result.reason = format_range_reason(descriptor.name, "integer");
+  return result;
+}
+
+RCLCPP_LOCAL
+rcl_interfaces::msg::SetParametersResult
+__check_double_range(
+  const rcl_interfaces::msg::ParameterDescriptor & descriptor,
+  const double value)
+{
+  rcl_interfaces::msg::SetParametersResult result;
+  result.successful = true;
+  auto fp_range = descriptor.floating_point_range.at(0);
+  if (__are_doubles_equal(value, fp_range.from_value) || __are_doubles_equal(value,
+    fp_range.to_value))
+  {
+    return result;
+  }
+  if ((value < fp_range.from_value) || (value > fp_range.to_value)) {
+    result.successful = false;
+    result.reason = format_range_reason(descriptor.name, "floating point");
+    return result;
+  }
+  if (fp_range.step == 0.0) {
+    return result;
+  }
+  double rounded_div = std::round((value - fp_range.from_value) / fp_range.step);
+  if (__are_doubles_equal(value, fp_range.from_value + rounded_div * fp_range.step)) {
+    return result;
+  }
+  result.successful = false;
+  result.reason = format_range_reason(descriptor.name, "floating point");
+  return result;
+}
+
 RCLCPP_LOCAL
 rcl_interfaces::msg::SetParametersResult
 __check_parameter_value_in_range(
@@ -201,49 +260,39 @@ __check_parameter_value_in_range(
   rcl_interfaces::msg::SetParametersResult result;
   result.successful = true;
   if (!descriptor.integer_range.empty() && value.get_type() == rclcpp::PARAMETER_INTEGER) {
-    int64_t v = value.get<int64_t>();
-    auto integer_range = descriptor.integer_range.at(0);
-    if (v == integer_range.from_value || v == integer_range.to_value) {
-      return result;
+    result = __check_integer_range(descriptor, value.get<int64_t>());
+    return result;
+  }
+
+  if (!descriptor.integer_range.empty() && value.get_type() == rclcpp::PARAMETER_INTEGER_ARRAY) {
+    std::vector<int64_t> val_array = value.get<std::vector<int64_t>>();
+    for (const int64_t & val : val_array) {
+      result = __check_integer_range(descriptor, val);
+      if (!result.successful) {
+        return result;
+      }
     }
-    if ((v < integer_range.from_value) || (v > integer_range.to_value)) {
-      result.successful = false;
-      result.reason = format_range_reason(descriptor.name, "integer");
-      return result;
-    }
-    if (integer_range.step == 0) {
-      return result;
-    }
-    if (((v - integer_range.from_value) % integer_range.step) == 0) {
-      return result;
-    }
-    result.successful = false;
-    result.reason = format_range_reason(descriptor.name, "integer");
     return result;
   }
 
   if (!descriptor.floating_point_range.empty() && value.get_type() == rclcpp::PARAMETER_DOUBLE) {
-    double v = value.get<double>();
-    auto fp_range = descriptor.floating_point_range.at(0);
-    if (__are_doubles_equal(v, fp_range.from_value) || __are_doubles_equal(v, fp_range.to_value)) {
-      return result;
-    }
-    if ((v < fp_range.from_value) || (v > fp_range.to_value)) {
-      result.successful = false;
-      result.reason = format_range_reason(descriptor.name, "floating point");
-      return result;
-    }
-    if (fp_range.step == 0.0) {
-      return result;
-    }
-    double rounded_div = std::round((v - fp_range.from_value) / fp_range.step);
-    if (__are_doubles_equal(v, fp_range.from_value + rounded_div * fp_range.step)) {
-      return result;
-    }
-    result.successful = false;
-    result.reason = format_range_reason(descriptor.name, "floating point");
+    result = __check_double_range(descriptor, value.get<double>());
     return result;
   }
+
+  if (!descriptor.floating_point_range.empty() &&
+    value.get_type() == rclcpp::PARAMETER_DOUBLE_ARRAY)
+  {
+    std::vector<double> val_array = value.get<std::vector<double>>();
+    for (const double & val : val_array) {
+      result = __check_double_range(descriptor, val);
+      if (!result.successful) {
+        return result;
+      }
+    }
+    return result;
+  }
+
   return result;
 }
 
@@ -1191,3 +1240,10 @@ NodeParameters::get_parameter_overrides() const
 {
   return parameter_overrides_;
 }
+
+void
+NodeParameters::enable_parameter_modification()
+{
+  std::lock_guard<std::recursive_mutex> lock(mutex_);
+  parameter_modification_enabled_ = true;
+}

rclcpp/src/rclcpp/node_interfaces/node_type_descriptions.cpp

@@ -105,6 +105,7 @@ public:
         RCLCPP_ERROR(
           logger_, "Failed to initialize ~/get_type_description service: %s",
           rcl_get_error_string().str);
+        rcl_reset_error();
         throw std::runtime_error(
                 "Failed to initialize ~/get_type_description service.");
       }

rclcpp/src/rclcpp/parameter_events_filter.cpp

@@ -28,6 +28,9 @@ ParameterEventsFilter::ParameterEventsFilter(
   const std::vector<EventType> & types)
 : event_(event)
 {
+  if (!event) {
+    throw std::invalid_argument("event cannot be null");
+  }
   if (std::find(types.begin(), types.end(), EventType::NEW) != types.end()) {
     for (auto & new_parameter : event->new_parameters) {
       if (std::find(names.begin(), names.end(), new_parameter.name) != names.end()) {

rclcpp/src/rclcpp/publisher_base.cpp

@@ -367,10 +367,8 @@ PublisherBase::default_incompatible_qos_callback(
 
 void
 PublisherBase::default_incompatible_type_callback(
-  rclcpp::IncompatibleTypeInfo & event) const
+  [[maybe_unused]] rclcpp::IncompatibleTypeInfo & event) const
 {
-  (void)event;
-
   RCLCPP_WARN(
     rclcpp::get_logger(rcl_node_get_logger_name(rcl_node_handle_.get())),
     "Incompatible type on topic '%s', no messages will be sent to it.", get_topic_name());

rclcpp/src/rclcpp/qos.cpp

@@ -407,7 +407,7 @@ ParameterEventsQoS::ParameterEventsQoS(const QoSInitialization & qos_initializat
 {}
 
 RosoutQoS::RosoutQoS(const QoSInitialization & rosout_initialization)
-: QoS(rosout_initialization, rcl_qos_profile_rosout_default)
+: QoS(rosout_initialization, rmw_qos_profile_rosout_default)
 {}
 
 SystemDefaultsQoS::SystemDefaultsQoS(const QoSInitialization & qos_initialization)

rclcpp/src/rclcpp/serialization.cpp

@@ -36,7 +36,6 @@ SerializationBase::SerializationBase(const rosidl_message_type_support_t * type_
 void SerializationBase::serialize_message(
   const void * ros_message, SerializedMessage * serialized_message) const
 {
-  rcpputils::check_true(nullptr != type_support_, "Typesupport is nullpointer.");
   rcpputils::check_true(nullptr != ros_message, "ROS message is nullpointer.");
   rcpputils::check_true(nullptr != serialized_message, "Serialized message is nullpointer.");
 
@@ -52,7 +51,6 @@ void SerializationBase::serialize_message(
 void SerializationBase::deserialize_message(
   const SerializedMessage * serialized_message, void * ros_message) const
 {
-  rcpputils::check_true(nullptr != type_support_, "Typesupport is nullpointer.");
   rcpputils::check_true(nullptr != serialized_message, "Serialized message is nullpointer.");
   rcpputils::check_true(
     0u != serialized_message->capacity(),

rclcpp/src/rclcpp/serialized_message.cpp

@@ -122,6 +122,7 @@ SerializedMessage::~SerializedMessage()
       RCLCPP_ERROR(
         get_logger("rclcpp"),
         "Failed to destroy serialized message: %s", rcl_get_error_string().str);
+      rcl_reset_error();
     }
   }
 }

rclcpp/src/rclcpp/subscription_base.cpp

@@ -381,10 +381,8 @@ SubscriptionBase::default_incompatible_qos_callback(
 
 void
 SubscriptionBase::default_incompatible_type_callback(
-  rclcpp::IncompatibleTypeInfo & event) const
+  [[maybe_unused]] rclcpp::IncompatibleTypeInfo & event) const
 {
-  (void)event;
-
   RCLCPP_WARN(
     rclcpp::get_logger(rcl_node_get_logger_name(node_handle_.get())),
     "Incompatible type on topic '%s', no messages will be sent to it.", get_topic_name());
@@ -573,30 +571,9 @@ SubscriptionBase::get_content_filter() const
 // DYNAMIC TYPE ==================================================================================
 bool
 SubscriptionBase::take_dynamic_message(
-  rclcpp::dynamic_typesupport::DynamicMessage & message_out,
-  rclcpp::MessageInfo & message_info_out)
+  rclcpp::dynamic_typesupport::DynamicMessage & /*message_out*/,
+  rclcpp::MessageInfo & /*message_info_out*/)
 {
-  if (rmw_feature_supported(RMW_MIDDLEWARE_CAN_TAKE_DYNAMIC_MESSAGE)) {
-    rcl_ret_t ret = rcl_take_dynamic_message(
-      this->get_subscription_handle().get(),
-      &message_out.get_rosidl_dynamic_data(),
-      &message_info_out.get_rmw_message_info(),
-      nullptr);
-    if (RCL_RET_SUBSCRIPTION_TAKE_FAILED == ret) {
-      return false;
-    } else if (RCL_RET_OK != ret) {
-      rclcpp::exceptions::throw_from_rcl_error(ret, "Error when taking dynamic message");
-    }
-  } else {  // Fall back to serialized conversion if direct dynamic message taking isn't supported
-    std::shared_ptr<rclcpp::SerializedMessage> serialized_msg = this->create_serialized_message();
-    if (!this->take_serialized(*serialized_msg.get(), message_info_out)) {
-      std::runtime_error("Couldn't take serialized message when attempting to take dynamic data!");
-    }
-    bool ret = message_out.deserialize(serialized_msg->get_rcl_serialized_message());
-    if (!ret) {
-      throw std::runtime_error("Couldn't convert serialized message to dynamic data!");
-    }
-    this->return_serialized_message(serialized_msg);
-  }
-  return true;
+  throw std::runtime_error("Unimplemented");
+  return false;
 }

rclcpp/src/rclcpp/time_source.cpp

@@ -276,13 +276,8 @@ public:
     on_set_parameters_callback_ = node_parameters_->add_on_set_parameters_callback(
       std::bind(&TimeSource::NodeState::on_set_parameters, this, std::placeholders::_1));
 
-
-    // TODO(tfoote) use parameters interface not subscribe to events via topic ticketed #609
-    parameter_subscription_ = rclcpp::AsyncParametersClient::on_parameter_event(
-      node_topics_,
-      [this](std::shared_ptr<const rcl_interfaces::msg::ParameterEvent> event) {
-        this->on_parameter_event(event);
-      });
+    post_set_parameters_callback_ = node_parameters_->add_post_set_parameters_callback(
+      std::bind(&TimeSource::NodeState::post_set_parameters, this, std::placeholders::_1));
   }
 
   // Detach the attached node
@@ -296,8 +291,11 @@ public:
     if (on_set_parameters_callback_) {
       node_parameters_->remove_on_set_parameters_callback(on_set_parameters_callback_.get());
     }
+    if (post_set_parameters_callback_) {
+      node_parameters_->remove_post_set_parameters_callback(post_set_parameters_callback_.get());
+    }
     on_set_parameters_callback_.reset();
-    parameter_subscription_.reset();
+    post_set_parameters_callback_.reset();
     node_base_.reset();
     node_topics_.reset();
     node_graph_.reset();
@@ -346,7 +344,6 @@ private:
   std::mutex clock_sub_lock_;
   rclcpp::CallbackGroup::SharedPtr clock_callback_group_;
   rclcpp::executors::SingleThreadedExecutor::SharedPtr clock_executor_;
-  std::promise<void> cancel_clock_executor_promise_;
 
   // The clock callback itself
   void clock_cb(std::shared_ptr<const rosgraph_msgs::msg::Clock> msg)
@@ -392,12 +389,10 @@ private:
       clock_executor_ =
         std::make_shared<rclcpp::executors::SingleThreadedExecutor>(exec_options);
       if (!clock_executor_thread_.joinable()) {
-        cancel_clock_executor_promise_ = std::promise<void>{};
         clock_executor_thread_ = std::thread(
           [this]() {
-            auto future = cancel_clock_executor_promise_.get_future();
             clock_executor_->add_callback_group(clock_callback_group_, node_base_);
-            clock_executor_->spin_until_future_complete(future);
+            clock_executor_->spin();
           }
         );
       }
@@ -429,7 +424,6 @@ private:
   {
     std::lock_guard<std::mutex> guard(clock_sub_lock_);
     if (clock_executor_thread_.joinable()) {
-      cancel_clock_executor_promise_.set_value();
       clock_executor_->cancel();
       clock_executor_thread_.join();
       clock_executor_->remove_callback_group(clock_callback_group_);
@@ -440,9 +434,9 @@ private:
   // On set Parameters callback handle
   node_interfaces::OnSetParametersCallbackHandle::SharedPtr on_set_parameters_callback_{nullptr};
 
-  // Parameter Event subscription
-  using ParamSubscriptionT = rclcpp::Subscription<rcl_interfaces::msg::ParameterEvent>;
-  std::shared_ptr<ParamSubscriptionT> parameter_subscription_;
+  // Post set Parameters callback handle
+  node_interfaces::PostSetParametersCallbackHandle::SharedPtr
+    post_set_parameters_callback_{nullptr};
 
   // Callback for parameter settings
   rcl_interfaces::msg::SetParametersResult on_set_parameters(
@@ -465,52 +459,27 @@ private:
     return result;
   }
 
-  // Callback for parameter updates
-  void on_parameter_event(std::shared_ptr<const rcl_interfaces::msg::ParameterEvent> event)
+  // Callback for post parameter updates
+  void post_set_parameters(const std::vector<rclcpp::Parameter> & parameters)
   {
-    std::lock_guard<std::mutex> guard(node_base_lock_);
-
-    if (node_base_ == nullptr) {
-      // Do nothing if node_base_ is nullptr because it means the TimeSource is now
-      // without an attached node
-      return;
-    }
-
-    // Filter out events on 'use_sim_time' parameter instances in other nodes.
-    if (event->node != node_base_->get_fully_qualified_name()) {
-      return;
-    }
-    // Filter for only 'use_sim_time' being added or changed.
-    rclcpp::ParameterEventsFilter filter(event, {"use_sim_time"},
-      {rclcpp::ParameterEventsFilter::EventType::NEW,
-        rclcpp::ParameterEventsFilter::EventType::CHANGED});
-    for (auto & it : filter.get_events()) {
-      if (it.second->value.type != ParameterType::PARAMETER_BOOL) {
-        RCLCPP_ERROR(logger_, "use_sim_time parameter cannot be set to anything but a bool");
-        continue;
+    // "use_sim_time" has been set, so just applys it to internal states
+    for (const auto & param : parameters) {
+      if (param.get_name() == "use_sim_time") {
+        if (param.as_bool()) {
+          parameter_state_ = SET_TRUE;
+          clocks_state_.enable_ros_time();
+          create_clock_sub();
+        } else {
+          parameter_state_ = SET_FALSE;
+          destroy_clock_sub();
+          clocks_state_.disable_ros_time();
+        }
       }
-      if (it.second->value.bool_value) {
-        parameter_state_ = SET_TRUE;
-        clocks_state_.enable_ros_time();
-        create_clock_sub();
-      } else {
-        parameter_state_ = SET_FALSE;
-        destroy_clock_sub();
-        clocks_state_.disable_ros_time();
-      }
-    }
-    // Handle the case that use_sim_time was deleted.
-    rclcpp::ParameterEventsFilter deleted(event, {"use_sim_time"},
-      {rclcpp::ParameterEventsFilter::EventType::DELETED});
-    for (auto & it : deleted.get_events()) {
-      (void) it;  // if there is a match it's already matched, don't bother reading it.
-      // If the parameter is deleted mark it as unset but don't change state.
-      parameter_state_ = UNSET;
     }
   }
 
   // An enum to hold the parameter state
-  enum UseSimTimeParameterState {UNSET, SET_TRUE, SET_FALSE};
+  enum UseSimTimeParameterState {SET_TRUE, SET_FALSE};
   UseSimTimeParameterState parameter_state_;
 };
 

rclcpp/src/rclcpp/typesupport_helpers.cpp

@@ -139,14 +139,6 @@ get_typesupport_library(const std::string & type, const std::string & typesuppor
   return std::make_shared<rcpputils::SharedLibrary>(library_path);
 }
 
-const rosidl_message_type_support_t * get_typesupport_handle(
-  const std::string & type,
-  const std::string & typesupport_identifier,
-  rcpputils::SharedLibrary & library)
-{
-  return get_message_typesupport_handle(type, typesupport_identifier, library);
-}
-
 const rosidl_message_type_support_t * get_message_typesupport_handle(
   const std::string & type,
   const std::string & typesupport_identifier,
@@ -177,4 +169,19 @@ const rosidl_service_type_support_t * get_service_typesupport_handle(
   ));
 }
 
+const rosidl_action_type_support_t * get_action_typesupport_handle(
+  const std::string & type,
+  const std::string & typesupport_identifier,
+  rcpputils::SharedLibrary & library)
+{
+  static const std::string typesupport_name = "action";
+  static const std::string symbol_part_name = "__get_action_type_support_handle__";
+  static const std::string middle_module_additional = "action";
+
+  return static_cast<const rosidl_action_type_support_t *>(get_typesupport_handle_impl(
+           type, typesupport_identifier, typesupport_name, symbol_part_name,
+           middle_module_additional, library
+  ));
+}
+
 }  // namespace rclcpp

rclcpp/test/msg/String.msg

@@ -1 +1 @@
-string data
+string data

rclcpp/test/rclcpp/CMakeLists.txt

@@ -57,10 +57,10 @@ ament_add_test_label(test_client mimick)
 if(TARGET test_client)
   target_link_libraries(test_client ${PROJECT_NAME} mimick ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
 endif()
-ament_add_gtest(test_clock test_clock.cpp)
-ament_add_test_label(test_clock mimick)
-if(TARGET test_clock)
-  target_link_libraries(test_clock ${PROJECT_NAME} mimick ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
+ament_add_gtest(test_clock_conditional test_clock_conditional.cpp)
+ament_add_test_label(test_clock_conditional mimick)
+if(TARGET test_clock_conditional)
+  target_link_libraries(test_clock_conditional ${PROJECT_NAME} mimick ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
 endif()
 ament_add_gtest(test_copy_all_parameter_values test_copy_all_parameter_values.cpp)
 if(TARGET test_copy_all_parameter_values)
@@ -191,7 +191,7 @@ ament_add_gtest(test_node_interfaces__node_parameters
   node_interfaces/test_node_parameters.cpp)
 ament_add_test_label(test_node_interfaces__node_parameters mimick)
 if(TARGET test_node_interfaces__node_parameters)
-  target_link_libraries(test_node_interfaces__node_parameters ${PROJECT_NAME} mimick rcpputils::rcpputils)
+  target_link_libraries(test_node_interfaces__node_parameters ${PROJECT_NAME} mimick rcpputils::rcpputils ${test_msgs_TARGETS})
 endif()
 ament_add_gtest(test_node_interfaces__node_services
   node_interfaces/test_node_services.cpp)
@@ -669,6 +669,14 @@ endif()
 function(test_on_all_rmws)
   set(rmw_implementation_env_var RMW_IMPLEMENTATION=${rmw_implementation})
 
+  # If the rmw_implementation is rmw_zenoh_cpp, run the tests with multicast discovery enabled.
+  # Note: This is a temporary change that will be reverted before we branch into Kilted.
+  if(rmw_implementation STREQUAL "rmw_zenoh_cpp")
+    list(APPEND rmw_implementation_env_var
+      ZENOH_CONFIG_OVERRIDE=scouting/multicast/enabled=true
+    )
+  endif()
+
   ament_add_gmock_test(test_qos_event
     TEST_NAME test_qos_event${target_suffix}
     ENV ${rmw_implementation_env_var}

rclcpp/test/rclcpp/executors/executor_types.hpp

@@ -61,9 +61,8 @@ class ExecutorTypeNames
 {
 public:
   template<typename T>
-  static std::string GetName(int idx)
+  static std::string GetName([[maybe_unused]] int idx)
   {
-    (void)idx;
     if (std::is_same<T, rclcpp::executors::SingleThreadedExecutor>()) {
       return "SingleThreadedExecutor";
     }

rclcpp/test/rclcpp/executors/test_events_executor.cpp

@@ -48,9 +48,8 @@ TEST_F(TestEventsExecutor, run_pub_sub)
   bool msg_received = false;
   auto subscription = node->create_subscription<test_msgs::msg::Empty>(
     "topic", rclcpp::SensorDataQoS(),
-    [&msg_received](test_msgs::msg::Empty::ConstSharedPtr msg)
+    [&msg_received]([[maybe_unused]] test_msgs::msg::Empty::ConstSharedPtr msg)
     {
-      (void)msg;
       msg_received = true;
     });
 
@@ -115,8 +114,8 @@ TEST_F(TestEventsExecutor, run_clients_servers)
   auto request = std::make_shared<test_msgs::srv::Empty::Request>();
   client->async_send_request(
     request,
-    [&response_received](rclcpp::Client<test_msgs::srv::Empty>::SharedFuture result_future) {
-      (void)result_future;
+    [&response_received]([[maybe_unused]] rclcpp::Client<test_msgs::srv::Empty>::SharedFuture
+    result_future){
       response_received = true;
     });
 
@@ -497,3 +496,122 @@ TEST_F(TestEventsExecutor, test_default_incompatible_qos_callbacks)
 
   rcutils_logging_set_output_handler(original_output_handler);
 }
+
+class TestWaitableWithTimer : public rclcpp::Waitable
+{
+  static constexpr int TimerCallbackType = 0;
+
+public:
+  explicit TestWaitableWithTimer(const rclcpp::Context::SharedPtr & context)
+  {
+    auto timer_callback = [this] () {
+        timer_ready = true;
+        if (ready_callback) {
+        // inform executor that the waitable is ready to process a timer event
+          ready_callback(1, TimerCallbackType);
+        }
+      };
+    timer =
+      std::make_shared<rclcpp::WallTimer<decltype (timer_callback)>>(std::chrono::milliseconds(10),
+      std::move(timer_callback), context);
+  }
+
+  void
+  add_to_wait_set(rcl_wait_set_t & /*wait_set*/) override {}
+
+  bool
+  is_ready(const rcl_wait_set_t & /*wait_set*/) override
+  {
+    return false;
+  }
+
+  std::shared_ptr<void>
+  take_data() override
+  {
+    return std::shared_ptr<void>(nullptr);
+  }
+
+  std::shared_ptr<void>
+  take_data_by_entity_id(size_t id) override
+  {
+    if (id != TimerCallbackType) {
+      throw std::runtime_error("Internal error, got wrong ID for take data");
+    }
+    return nullptr;
+  }
+
+  void
+  execute(const std::shared_ptr<void> &) override
+  {
+    if (timer_ready) {
+      timer_triggered_waitable_and_waitable_was_executed = true;
+    }
+  }
+
+  void
+  set_on_ready_callback(std::function<void(size_t, int)> callback) override
+  {
+    ready_callback = callback;
+  }
+
+  void
+  clear_on_ready_callback() override
+  {
+    ready_callback = std::function<void(size_t, int)>();
+  }
+
+  size_t
+  get_number_of_ready_guard_conditions() override
+  {
+    return 0;
+  }
+
+  std::vector<std::shared_ptr<rclcpp::TimerBase>> get_timers() const override
+  {
+    return {timer};
+  }
+
+  bool timerTriggeredWaitable() const
+  {
+    return timer_triggered_waitable_and_waitable_was_executed;
+  }
+
+private:
+  std::atomic_bool timer_triggered_waitable_and_waitable_was_executed = false;
+  std::atomic_bool timer_ready = false;
+  rclcpp::TimerBase::SharedPtr timer;
+  std::function<void(size_t, int)> ready_callback;
+};
+
+TEST_F(TestEventsExecutor, waitable_with_timer)
+{
+  auto node = std::make_shared<rclcpp::Node>("node");
+
+  auto waitable =
+    std::make_shared<TestWaitableWithTimer>(rclcpp::contexts::get_global_default_context());
+
+  EventsExecutor executor;
+  executor.add_node(node);
+
+  node->get_node_waitables_interface()->add_waitable(waitable,
+    node->get_node_base_interface()->get_default_callback_group());
+
+  std::thread spinner([&executor]() {executor.spin();});
+
+  size_t cnt = 0;
+  while (!waitable->timerTriggeredWaitable()) {
+    std::this_thread::sleep_for(10ms);
+    cnt++;
+
+    // This should terminate after ~20 ms, so a timeout of 500ms should be plenty
+    EXPECT_LT(cnt, 51);
+    if (cnt > 50) {
+      // timeout case
+      break;
+    }
+  }
+  executor.cancel();
+  spinner.join();
+
+  EXPECT_TRUE(waitable->timerTriggeredWaitable());
+}

rclcpp/test/rclcpp/executors/test_executor_notify_waitable.cpp

@@ -76,8 +76,7 @@ TEST_F(TestExecutorNotifyWaitable, wait) {
     std::make_shared<rclcpp::executors::ExecutorNotifyWaitable>(on_execute_callback);
 
   auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");
-  auto notify_guard_condition =
-    node->get_node_base_interface()->get_shared_notify_guard_condition();
+  auto notify_guard_condition = std::make_shared<rclcpp::GuardCondition>();
   EXPECT_NO_THROW(waitable->add_guard_condition(notify_guard_condition));
 
   auto default_cbg = node->get_node_base_interface()->get_default_callback_group();
@@ -86,12 +85,15 @@ TEST_F(TestExecutorNotifyWaitable, wait) {
   auto waitables = node->get_node_waitables_interface();
   waitables->add_waitable(std::static_pointer_cast<rclcpp::Waitable>(waitable), default_cbg);
 
+  // notify the guard condition, this should trigger the on_execute_callback
+  notify_guard_condition->trigger();
+
   rclcpp::executors::SingleThreadedExecutor executor;
   executor.add_node(node);
   executor.spin_all(std::chrono::seconds(1));
   EXPECT_EQ(1u, on_execute_calls);
 
-  // on_execute_callback doesn't change if the topology doesn't change
+  // no further trigger, therefore no further callback
   executor.spin_all(std::chrono::seconds(1));
   EXPECT_EQ(1u, on_execute_calls);
 }

rclcpp/test/rclcpp/executors/test_executors.cpp

@@ -749,8 +749,7 @@ TYPED_TEST(TestExecutors, notifyTwiceWhileSpinning)
   this->publisher->publish(test_msgs::msg::Empty());
   start = std::chrono::steady_clock::now();
   while (
-    sub1_msg_count == 1 &&
-    sub2_msg_count == 0 &&
+    (sub1_msg_count == 1 || sub2_msg_count == 0) &&
     (std::chrono::steady_clock::now() - start) < 10s)
   {
     std::this_thread::sleep_for(1ms);
@@ -890,3 +889,276 @@ TYPED_TEST(TestExecutors, testRaceDropCallbackGroupFromSecondThread)
   executor.cancel();
   executor_thread.join();
 }
+
+TYPED_TEST(TestExecutors, dropSomeTimer)
+{
+  using ExecutorType = TypeParam;
+  ExecutorType executor;
+
+  auto node = std::make_shared<rclcpp::Node>("test_node");
+
+  bool timer1_works = false;
+  bool timer2_works = false;
+
+  auto timer1 = node->create_timer(std::chrono::milliseconds(10), [&timer1_works]() {
+        timer1_works = true;
+  });
+  auto timer2 = node->create_timer(std::chrono::milliseconds(10), [&timer2_works]() {
+        timer2_works = true;
+  });
+
+  executor.add_node(node);
+
+  // first let's make sure that both timers work
+  auto max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
+  while(!timer1_works || !timer2_works) {
+    // let the executor pick up the node and the timers
+    executor.spin_all(std::chrono::milliseconds(10));
+
+    const auto cur_time = std::chrono::steady_clock::now();
+    ASSERT_LT(cur_time, max_end_time);
+  }
+
+  // delete timer 2. Note, the executor uses an unordered map internally, to order
+  // the entities added to the rcl waitset therefore the order is kind of undefined,
+  // and this test may be flaky. In case it triggers, something is most likely
+  // really broken.
+  timer2.reset();
+
+  timer1_works = false;
+  timer2_works = false;
+  max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
+  while(!timer1_works && !timer2_works) {
+    // let the executor pick up the node and the timers
+    executor.spin_all(std::chrono::milliseconds(10));
+
+    const auto cur_time = std::chrono::steady_clock::now();
+    ASSERT_LT(cur_time, max_end_time);
+  }
+
+  ASSERT_TRUE(timer1_works || timer2_works);
+}
+
+TYPED_TEST(TestExecutors, dropSomeNodeWithTimer)
+{
+  using ExecutorType = TypeParam;
+  ExecutorType executor;
+
+  auto node1 = std::make_shared<rclcpp::Node>("test_node_1");
+  auto node2 = std::make_shared<rclcpp::Node>("test_node_2");
+
+  bool timer1_works = false;
+  bool timer2_works = false;
+
+  auto timer1 = node1->create_timer(std::chrono::milliseconds(10), [&timer1_works]() {
+        timer1_works = true;
+  });
+  auto timer2 = node2->create_timer(std::chrono::milliseconds(10), [&timer2_works]() {
+        timer2_works = true;
+  });
+
+  executor.add_node(node1);
+  executor.add_node(node2);
+
+  // first let's make sure that both timers work
+  auto max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
+  while(!timer1_works || !timer2_works) {
+    // let the executor pick up the node and the timers
+    executor.spin_all(std::chrono::milliseconds(10));
+
+    const auto cur_time = std::chrono::steady_clock::now();
+    ASSERT_LT(cur_time, max_end_time);
+  }
+
+  // delete node 1.
+  node1 = nullptr;
+
+  timer2_works = false;
+  max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
+  while(!timer2_works) {
+    // let the executor pick up the node and the timer
+    executor.spin_all(std::chrono::milliseconds(10));
+
+    const auto cur_time = std::chrono::steady_clock::now();
+    ASSERT_LT(cur_time, max_end_time);
+  }
+
+  ASSERT_TRUE(timer2_works);
+}
+
+TYPED_TEST(TestExecutors, dropSomeSubscription)
+{
+  using ExecutorType = TypeParam;
+  ExecutorType executor;
+
+  auto node = std::make_shared<rclcpp::Node>("test_node");
+
+  bool sub1_works = false;
+  bool sub2_works = false;
+
+  auto sub1 = node->create_subscription<test_msgs::msg::Empty>("/test_drop", 10,
+      [&sub1_works](const test_msgs::msg::Empty &) {
+        sub1_works = true;
+  });
+  auto sub2 = node->create_subscription<test_msgs::msg::Empty>("/test_drop", 10,
+      [&sub2_works](const test_msgs::msg::Empty &) {
+        sub2_works = true;
+  });
+
+  auto pub = node->create_publisher<test_msgs::msg::Empty>("/test_drop", 10);
+
+  executor.add_node(node);
+
+  // first let's make sure that both timers work
+  auto max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
+  while(!sub1_works || !sub2_works) {
+    pub->publish(test_msgs::msg::Empty());
+
+    // let the executor pick up the node and the timers
+    executor.spin_all(std::chrono::milliseconds(10));
+
+    const auto cur_time = std::chrono::steady_clock::now();
+    ASSERT_LT(cur_time, max_end_time);
+  }
+
+  // delete subscription 2. Note, the executor uses an unordered map internally, to order
+  // the entities added to the rcl waitset therefore the order is kind of undefined,
+  // and this test may be flaky. In case it triggers, something is most likely
+  // really broken.
+  sub2.reset();
+
+  sub1_works = false;
+  sub2_works = false;
+  max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
+  while(!sub1_works && !sub2_works) {
+    pub->publish(test_msgs::msg::Empty());
+
+    // let the executor pick up the node and the timers
+    executor.spin_all(std::chrono::milliseconds(10));
+
+    const auto cur_time = std::chrono::steady_clock::now();
+    ASSERT_LT(cur_time, max_end_time);
+  }
+
+  ASSERT_TRUE(sub1_works || sub2_works);
+}
+
+TYPED_TEST(TestExecutors, dropSomeNodesWithSubscription)
+{
+  using ExecutorType = TypeParam;
+  ExecutorType executor;
+
+  auto node = std::make_shared<rclcpp::Node>("test_node");
+  auto node1 = std::make_shared<rclcpp::Node>("test_node_1");
+  auto node2 = std::make_shared<rclcpp::Node>("test_node_2");
+
+  bool sub1_works = false;
+  bool sub2_works = false;
+
+  auto sub1 = node1->create_subscription<test_msgs::msg::Empty>("/test_drop", 10,
+      [&sub1_works](const test_msgs::msg::Empty &) {
+        sub1_works = true;
+  });
+  auto sub2 = node2->create_subscription<test_msgs::msg::Empty>("/test_drop", 10,
+      [&sub2_works](const test_msgs::msg::Empty &) {
+        sub2_works = true;
+  });
+
+  auto pub = node->create_publisher<test_msgs::msg::Empty>("/test_drop", 10);
+
+  executor.add_node(node);
+  executor.add_node(node1);
+  executor.add_node(node2);
+
+  // first let's make sure that both subscribers work
+  auto max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
+  while(!sub1_works || !sub2_works) {
+    pub->publish(test_msgs::msg::Empty());
+
+    // let the executor pick up the node and the timers
+    executor.spin_all(std::chrono::milliseconds(10));
+
+    const auto cur_time = std::chrono::steady_clock::now();
+    ASSERT_LT(cur_time, max_end_time);
+  }
+
+  // delete node 2.
+  node2 = nullptr;
+
+  sub1_works = false;
+  max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
+  while(!sub1_works) {
+    pub->publish(test_msgs::msg::Empty());
+
+    // let the executor pick up the node and the timers
+    executor.spin_all(std::chrono::milliseconds(10));
+
+    const auto cur_time = std::chrono::steady_clock::now();
+    ASSERT_LT(cur_time, max_end_time);
+  }
+
+  ASSERT_TRUE(sub1_works);
+}
+
+TYPED_TEST(TestExecutors, dropSubscriptionDuringCallback)
+{
+  using ExecutorType = TypeParam;
+  ExecutorType executor;
+
+
+  auto node = std::make_shared<rclcpp::Node>("test_node");
+
+  bool sub1_works = false;
+  bool sub2_works = false;
+
+  auto cbg = node->create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive, true);
+  rclcpp::SubscriptionOptions sub_ops;
+  sub_ops.callback_group = cbg;
+
+  rclcpp::SubscriptionBase::SharedPtr sub1;
+  rclcpp::SubscriptionBase::SharedPtr sub2;
+
+  // Note, the executor uses an unordered map internally, to order
+  // the entities added to the rcl waitset therefore the order of the subscriptions
+  // is kind of undefined. Therefore each sub deletes the other one.
+  sub1 = node->create_subscription<test_msgs::msg::Empty>("/test_drop", 10,
+      [&sub1_works, &sub2](const test_msgs::msg::Empty &) {
+        sub1_works = true;
+        // delete the other subscriber
+        sub2.reset();
+  }, sub_ops);
+  sub2 = node->create_subscription<test_msgs::msg::Empty>("/test_drop", 10,
+      [&sub2_works, &sub1](const test_msgs::msg::Empty &) {
+        sub2_works = true;
+        // delete the other subscriber
+        sub1.reset();
+  }, sub_ops);
+
+  auto pub = node->create_publisher<test_msgs::msg::Empty>("/test_drop", 10);
+
+  // wait for both subs to be connected
+  auto max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(1500);
+  while ((sub1->get_publisher_count() == 0) || (sub2->get_publisher_count() == 0)) {
+    const auto cur_time = std::chrono::steady_clock::now();
+    ASSERT_LT(cur_time, max_end_time);
+  }
+
+  executor.add_node(node);
+
+  // publish some messages, until one subscriber fired. As both subscribers are
+  // connected to the same topic, they should fire in the same wait.
+  max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
+  while (!sub1_works && !sub2_works) {
+    pub->publish(test_msgs::msg::Empty());
+
+    // let the executor pick up the node and the timers
+    executor.spin_all(std::chrono::milliseconds(10));
+
+    const auto cur_time = std::chrono::steady_clock::now();
+    ASSERT_LT(cur_time, max_end_time);
+  }
+
+  // only one subscriber must have worked, as the other
+  // one was deleted during the callback
+  ASSERT_TRUE(!sub1_works || !sub2_works);
+}

rclcpp/test/rclcpp/executors/test_executors_timer_cancel_behavior.cpp

@@ -267,12 +267,15 @@ public:
 
   void TearDown()
   {
-    node.reset();
+    executor.cancel();
 
     // Clean up thread object
     if (standalone_thread.joinable()) {
       standalone_thread.join();
     }
+
+    node.reset();
+    sim_clock_node.reset();
   }
 
   std::shared_ptr<TimerNode> node;
@@ -310,7 +313,6 @@ TYPED_TEST(TestTimerCancelBehavior, testTimer1CancelledWithExecutorSpin) {
   this->sim_clock_node->sleep_for(50ms);
   this->node->CancelTimer1();
   this->sim_clock_node->sleep_for(150ms);
-  this->executor.cancel();
 
   int t1_runs = this->node->GetTimer1Cnt();
   int t2_runs = this->node->GetTimer2Cnt();
@@ -328,7 +330,6 @@ TYPED_TEST(TestTimerCancelBehavior, testTimer2CancelledWithExecutorSpin) {
   this->sim_clock_node->sleep_for(50ms);
   this->node->CancelTimer2();
   this->sim_clock_node->sleep_for(150ms);
-  this->executor.cancel();
 
   int t1_runs = this->node->GetTimer1Cnt();
   int t2_runs = this->node->GetTimer2Cnt();
@@ -355,8 +356,6 @@ TYPED_TEST(TestTimerCancelBehavior, testHeadTimerCancelThenResetBehavior) {
   int t1_runs_final = this->node->GetTimer1Cnt();
   int t2_runs_final = this->node->GetTimer2Cnt();
 
-  this->executor.cancel();
-
   // T1 should have been restarted, and execute about 15 additional times.
   // Check 10 greater than initial, to account for some timing jitter.
   EXPECT_LT(t1_runs_initial + 50, t1_runs_final);
@@ -384,8 +383,6 @@ TYPED_TEST(TestTimerCancelBehavior, testBackTimerCancelThenResetBehavior) {
   int t1_runs_final = this->node->GetTimer1Cnt();
   int t2_runs_final = this->node->GetTimer2Cnt();
 
-  this->executor.cancel();
-
   // T2 should have been restarted, and execute about 15 additional times.
   // Check 10 greater than initial, to account for some timing jitter.
   EXPECT_LT(t2_runs_initial + 50, t2_runs_final);
@@ -419,8 +416,6 @@ TYPED_TEST(TestTimerCancelBehavior, testBothTimerCancelThenResetT1Behavior) {
   int t1_runs_final = this->node->GetTimer1Cnt();
   int t2_runs_final = this->node->GetTimer2Cnt();
 
-  this->executor.cancel();
-
   // T1 and T2 should have the same initial count.
   EXPECT_LE(std::abs(t1_runs_initial - t2_runs_initial), 1);
 
@@ -458,8 +453,6 @@ TYPED_TEST(TestTimerCancelBehavior, testBothTimerCancelThenResetT2Behavior) {
   int t1_runs_final = this->node->GetTimer1Cnt();
   int t2_runs_final = this->node->GetTimer2Cnt();
 
-  this->executor.cancel();
-
   // T1 and T2 should have the same initial count.
   EXPECT_LE(std::abs(t1_runs_initial - t2_runs_initial), 1);
 

rclcpp/test/rclcpp/executors/test_executors_warmup.cpp

@@ -99,14 +99,6 @@ TYPED_TEST(TestExecutorsWarmup, spin_all_doesnt_require_warmup_with_cbgroup)
 {
   using ExecutorType = TypeParam;
 
-  // TODO(alsora): Enable when https://github.com/ros2/rclcpp/pull/2595 gets merged
-  if (
-    std::is_same<ExecutorType, rclcpp::executors::SingleThreadedExecutor>() ||
-    std::is_same<ExecutorType, rclcpp::executors::MultiThreadedExecutor>())
-  {
-    GTEST_SKIP();
-  }
-
   ExecutorType executor;
 
   // Enable intra-process to guarantee deterministic and synchronous delivery of the message / event

rclcpp/test/rclcpp/executors/test_waitable.cpp

@@ -64,9 +64,8 @@ TestWaitable::take_data()
 }
 
 std::shared_ptr<void>
-TestWaitable::take_data_by_entity_id(size_t id)
+TestWaitable::take_data_by_entity_id([[maybe_unused]] size_t id)
 {
-  (void) id;
   return nullptr;
 }
 

rclcpp/test/rclcpp/executors/test_waitable.hpp

@@ -18,6 +18,7 @@
 #include <atomic>
 #include <functional>
 #include <memory>
+#include <vector>
 
 #include "rclcpp/waitable.hpp"
 #include "rclcpp/guard_condition.hpp"
@@ -64,6 +65,11 @@ public:
   size_t
   get_is_ready_call_count() const;
 
+  std::vector<std::shared_ptr<rclcpp::TimerBase>> get_timers() const override
+  {
+    return {};
+  }
+
 private:
   std::atomic<size_t> trigger_count_ = 0;
   std::atomic<size_t> is_ready_count_ = 0;

rclcpp/test/rclcpp/node_interfaces/test_node_parameters.cpp

@@ -29,6 +29,8 @@
 #include "rclcpp/node.hpp"
 #include "rclcpp/node_interfaces/node_parameters.hpp"
 
+#include "test_msgs/msg/empty.hpp"
+
 #include "../../mocking_utils/patch.hpp"
 #include "../../utils/rclcpp_gtest_macros.hpp"
 
@@ -329,6 +331,89 @@ TEST_F(TestNodeParameters, add_remove_post_set_parameters_callback) {
     std::runtime_error("Post set parameter callback doesn't exist"));
 }
 
+TEST_F(TestNodeParameters, set_param_recursive_in_post_set_parameters_callback) {
+  rclcpp::Subscription<test_msgs::msg::Empty>::SharedPtr subscription_;
+  rclcpp::Publisher<test_msgs::msg::Empty>::SharedPtr publisher_;
+
+  rcl_interfaces::msg::ParameterDescriptor param_descriptor;
+  param_descriptor.name = "create_entities";
+  param_descriptor.type = rcl_interfaces::msg::ParameterType::PARAMETER_BOOL;
+  param_descriptor.read_only = false;
+
+  bool result = node_parameters->declare_parameter(
+    "create_entities", rclcpp::ParameterValue(false), param_descriptor, false).get<bool>();
+  EXPECT_EQ(result, false);
+
+  // Register a callback to create/delete publisher and subscription with
+  // QoS override parameter options. This will call declare_parameter recursively
+  // during this callback.
+  auto sub_callback = [](test_msgs::msg::Empty::ConstSharedPtr) {};
+  auto callback = [&](const std::vector<rclcpp::Parameter> & parameters) {
+      for (const auto & parameter : parameters) {
+        if (parameter.get_name() == "create_entities" &&
+          parameter.get_type() == rclcpp::ParameterType::PARAMETER_BOOL)
+        {
+          if (parameter.as_bool()) {
+            ASSERT_EQ(subscription_, nullptr);
+            rclcpp::SubscriptionOptions sub_options;
+            // This will declare the QoS override parameters in this callback.
+            sub_options.qos_overriding_options =
+              rclcpp::QosOverridingOptions::with_default_policies();
+            subscription_ = node->create_subscription<test_msgs::msg::Empty>(
+              "empty",
+              rclcpp::QoS(10),
+              sub_callback,
+              sub_options);
+            ASSERT_NE(subscription_, nullptr);
+            ASSERT_EQ(publisher_, nullptr);
+            rclcpp::PublisherOptions pub_options;
+            // This will declare the QoS override parameters in this callback.
+            pub_options.qos_overriding_options =
+              rclcpp::QosOverridingOptions::with_default_policies();
+            publisher_ = node->create_publisher<test_msgs::msg::Empty>(
+              "empty",
+              rclcpp::QoS(10),
+              pub_options);
+            ASSERT_NE(publisher_, nullptr);
+          } else {
+            ASSERT_NE(subscription_, nullptr);
+            subscription_.reset();
+            ASSERT_EQ(subscription_, nullptr);
+            ASSERT_NE(publisher_, nullptr);
+            publisher_.reset();
+            ASSERT_EQ(publisher_, nullptr);
+          }
+        }
+      }
+    };
+
+  auto handle = node_parameters->add_post_set_parameters_callback(callback);
+  ASSERT_NE(handle, nullptr);
+  EXPECT_TRUE(node_parameters->has_parameter("create_entities"));
+  EXPECT_EQ(node_parameters->get_parameter("create_entities").get_value<bool>(), false);
+
+  // This will call the registered callback, that will create endpoints with
+  // declaring the QoS override parameters recursively.
+  auto results = node_parameters->set_parameters({rclcpp::Parameter("create_entities", true)});
+  EXPECT_TRUE(!results.empty() && results[0].successful);
+
+  EXPECT_TRUE(node_parameters->has_parameter("create_entities"));
+  EXPECT_EQ(node_parameters->get_parameter("create_entities").get_value<bool>(), true);
+
+  // Destroy publisher and subscription endpoints.
+  results = node_parameters->set_parameters({rclcpp::Parameter("create_entities", false)});
+  EXPECT_TRUE(!results.empty() && results[0].successful);
+
+  EXPECT_TRUE(node_parameters->has_parameter("create_entities"));
+  EXPECT_EQ(node_parameters->get_parameter("create_entities").get_value<bool>(), false);
+
+  // Make sure recreation can also work without any exception.
+  results = node_parameters->set_parameters({rclcpp::Parameter("create_entities", true)});
+  EXPECT_TRUE(!results.empty() && results[0].successful);
+
+  EXPECT_NO_THROW(node_parameters->remove_post_set_parameters_callback(handle.get()));
+}
+
 TEST_F(TestNodeParameters, wildcard_with_namespace)
 {
   rclcpp::NodeOptions opts;

rclcpp/test/rclcpp/node_interfaces/test_node_waitables.cpp

@@ -38,6 +38,11 @@ public:
   void clear_on_ready_callback() override {}
 
   std::shared_ptr<void> take_data_by_entity_id(size_t) override {return nullptr;}
+
+  std::vector<std::shared_ptr<rclcpp::TimerBase>> get_timers() const override
+  {
+    return {};
+  }
 };
 
 class TestNodeWaitables : public ::testing::Test

rclcpp/test/rclcpp/strategies/test_allocator_memory_strategy.cpp

@@ -58,6 +58,11 @@ public:
   void clear_on_ready_callback() override {}
 
   std::shared_ptr<void> take_data_by_entity_id(size_t) override {return nullptr;}
+
+  std::vector<std::shared_ptr<rclcpp::TimerBase>> get_timers() const override
+  {
+    return {};
+  }
 };
 
 struct RclWaitSetSizes
@@ -535,8 +540,8 @@ TEST_F(TestAllocatorMemoryStrategy, add_handles_to_wait_set_bad_arguments) {
     });
   allocator_memory_strategy()->collect_entities(weak_groups_to_nodes);
   EXPECT_FALSE(allocator_memory_strategy()->add_handles_to_wait_set(nullptr));
-  EXPECT_TRUE(rcl_error_is_set());
-  rcl_reset_error();
+  // The error message is collected and already reset.
+  EXPECT_FALSE(rcl_error_is_set());
 }
 
 TEST_F(TestAllocatorMemoryStrategy, add_handles_to_wait_set_subscription) {

rclcpp/test/rclcpp/test_client_common.cpp

@@ -184,9 +184,8 @@ class ClientTypeNames
 {
 public:
   template<typename T>
-  static std::string GetName(int idx)
+  static std::string GetName([[maybe_unused]] int idx)
   {
-    (void)idx;
     if (std::is_same_v<T, rclcpp::Client<test_msgs::srv::Empty>>) {
       return "Client";
     }

rclcpp/test/rclcpp/test_clock_conditional.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Cellumation GmbH
+// Copyright 2025 Cellumation GmbH
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -32,18 +32,28 @@ public:
   void test_wakeup_before_sleep(const rclcpp::Clock::SharedPtr & clock)
   {
     std::atomic_bool thread_finished = false;
+    rclcpp::ClockConditionalVariable cond(clock);
+
+    bool stopSleeping = false;
 
     std::thread wait_thread = std::thread(
-      [&clock, &thread_finished]()
+      [&cond, &clock, &stopSleeping, &thread_finished]()
       {
         // make sure the thread starts sleeping late
         std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        clock->sleep_until(clock->now() + std::chrono::seconds(3));
+        std::unique_lock lk(cond.mutex());
+        cond.wait_until(lk, clock->now() + std::chrono::seconds(3),
+        [&stopSleeping] () {return stopSleeping;});
         thread_finished = true;
       });
 
-    // notify the clock, that the sleep shall be interrupted
-    clock->cancel_sleep_or_wait();
+    {
+      std::lock_guard lk(cond.mutex());
+      // stop sleeping after next notification
+      stopSleeping = true;
+    }
+    // notify the conditional, to recheck it pred
+    cond.notify_one();
 
     auto start_time = std::chrono::steady_clock::now();
     auto cur_time = start_time;
@@ -61,19 +71,29 @@ public:
   void test_wakeup_after_sleep(const rclcpp::Clock::SharedPtr & clock)
   {
     std::atomic_bool thread_finished = false;
+    rclcpp::ClockConditionalVariable cond(clock);
+
+    bool stopSleeping = false;
 
     std::thread wait_thread = std::thread(
-      [&clock, &thread_finished]()
+      [&cond, &clock, &stopSleeping, &thread_finished]()
       {
-        clock->sleep_until(clock->now() + std::chrono::seconds(3));
+        std::unique_lock lk(cond.mutex());
+        cond.wait_until(lk, clock->now() + std::chrono::seconds(3),
+        [&stopSleeping] () {return stopSleeping;});
         thread_finished = true;
       });
 
     // make sure the thread is already sleeping before we send the cancel
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
-    // notify the clock, that the sleep shall be interrupted
-    clock->cancel_sleep_or_wait();
+    {
+      std::lock_guard lk(cond.mutex());
+      // stop sleeping after next notification
+      stopSleeping = true;
+    }
+    // notify the conditional, to recheck it pred
+    cond.notify_one();
 
     auto start_time = std::chrono::steady_clock::now();
     auto cur_time = start_time;
@@ -113,7 +133,7 @@ protected:
 };
 
 INSTANTIATE_TEST_SUITE_P(
-  Clocks,
+  ClockConditionalVariable,
   TestClockWakeup,
   ::testing::Values(
     RCL_SYSTEM_TIME, RCL_ROS_TIME, RCL_STEADY_TIME
@@ -140,18 +160,24 @@ TEST_F(TestClockWakeup, wakeup_sleep_ros_time_active) {
 TEST_F(TestClockWakeup, no_wakeup_on_sim_time) {
   node->set_parameter({"use_sim_time", true});
   auto clock = std::make_shared<rclcpp::Clock>(RCL_ROS_TIME);
+  EXPECT_FALSE(clock->ros_time_is_active());
+
   rclcpp::TimeSource time_source(node);
   time_source.attachClock(clock);
-
   EXPECT_TRUE(clock->ros_time_is_active());
 
   std::atomic_bool thread_finished = false;
+  rclcpp::ClockConditionalVariable cond(clock);
+
+  bool stopSleeping = false;
 
   std::thread wait_thread = std::thread(
-    [&clock, &thread_finished]()
+    [&cond, &clock, &stopSleeping, &thread_finished]()
     {
-      // make sure the thread starts sleeping late
-      clock->sleep_until(clock->now() + std::chrono::milliseconds(10));
+      std::unique_lock lk(cond.mutex());
+      // only sleep for an short period
+      cond.wait_until(lk, clock->now() + std::chrono::milliseconds(10),
+      [&stopSleeping] () {return stopSleeping;});
       thread_finished = true;
     });
 
@@ -159,8 +185,13 @@ TEST_F(TestClockWakeup, no_wakeup_on_sim_time) {
   std::this_thread::sleep_for(std::chrono::milliseconds(500));
   EXPECT_FALSE(thread_finished);
 
-  // notify the clock, that the sleep shall be interrupted
-  clock->cancel_sleep_or_wait();
+  {
+    std::lock_guard lk(cond.mutex());
+    // stop sleeping after next notification
+    stopSleeping = true;
+  }
+  // notify the conditional, to recheck it pred
+  cond.notify_one();
 
   auto start_time = std::chrono::steady_clock::now();
   auto cur_time = start_time;
@@ -175,55 +206,41 @@ TEST_F(TestClockWakeup, no_wakeup_on_sim_time) {
   EXPECT_LT(cur_time, start_time + std::chrono::seconds(1));
 }
 
-TEST_F(TestClockWakeup, multiple_threads_wait_on_one_clock) {
+TEST_F(TestClockWakeup, wakeup_on_ros_shutdown) {
   auto clock = std::make_shared<rclcpp::Clock>(RCL_ROS_TIME);
 
-  std::vector<bool> thread_finished(10, false);
+  std::atomic_bool thread_finished = false;
+  rclcpp::ClockConditionalVariable cond(clock);
 
-  std::vector<std::thread> threads;
+  bool stopSleeping = false;
 
-  for (size_t nr = 0; nr < thread_finished.size(); nr++) {
-    threads.push_back(
-      std::thread(
-        [&clock, &thread_finished, nr]()
-        {
-          // make sure the thread starts sleeping late
-          clock->sleep_until(clock->now() + std::chrono::seconds(10));
-          thread_finished[nr] = true;
-        }));
-  }
+  std::thread wait_thread = std::thread(
+    [&cond, &clock, &stopSleeping, &thread_finished]()
+    {
+      std::unique_lock lk(cond.mutex());
+      // only sleep for an short period
+      cond.wait_until(lk, clock->now() + std::chrono::seconds(10),
+      [&stopSleeping] () {return stopSleeping;});
+      thread_finished = true;
+    });
 
-  // wait a bit so all threads can execute the sleep_until
+  // wait a bit to be sure the thread is sleeping
   std::this_thread::sleep_for(std::chrono::milliseconds(500));
 
-  for (const bool & finished : thread_finished) {
-    EXPECT_FALSE(finished);
-  }
+  EXPECT_FALSE(thread_finished);
 
   rclcpp::shutdown();
 
   auto start_time = std::chrono::steady_clock::now();
   auto cur_time = start_time;
-  bool threads_finished = false;
-  while (!threads_finished && start_time + std::chrono::seconds(1) > cur_time) {
-    threads_finished = true;
-    for (const bool finished : thread_finished) {
-      if (!finished) {
-        threads_finished = false;
-      }
-    }
-
+  while (!thread_finished && start_time + std::chrono::seconds(1) > cur_time) {
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
     cur_time = std::chrono::steady_clock::now();
   }
 
-  for (const bool finished : thread_finished) {
-    EXPECT_TRUE(finished);
-  }
+  EXPECT_TRUE(thread_finished);
 
-  for (auto & thread : threads) {
-    thread.join();
-  }
+  wait_thread.join();
 
   EXPECT_LT(cur_time, start_time + std::chrono::seconds(1));
 }

rclcpp/test/rclcpp/test_executor.cpp

@@ -19,11 +19,16 @@
 #include <stdexcept>
 #include <string>
 
+#include "rcl_interfaces/msg/parameter_event.hpp"
+
 #include "rclcpp/executor.hpp"
 #include "rclcpp/memory_strategy.hpp"
 #include "rclcpp/executors/single_threaded_executor.hpp"
+#include "rclcpp/rclcpp.hpp"
 #include "rclcpp/strategies/allocator_memory_strategy.hpp"
 
+#include "test_msgs/msg/empty.hpp"
+
 #include "../mocking_utils/patch.hpp"
 #include "../utils/rclcpp_gtest_macros.hpp"
 
@@ -331,8 +336,17 @@ TEST_F(TestExecutor, spin_all_fail_wait_set_clear) {
     node->create_wall_timer(std::chrono::milliseconds(1), [&]() {});
 
   dummy.add_node(node);
+  auto callback = [](test_msgs::msg::Empty::ConstSharedPtr) {};
+  rclcpp::Subscription<test_msgs::msg::Empty>::SharedPtr subscription;
+  auto node_topics = node->get_node_topics_interface();
+  subscription =
+    rclcpp::create_subscription<test_msgs::msg::Empty>(
+    node_topics, "test", rclcpp::QoS(10), std::move(callback));
   auto mock = mocking_utils::patch_and_return("lib:rclcpp", rcl_wait_set_clear, RCL_RET_ERROR);
 
+  dummy.spin_all(std::chrono::milliseconds(1));
+  // second spin_all triggers rcl_wait_set_clear that should be called
+  // whenever a waitset gets rebuild and it was not changed in size.
   RCLCPP_EXPECT_THROW_EQ(
     dummy.spin_all(std::chrono::milliseconds(1)),
     std::runtime_error("Couldn't clear the wait set: error not set"));
@@ -354,8 +368,14 @@ TEST_F(TestExecutor, spin_some_fail_wait_set_resize) {
 TEST_F(TestExecutor, spin_some_fail_add_handles_to_wait_set) {
   DummyExecutor dummy;
   auto node = std::make_shared<rclcpp::Node>("node", "ns");
-  auto timer =
-    node->create_wall_timer(std::chrono::milliseconds(1), [&]() {});
+
+  // create subscription explicitly, because we do not create subscription
+  // on /parameter_events for 'use_sim_time' parameter anymore.
+  auto callback = [](test_msgs::msg::Empty::ConstSharedPtr) {};
+  rclcpp::Subscription<test_msgs::msg::Empty>::SharedPtr subscription;
+  subscription =
+    node->create_subscription<test_msgs::msg::Empty>(
+    "test", rclcpp::QoS(10), std::move(callback));
 
   dummy.add_node(node);
   auto mock = mocking_utils::patch_and_return(

rclcpp/test/rclcpp/test_function_traits.cpp

@@ -74,29 +74,23 @@ struct FunctionObjectOneIntOneChar
 
 struct ObjectMember
 {
-  int callback_one_bool(bool a)
+  int callback_one_bool([[maybe_unused]] bool a)
   {
-    (void)a;
     return 7;
   }
 
-  int callback_one_bool_const(bool a) const
+  int callback_one_bool_const([[maybe_unused]] bool a) const
   {
-    (void)a;
     return 7;
   }
 
-  int callback_two_bools(bool a, bool b)
+  int callback_two_bools([[maybe_unused]] bool a, [[maybe_unused]] bool b)
   {
-    (void)a;
-    (void)b;
     return 8;
   }
 
-  int callback_one_bool_one_float(bool a, float b)
+  int callback_one_bool_one_float([[maybe_unused]] bool a, [[maybe_unused]] float b)
   {
-    (void)a;
-    (void)b;
     return 9;
   }
 };
@@ -212,20 +206,15 @@ TEST(TestFunctionTraits, arity) {
       return 0;
     };
 
-  auto lambda_one_int = [](int one) {
-      (void)one;
+  auto lambda_one_int = []([[maybe_unused]] int one) {
       return 1;
     };
 
-  auto lambda_two_ints = [](int one, int two) {
-      (void)one;
-      (void)two;
+  auto lambda_two_ints = []([[maybe_unused]] int one, [[maybe_unused]] int two) {
       return 2;
     };
 
-  auto lambda_one_int_one_char = [](int one, char two) {
-      (void)one;
-      (void)two;
+  auto lambda_one_int_one_char = []([[maybe_unused]] int one, [[maybe_unused]] char two) {
       return 3;
     };
 
@@ -303,20 +292,15 @@ TEST(TestFunctionTraits, argument_types) {
     >::value, "Functor accepts a char as second argument");
 
   // Test lambdas
-  auto lambda_one_int = [](int one) {
-      (void)one;
+  auto lambda_one_int = []([[maybe_unused]] int one) {
       return 1;
     };
 
-  auto lambda_two_ints = [](int one, int two) {
-      (void)one;
-      (void)two;
+  auto lambda_two_ints = []([[maybe_unused]] int one, [[maybe_unused]] int two) {
       return 2;
     };
 
-  auto lambda_one_int_one_char = [](int one, char two) {
-      (void)one;
-      (void)two;
+  auto lambda_one_int_one_char = []([[maybe_unused]] int one, [[maybe_unused]]  char two) {
       return 3;
     };
 
@@ -533,22 +517,17 @@ TEST(TestFunctionTraits, check_arguments) {
     "Functor accepts an int and a char as arguments");
 
   // Test lambdas
-  auto lambda_one_int = [](int one) {
-      (void)one;
+  auto lambda_one_int = []([[maybe_unused]] int one) {
       return 1;
     };
   (void)lambda_one_int;  // to quiet clang
 
-  auto lambda_two_ints = [](int one, int two) {
-      (void)one;
-      (void)two;
+  auto lambda_two_ints = []([[maybe_unused]] int one, [[maybe_unused]] int two) {
       return 2;
     };
   (void)lambda_two_ints;  // to quiet clang
 
-  auto lambda_one_int_one_char = [](int one, char two) {
-      (void)one;
-      (void)two;
+  auto lambda_one_int_one_char = []([[maybe_unused]] int one, [[maybe_unused]]  char two) {
       return 3;
     };
   (void)lambda_one_int_one_char;  // to quiet clang
@@ -603,14 +582,11 @@ TEST(TestFunctionTraits, check_arguments) {
    Tests that same_arguments work.
 */
 TEST(TestFunctionTraits, same_arguments) {
-  auto lambda_one_int = [](int one) {
-      (void)one;
+  auto lambda_one_int = []([[maybe_unused]] int one) {
       return 1;
     };
 
-  auto lambda_two_ints = [](int one, int two) {
-      (void)one;
-      (void)two;
+  auto lambda_two_ints = []([[maybe_unused]] int one, [[maybe_unused]]  int two) {
       return 1;
     };
 
@@ -658,8 +634,7 @@ TEST(TestFunctionTraits, return_type) {
     "Functor return ints");
 
   // Test lambda
-  auto lambda_one_int_return_double = [](int one) -> double {
-      (void)one;
+  auto lambda_one_int_return_double = []([[maybe_unused]] int one) -> double {
       return 1.0;
     };
 
@@ -697,20 +672,15 @@ TEST(TestFunctionTraits, sfinae_match) {
       return 0;
     };
 
-  auto lambda_one_int = [](int one) {
-      (void)one;
+  auto lambda_one_int = []([[maybe_unused]] int one) {
       return 1;
     };
 
-  auto lambda_two_ints = [](int one, int two) {
-      (void)one;
-      (void)two;
+  auto lambda_two_ints = []([[maybe_unused]] int one, [[maybe_unused]]  int two) {
       return 2;
     };
 
-  auto lambda_one_int_one_char = [](int one, char two) {
-      (void)one;
-      (void)two;
+  auto lambda_one_int_one_char = []([[maybe_unused]] int one, [[maybe_unused]]  char two) {
       return 3;
     };
 

rclcpp/test/rclcpp/test_generic_client.cpp

@@ -221,7 +221,7 @@ TEST_F(TestGenericClient, wait_for_service) {
 TEST_F(TestGenericClientSub, construction_and_destruction) {
   {
     auto client = subnode->create_generic_client("test_service", "test_msgs/srv/Empty");
-    EXPECT_STREQ(client->get_service_name(), "/ns/test_service");
+    EXPECT_STREQ(client->get_service_name(), "/ns/sub_ns/test_service");
   }
 
   {

rclcpp/test/rclcpp/test_generic_pubsub.cpp

@@ -89,9 +89,9 @@ public:
     T2 message;
     write_message(data, message);
 
-    rclcpp::Serialization<T2> serialization_support;
+    rclcpp::Serialization<T2> ser;
     SerializedMessage result;
-    serialization_support.serialize_message(&message, &result);
+    ser.serialize_message(&message, &result);
     return result;
   }
 

rclcpp/test/rclcpp/test_intra_process_buffer.cpp

@@ -21,7 +21,7 @@
 #include "rclcpp/rclcpp.hpp"
 
 /*
-   Construtctor
+   Constructor
  */
 TEST(TestIntraProcessBuffer, constructor) {
   using MessageT = char;

rclcpp/test/rclcpp/test_intra_process_manager.cpp

@@ -193,16 +193,14 @@ public:
   }
 
   bool
-  operator==(const rmw_gid_t & gid) const
+  operator==([[maybe_unused]] const rmw_gid_t & gid) const
   {
-    (void)gid;
     return false;
   }
 
   bool
-  operator==(const rmw_gid_t * gid) const
+  operator==([[maybe_unused]] const rmw_gid_t * gid) const
   {
-    (void)gid;
     return false;
   }
 
@@ -260,12 +258,12 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(SubscriptionIntraProcessBase)
 
   explicit SubscriptionIntraProcessBase(
-    rclcpp::Context::SharedPtr context,
+    [[maybe_unused]] rclcpp::Context::SharedPtr context,
     const std::string & topic,
     const rclcpp::QoS & qos)
   : topic_name(topic), qos_profile(qos)
   {
-    (void)context;
+    // This function is intentionally left empty.
   }
 
   virtual ~SubscriptionIntraProcessBase() {}

rclcpp/test/rclcpp/test_intra_process_manager_with_allocators.cpp

@@ -61,9 +61,8 @@ public:
     return static_cast<T *>(std::malloc(size * sizeof(T)));
   }
 
-  void deallocate(T * ptr, size_t size)
+  void deallocate(T * ptr, [[maybe_unused]] size_t size)
   {
-    (void)size;
     if (!ptr) {
       return;
     }

rclcpp/test/rclcpp/test_memory_strategy.cpp

@@ -45,6 +45,11 @@ public:
   void clear_on_ready_callback() override {}
 
   std::shared_ptr<void> take_data_by_entity_id(size_t) override {return nullptr;}
+
+  std::vector<std::shared_ptr<rclcpp::TimerBase>> get_timers() const override
+  {
+    return {};
+  }
 };
 
 class TestMemoryStrategy : public ::testing::Test

rclcpp/test/rclcpp/test_node.cpp

@@ -306,6 +306,39 @@ TEST_F(TestNode, subnode_get_name_and_namespace) {
     }, rclcpp::exceptions::NameValidationError);
   }
 }
+
+TEST_F(TestNode, subnode_parameter_operation) {
+  auto node = std::make_shared<rclcpp::Node>("my_node", "ns");
+  auto subnode = node->create_sub_node("sub_ns");
+
+  auto value = subnode->declare_parameter("param", 5);
+  EXPECT_EQ(value, 5);
+  // node and sub-node shares NodeParametersInterface, so expecting the exception.
+  EXPECT_THROW(
+    node->declare_parameter("param", 0),
+    rclcpp::exceptions::ParameterAlreadyDeclaredException);
+  rclcpp::Parameter param;
+
+  node->get_parameter("param", param);
+  EXPECT_EQ(param.get_value<int>(), 5);
+  subnode->get_parameter("param", param);
+  EXPECT_EQ(param.get_value<int>(), 5);
+
+  int param_int;
+  node->get_parameter("param", param_int);
+  EXPECT_EQ(param_int, 5);
+  subnode->get_parameter("param", param_int);
+  EXPECT_EQ(param_int, 5);
+
+  EXPECT_EQ(node->get_parameter_or("param", 333), 5);
+  EXPECT_EQ(subnode->get_parameter_or("param", 666), 5);
+
+  node->get_parameter_or("param", param_int, 333);
+  EXPECT_EQ(param_int, 5);
+  subnode->get_parameter_or("param", param_int, 666);
+  EXPECT_EQ(param_int, 5);
+}
+
 /*
    Testing node construction and destruction.
  */
@@ -1332,6 +1365,203 @@ TEST_F(TestNode, set_parameter_undeclared_parameters_not_allowed) {
       node->declare_parameter(name, 42, descriptor),
       rclcpp::exceptions::InvalidParameterValueException);
   }
+  {
+    // setting an array parameter with integer range descriptor
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 10;
+    integer_range.to_value = 18;
+    integer_range.step = 2;
+    node->declare_parameter(name, std::vector<int64_t>{10, 12, 14, 16, 18}, descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<int64_t>>(), std::vector<int64_t>({10, 12, 14, 16, 18}));
+
+    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({12, 14, 10}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({12, 14, 10}));
+    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({10, 10, 10}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({10, 10, 10}));
+    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({18}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({15}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({20}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({8}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({12, 8, 18}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+  }
+  {
+    // setting an array parameter with integer range descriptor, from_value > to_value
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 20;
+    integer_range.to_value = 18;
+    integer_range.step = 1;
+    node->declare_parameter(name, std::vector<int64_t>({18, 20}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<int64_t>>(), std::vector<int64_t>({18, 20}));
+
+    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({20, 18}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({20, 18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({18, 19, 20}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({20, 18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({10}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({20, 18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({25}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({20, 18}));
+  }
+  {
+    // setting an array parameter with integer range descriptor, from_value = to_value
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 18;
+    integer_range.to_value = 18;
+    integer_range.step = 1;
+    node->declare_parameter(name, std::vector<int64_t>({18}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<int64_t>>(), std::vector<int64_t>({18}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({17}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({19}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+  }
+  {
+    // setting an array parameter with integer range descriptor,
+    // step > distance(from_value, to_value)
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 18;
+    integer_range.to_value = 25;
+    integer_range.step = 10;
+    node->declare_parameter(name, std::vector<int64_t>({18, 25}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<int64_t>>(), std::vector<int64_t>({18, 25}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({17}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18, 25}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({19}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18, 25}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({28}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18, 25}));
+  }
+  {
+    // setting an array parameter with integer range descriptor, distance not multiple of the step.
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 18;
+    integer_range.to_value = 28;
+    integer_range.step = 7;
+    node->declare_parameter(name, std::vector<int64_t>({18, 25, 28}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<int64_t>>(), std::vector<int64_t>({18, 25, 28}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({17}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18, 25, 28}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({19}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18, 25, 28}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({32}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18, 25, 28}));
+  }
+  {
+    // setting an array parameter with integer range descriptor, step=0
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 10;
+    integer_range.to_value = 18;
+    integer_range.step = 0;
+    node->declare_parameter(name, std::vector<int64_t>({10, 11, 12, 13, 14, 15, 16, 17, 18}),
+      descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({10, 11, 12, 13, 14, 15, 16, 17, 18}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({9}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({10, 11, 12, 13, 14, 15, 16, 17, 18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({19}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({10, 11, 12, 13, 14, 15, 16, 17, 18}));
+  }
+  {
+    // setting an array parameter with integer range descriptor and wrong default value will throw
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 10;
+    integer_range.to_value = 18;
+    integer_range.step = 2;
+    ASSERT_THROW(
+      node->declare_parameter(name, std::vector<int64_t>({10, 11, 12, 13, 14, 15, 16, 17, 18}),
+      descriptor),
+      rclcpp::exceptions::InvalidParameterValueException);
+  }
   {
     // setting a parameter with floating point range descriptor
     auto name = "parameter"_unq;
@@ -1502,6 +1732,201 @@ TEST_F(TestNode, set_parameter_undeclared_parameters_not_allowed) {
     EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 9.999)).successful);
     EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
   }
+  {
+    // setting an array parameter with floating point range descriptor
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 10.0;
+    floating_point_range.to_value = 11.0;
+    floating_point_range.step = 0.2;
+    node->declare_parameter(name, std::vector<double>({10.0, 10.4, 11.0, 10.8, 10.2, 10.6}),
+      descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.4, 11.0, 10.8, 10.2, 10.6}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({10.3}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.4, 11.0, 10.8, 10.2, 10.6}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({12.0}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.4, 11.0, 10.8, 10.2, 10.6}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({9.4}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.4, 11.0, 10.8, 10.2, 10.6}));
+  }
+  {
+    // setting an array parameter with floating point range descriptor, negative step
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 10.0;
+    floating_point_range.to_value = 11.0;
+    floating_point_range.step = -0.2;
+    node->declare_parameter(name, std::vector<double>({10.0, 10.2, 10.4, 10.6, 10.8, 11.0}),
+      descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.2, 10.4, 10.6, 10.8, 11.0}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({10.3}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.2, 10.4, 10.6, 10.8, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({12.0}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.2, 10.4, 10.6, 10.8, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({9.4}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.2, 10.4, 10.6, 10.8, 11.0}));
+  }
+  {
+    // setting an array parameter with floating point range descriptor, from_value > to_value
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 11.0;
+    floating_point_range.to_value = 10.0;
+    floating_point_range.step = 0.2;
+    node->declare_parameter(name, std::vector<double>({10.0, 11.0}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(), std::vector<double>({10.0, 11.0}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({10.2}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({12.0}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({9.4}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 11.0}));
+  }
+  {
+    // setting an array parameter with floating point range descriptor, from_value = to_value
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 10.0;
+    floating_point_range.to_value = 10.0;
+    floating_point_range.step = 0.2;
+    node->declare_parameter(name, std::vector<double>({10.0}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(), std::vector<double>({10.0}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({11.2}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({12.0}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({9.4}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0}));
+  }
+  {
+    // setting an array parameter with floating point range descriptor, step > distance
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 10.0;
+    floating_point_range.to_value = 11.0;
+    floating_point_range.step = 2.2;
+    node->declare_parameter(name, std::vector<double>({10.0, 11.0}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(), std::vector<double>({10.0, 11.0}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({12.2}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({7.8}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 11.0}));
+  }
+  {
+    // setting an array parameter with floating point range descriptor,
+    // distance not multiple of the step.
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 10.0;
+    floating_point_range.to_value = 11.0;
+    floating_point_range.step = 0.7;
+    node->declare_parameter(name, std::vector<double>({10.0, 10.7, 11.0}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(), std::vector<double>({10.0, 10.7, 11.0}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({12.2}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.7, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({11.4}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.7, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({9.3}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.7, 11.0}));
+  }
+  {
+    // setting an array parameter with floating point range descriptor, step=0
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 10.0;
+    floating_point_range.to_value = 11.0;
+    floating_point_range.step = 0.0;
+    node->declare_parameter(name, std::vector<double>({10.0, 10.0001, 10.5479051, 11.0}),
+      descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.0001, 10.5479051, 11.0}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({11.001}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.0001, 10.5479051, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({9.999}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.0001, 10.5479051, 11.0}));
+  }
   {
     // setting a parameter with a different type is still possible
     // when having a descriptor specifying a type (type is a status, not a constraint).

rclcpp/test/rclcpp/test_parameter_client.cpp

@@ -34,9 +34,9 @@ using namespace std::chrono_literals;
 class TestParameterClient : public ::testing::Test
 {
 public:
-  void OnMessage(rcl_interfaces::msg::ParameterEvent::ConstSharedPtr event)
+  void OnMessage([[maybe_unused]] rcl_interfaces::msg::ParameterEvent::ConstSharedPtr event)
   {
-    (void)event;
+    // This function is intentionally left empty.
   }
 
 protected:

rclcpp/test/rclcpp/test_parameter_events_filter.cpp

@@ -72,6 +72,13 @@ protected:
 /*
    Testing filters.
  */
+TEST_F(TestParameterEventFilter, invalide_arguments) {
+  EXPECT_THROW(
+    rclcpp::ParameterEventsFilter(nullptr, {"new"}, {nt}),
+    std::invalid_argument
+  );
+}
+
 TEST_F(TestParameterEventFilter, full_by_type) {
   auto res = rclcpp::ParameterEventsFilter(
     full,

rclcpp/test/rclcpp/test_publisher_subscription_count_api.cpp

@@ -122,9 +122,9 @@ public:
   }
 
 protected:
-  static void OnMessage(test_msgs::msg::Empty::ConstSharedPtr msg)
+  static void OnMessage([[maybe_unused]] test_msgs::msg::Empty::ConstSharedPtr msg)
   {
-    (void)msg;
+    // This function is intentionally left empty.
   }
 
   std::chrono::milliseconds offset{2000};