Implement dynamic subscription and C++ wrapper classes

Signed-off-by: methylDragon <methylDragon@gmail.com>
2024-12-30 20:25:38 -08:00
278 changed files with 7222 additions and 10750 deletions
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -0,0 +1,45 @@
+<!--
+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 -->
--- a/rclcpp/CHANGELOG.rst
+++ b/rclcpp/CHANGELOG.rst
@@ -2,136 +2,6 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

-30.1.5 (2026-02-09)
-------------------
-* remove default: so that compiler can detect the missing case. (`#3048 <https://github.com/ros2/rclcpp/issues/3048>`_)
-* use weak_ptr for rcl entities in the memory strategy. (`#2988 <https://github.com/ros2/rclcpp/issues/2988>`_)
-* remove test_static_executor_entities_collector.cpp (`#3041 <https://github.com/ros2/rclcpp/issues/3041>`_)
-* include the 1st spin that might throw the exception. (`#3042 <https://github.com/ros2/rclcpp/issues/3042>`_)
-* print warning message on owner node if the parameter operation fails. (`#3037 <https://github.com/ros2/rclcpp/issues/3037>`_)
-* fix context in wait for message wait set (`#3030 <https://github.com/ros2/rclcpp/issues/3030>`_)
-* Revert "construct wait set with passed in context (`#3021 <https://github.com/ros2/rclcpp/issues/3021>`_)" (`#3028 <https://github.com/ros2/rclcpp/issues/3028>`_)
-* construct wait set with passed in context (`#3021 <https://github.com/ros2/rclcpp/issues/3021>`_)
-* Improve the robustness of the TopicEndpointInfo constructor (`#3013 <https://github.com/ros2/rclcpp/issues/3013>`_)
-* Deprecate the shared_ptr<MessageT> subscription callback signatures (`#2975 <https://github.com/ros2/rclcpp/issues/2975>`_)
-* Contributors: Barry Xu, Maurice Alexander Purnawan, Michael Carroll, Rahat Dhande, Tomoya Fujita
-
-30.1.4 (2025-12-23)
-------------------
-* Updated deprecated ament_index_cpp API (`#3011 <https://github.com/ros2/rclcpp/issues/3011>`_)
-* Unified Node Interfaces: Add const version of get_node_x_interface() (`#3006 <https://github.com/ros2/rclcpp/issues/3006>`_)
-* Parameter Descriptor Simplification  (`#2179 <https://github.com/ros2/rclcpp/issues/2179>`_)
-* ParameterEventHandler support ContentFiltering (`#2971 <https://github.com/ros2/rclcpp/issues/2971>`_)
-* update policy_name_from_kind && test_qos (`#2156 <https://github.com/ros2/rclcpp/issues/2156>`_)
-* Add ability to disable and enable subscription's callbacks (`#2985 <https://github.com/ros2/rclcpp/issues/2985>`_)
-* Switch to isolated testing via rmw_test_fixture (`#2929 <https://github.com/ros2/rclcpp/issues/2929>`_)
-* remove I/O from signal handler. (`#2986 <https://github.com/ros2/rclcpp/issues/2986>`_)
-* Contributors: Alejandro Hernández Cordero, Andrianov Roman, Barry Xu, Lucas Wendland, Michael Orlov, Tomoya Fujita, fabianhirmann, yadunund
-
-30.1.3 (2025-11-18)
-------------------
-* correct test function descriptions (`#2970 <https://github.com/ros2/rclcpp/issues/2970>`_)
-* add : get clients, servers info (`#2569 <https://github.com/ros2/rclcpp/issues/2569>`_)
-* Fix REP url locations (`#2987 <https://github.com/ros2/rclcpp/issues/2987>`_)
-* Contributors: Minju, Lee, Tim Clephas, Yuchen966
-
-30.1.2 (2025-10-21)
-------------------
-* clear handles before node destruction in test_memory_strategy. (`#2969 <https://github.com/ros2/rclcpp/issues/2969>`_)
-* Added static assert asserting custom types have no overloaded operator new (`#2954 <https://github.com/ros2/rclcpp/issues/2954>`_)
-* Store graph listener inside the context instead of the node graph (`#2952 <https://github.com/ros2/rclcpp/issues/2952>`_)
-* Reapply "Catch the exception from rate.sleep() if the context is invalid. (`#2956 <https://github.com/ros2/rclcpp/issues/2956>`_)" (`#2963 <https://github.com/ros2/rclcpp/issues/2963>`_) (`#2964 <https://github.com/ros2/rclcpp/issues/2964>`_)
-* Revert "Catch the exception from rate.sleep() if the context is invalid. (`#2956 <https://github.com/ros2/rclcpp/issues/2956>`_)" (`#2963 <https://github.com/ros2/rclcpp/issues/2963>`_)
-* Catch the exception from rate.sleep() if the context is invalid. (`#2956 <https://github.com/ros2/rclcpp/issues/2956>`_)
-* update Time documentation (`#2955 <https://github.com/ros2/rclcpp/issues/2955>`_)
-* Contributors: Ilario A. Azzollini, Ivo Ivanov, Skyler Medeiros, Tomoya Fujita
-
-30.1.1 (2025-09-11)
-------------------
-* Removed warning (`#2949 <https://github.com/ros2/rclcpp/issues/2949>`_)
-* add note about problems with spin_until_future_complete (`#2849 <https://github.com/ros2/rclcpp/issues/2849>`_)
-* deprecate rclcpp::spin_some and rclcpp::spin_all (`#2848 <https://github.com/ros2/rclcpp/issues/2848>`_)
-* Improve the function extract_type_identifier (`#2923 <https://github.com/ros2/rclcpp/issues/2923>`_)
-* Allow for implicitly convertable loggers as well (`#2922 <https://github.com/ros2/rclcpp/issues/2922>`_)
-* Contributors: Alberto Soragna, Alejandro Hernández Cordero, Barry Xu, Tim Clephas
-
-30.1.0 (2025-07-29)
-------------------
-* Fix: improve exception context for parameter_value_from (`#2917 <https://github.com/ros2/rclcpp/issues/2917>`_)
-* Fix `start_type_description_service` param handling (`#2897 <https://github.com/ros2/rclcpp/issues/2897>`_)
-* Add qos parameter for wait_for_message function (`#2903 <https://github.com/ros2/rclcpp/issues/2903>`_)
-* Fujitatomoya/test append parameter override (`#2896 <https://github.com/ros2/rclcpp/issues/2896>`_)
-* Expose `typesupport_helpers` API needed for the Rosbag2 (`#2858 <https://github.com/ros2/rclcpp/issues/2858>`_)
-* Remove comment about now-removed StaticSingleThreadedExecutor (`#2893 <https://github.com/ros2/rclcpp/issues/2893>`_)
-* Add overload of `append_parameter_override` (`#2891 <https://github.com/ros2/rclcpp/issues/2891>`_)
-* fix: Don't deadlock if removing shutdown callbacks in a shutdown callback (`#2886 <https://github.com/ros2/rclcpp/issues/2886>`_)
-* Contributors: Christophe Bedard, Janosch Machowinski, Michael Orlov, Michiel Leegwater, Patrick Roncagliolo, Sriharsha Ghanta, Tomoya Fujita
-
-30.0.0 (2025-07-01)
-------------------
-* Hand-code logging.hpp (`#2870 <https://github.com/ros2/rclcpp/issues/2870>`_)
-* Adressed TODO in node_graph (`#2877 <https://github.com/ros2/rclcpp/issues/2877>`_)
-* fix test_publisher_with_system_default_qos. (`#2881 <https://github.com/ros2/rclcpp/issues/2881>`_)
-* Contributors: Alejandro Hernández Cordero, Chris Lalancette, Tomoya Fujita
-
-29.6.1 (2025-06-23)
-------------------
-* Fix for memory leaks in rclcpp::SerializedMessage (`#2861 <https://github.com/ros2/rclcpp/issues/2861>`_)
-* Removed warning test_qos (`#2859 <https://github.com/ros2/rclcpp/issues/2859>`_)
-* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_)
-* get_all_data_impl() does not handle null pointers properly, causing segmentation fault (`#2840 <https://github.com/ros2/rclcpp/issues/2840>`_)
-* QoSInitialization::from_rmw does not validate invalid history policy values, leading to silent failures (`#2841 <https://github.com/ros2/rclcpp/issues/2841>`_)
-* remove get_notify_guard_condition from NodeBaseInterface. (`#2839 <https://github.com/ros2/rclcpp/issues/2839>`_)
-* Removed deprecated StaticSingleThreadedExecutor (`#2835 <https://github.com/ros2/rclcpp/issues/2835>`_)
-* Removed deprecated rcpputils Path (`#2834 <https://github.com/ros2/rclcpp/issues/2834>`_)
-* Add range constraints for applicable array parameters (`#2828 <https://github.com/ros2/rclcpp/issues/2828>`_)
-* Update RingBufferImplementation to clear internal data. (`#2837 <https://github.com/ros2/rclcpp/issues/2837>`_)
-* Removed deprecated cancel_sleep_or_wait (`#2836 <https://github.com/ros2/rclcpp/issues/2836>`_)
-* Add missing 's' to 'NodeParametersInterface' in doc/comment (`#2831 <https://github.com/ros2/rclcpp/issues/2831>`_)
-* subordinate node consistent behavior and update docstring. (`#2822 <https://github.com/ros2/rclcpp/issues/2822>`_)
-* Contributors: Alejandro Hernández Cordero, Alex Youngs, Christophe Bedard, Michael Carlstrom, Michael Orlov, Tomoya Fujita
-
-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>`_)
--- a/rclcpp/CMakeLists.txt
+++ b/rclcpp/CMakeLists.txt
@@ -70,6 +70,7 @@ set(${PROJECT_NAME}_SRCS
  src/rclcpp/executors/executor_notify_waitable.cpp
  src/rclcpp/executors/multi_threaded_executor.cpp
  src/rclcpp/executors/single_threaded_executor.cpp
+  src/rclcpp/executors/static_single_threaded_executor.cpp
  src/rclcpp/expand_topic_or_service_name.cpp
  src/rclcpp/experimental/executors/events_executor/events_executor.cpp
  src/rclcpp/experimental/timers_manager.cpp
@@ -103,7 +104,6 @@ set(${PROJECT_NAME}_SRCS
  src/rclcpp/node_options.cpp
  src/rclcpp/parameter.cpp
  src/rclcpp/parameter_client.cpp
-  src/rclcpp/parameter_descriptor_wrapper.cpp
  src/rclcpp/parameter_event_handler.cpp
  src/rclcpp/parameter_events_filter.cpp
  src/rclcpp/parameter_map.cpp
@@ -113,6 +113,7 @@ 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
@@ -147,6 +148,27 @@ set(Python3_FIND_UNVERSIONED_NAMES FIRST)

 find_package(Python3 REQUIRED COMPONENTS Interpreter)

+# "watch" template for changes
+configure_file(
+  "resource/logging.hpp.em"
+  "logging.hpp.em.watch"
+  COPYONLY
+)
+# generate header with logging macros
+set(python_code_logging
+  "import em"
+  "em.invoke(['-o', 'include/rclcpp/logging.hpp', '${CMAKE_CURRENT_SOURCE_DIR}/resource/logging.hpp.em'])")
+string(REPLACE ";" "$<SEMICOLON>" python_code_logging "${python_code_logging}")
+add_custom_command(OUTPUT include/rclcpp/logging.hpp
+  COMMAND ${CMAKE_COMMAND} -E make_directory "include/rclcpp"
+  COMMAND Python3::Interpreter ARGS -c "${python_code_logging}"
+  DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/logging.hpp.em.watch"
+  COMMENT "Expanding logging.hpp.em"
+  VERBATIM
+)
+list(APPEND ${PROJECT_NAME}_SRCS
+  include/rclcpp/logging.hpp)
+
 file(GLOB interface_files "include/rclcpp/node_interfaces/node_*_interface.hpp")
 foreach(interface_file ${interface_files})
  get_filename_component(interface_name ${interface_file} NAME_WE)
--- a/rclcpp/Doxyfile
+++ b/rclcpp/Doxyfile
@@ -21,22 +21,6 @@ GENERATE_LATEX         = NO
 ENABLE_PREPROCESSING   = YES
 MACRO_EXPANSION        = YES
 EXPAND_ONLY_PREDEF     = YES
-EXCLUDE_SYMBOLS        += RCLCPP_STATIC_ASSERT_LOGGER
-EXCLUDE_SYMBOLS        += RCLCPP_LOG
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_ONCE
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_EXPRESSION
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_FUNCTION
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_SKIPFIRST
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_TIME_POINT_FUNC
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_THROTTLE
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_SKIPFIRST_THROTTLE
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_ONCE
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_EXPRESSION
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_FUNCTION
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_SKIPFIRST
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_THROTTLE
-EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
 PREDEFINED             += DOXYGEN_ONLY
 PREDEFINED             += RCLCPP_LOCAL=
 PREDEFINED             += RCLCPP_PUBLIC=
--- a/rclcpp/QUALITY_DECLARATION.md
+++ b/rclcpp/QUALITY_DECLARATION.md
@@ -1,10 +1,10 @@
-This document is a declaration of software quality for the `rclcpp` package, based on the guidelines in [REP-2004](https://reps.openrobotics.org/rep-2004/).
+This document is a declaration of software quality for the `rclcpp` package, based on the guidelines in [REP-2004](https://www.ros.org/reps/rep-2004.html).

 # rclcpp Quality Declaration

 The package `rclcpp` claims to be in the **Quality Level 1** category when it is used with a **Quality Level 1** middleware.

-Below are the rationales, notes, and caveats for this claim, organized by each requirement listed in the [Package Requirements for Quality Level 1 in REP-2004](https://reps.openrobotics.org/rep-2004/).
+Below are the rationales, notes, and caveats for this claim, organized by each requirement listed in the [Package Requirements for Quality Level 1 in REP-2004](https://www.ros.org/reps/rep-2004.html).

 ## Version Policy [1]

@@ -55,7 +55,7 @@ All pull requests will be peer-reviewed, check [ROS 2 Developer Guide](https://d

 ### Continuous Integration [2.iv]

-All pull requests must pass CI on all [tier 1 platforms](https://reps.openrobotics.org/rep-2000/#support-tiers)
+All pull requests must pass CI on all [tier 1 platforms](https://www.ros.org/reps/rep-2000.html#support-tiers)

 Currently nightly results can be seen here:

@@ -213,7 +213,7 @@ It is **Quality Level 1**, see its [Quality Declaration document](https://github

 ## Platform Support [6]

-`rclcpp` supports all of the tier 1 platforms as described in [REP-2000](https://reps.openrobotics.org/rep-2000/#support-tiers), and tests each change against all of them.
+`rclcpp` supports all of the tier 1 platforms as described in [REP-2000](https://www.ros.org/reps/rep-2000.html#support-tiers), and tests each change against all of them.

 Currently nightly build status can be seen here:
 * [linux-aarch64_release](https://ci.ros2.org/view/nightly/job/nightly_linux-aarch64_release/lastBuild/rclcpp/)
@@ -225,4 +225,4 @@ Currently nightly build status can be seen here:

 ### Vulnerability Disclosure Policy [7.i]

-This package conforms to the Vulnerability Disclosure Policy in [REP-2006](https://reps.openrobotics.org/rep-2006/).
+This package conforms to the Vulnerability Disclosure Policy in [REP-2006](https://www.ros.org/reps/rep-2006.html).
--- a/rclcpp/doc/api_review_march_2020.md
+++ b/rclcpp/doc/api_review_march_2020.md
@@ -434,3 +434,4 @@

 - (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.
+
--- a/rclcpp/doc/proposed_node_parameter_callbacks.md
+++ b/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.
--- a/rclcpp/include/rclcpp/allocator/allocator_common.hpp
+++ b/rclcpp/include/rclcpp/allocator/allocator_common.hpp
@@ -27,39 +27,10 @@ namespace rclcpp
 namespace allocator
 {

-template<typename T>
-using clean_t = std::remove_cv_t<std::remove_reference_t<T>>;
-
-// Primary template: false
-template<typename, typename = std::void_t<>>
-struct has_get_rcl_allocator : std::false_type {};
-
-// Specialization: true if expression is valid
-template<typename T>
-struct has_get_rcl_allocator<T,
-  std::void_t<
-    decltype(std::declval<clean_t<T> &>().get_rcl_allocator())
-  >
->
-  : std::bool_constant<
-    std::is_same_v<
-      decltype(std::declval<clean_t<T> &>().get_rcl_allocator()),
-      rcl_allocator_t
-    >
-  >
-{};
-
-// Helper variable template
-template<typename T>
-inline constexpr bool has_get_rcl_allocator_v =
-  has_get_rcl_allocator<T>::value;
-
 template<typename T, typename Alloc>
 using AllocRebind = typename std::allocator_traits<Alloc>::template rebind_traits<T>;

 template<typename Alloc>
-[[deprecated("Conversion of C++ allocators to C style is not valid, as the size on deallocate"
-  "can not be determined. This will be remove in future versions of ros.")]]
 void * retyped_allocate(size_t size, void * untyped_allocator)
 {
  auto typed_allocator = static_cast<Alloc *>(untyped_allocator);
@@ -70,8 +41,6 @@ void * retyped_allocate(size_t size, void * untyped_allocator)
 }

 template<typename Alloc>
-[[deprecated("Conversion of C++ allocators to C style is not valid, as the size on deallocate"
-  "can not be determined. This will be remove in future versions of ros.")]]
 void * retyped_zero_allocate(size_t number_of_elem, size_t size_of_elem, void * untyped_allocator)
 {
  auto typed_allocator = static_cast<Alloc *>(untyped_allocator);
@@ -88,8 +57,6 @@ void * retyped_zero_allocate(size_t number_of_elem, size_t size_of_elem, void *
 }

 template<typename T, typename Alloc>
-[[deprecated("Conversion of C++ allocators to C style is not valid, as the size on deallocate"
-  "can not be determined. This will be remove in future versions of ros.")]]
 void retyped_deallocate(void * untyped_pointer, void * untyped_allocator)
 {
  auto typed_allocator = static_cast<Alloc *>(untyped_allocator);
@@ -101,8 +68,6 @@ void retyped_deallocate(void * untyped_pointer, void * untyped_allocator)
 }

 template<typename T, typename Alloc>
-[[deprecated("Conversion of C++ allocators to C style is not valid, as the size on deallocate"
-  "can not be determined. This will be remove in future versions of ros.")]]
 void * retyped_reallocate(void * untyped_pointer, size_t size, void * untyped_allocator)
 {
  auto typed_allocator = static_cast<Alloc *>(untyped_allocator);
@@ -120,9 +85,6 @@ template<
  typename T,
  typename Alloc,
  typename std::enable_if<!std::is_same<Alloc, std::allocator<void>>::value>::type * = nullptr>
-[[deprecated("Conversion of C++ allocators to C style is not valid, as the size on deallocate"
-  "can not be determined. This will be remove in future versions of ros. To suppress this warning"
-  "define the method 'rcl_allocator_t get_rcl_allocator()' on your allocator")]]
 rcl_allocator_t get_rcl_allocator(Alloc & allocator)
 {
  rcl_allocator_t rcl_allocator = rcl_get_default_allocator();
--- a/rclcpp/include/rclcpp/allocator/allocator_deleter.hpp
+++ b/rclcpp/include/rclcpp/allocator/allocator_deleter.hpp
@@ -69,17 +69,18 @@ private:
 };

 template<typename Alloc, typename T, typename D>
-void set_allocator_for_deleter([[maybe_unused]] D * deleter, [[maybe_unused]] Alloc * alloc)
+void set_allocator_for_deleter(D * deleter, Alloc * alloc)
 {
+  (void) alloc;
+  (void) deleter;
  throw std::runtime_error("Reached unexpected template specialization");
 }

 template<typename T, typename U>
-void set_allocator_for_deleter(
-  [[maybe_unused]] std::default_delete<T> * deleter,
-  [[maybe_unused]] std::allocator<U> * alloc)
+void set_allocator_for_deleter(std::default_delete<T> * deleter, std::allocator<U> * alloc)
 {
-  // This function is intentionally left empty.
+  (void) deleter;
+  (void) alloc;
 }

 template<typename Alloc, typename T>
--- a/rclcpp/include/rclcpp/any_subscription_callback.hpp
+++ b/rclcpp/include/rclcpp/any_subscription_callback.hpp
@@ -15,10 +15,8 @@
 #ifndef RCLCPP__ANY_SUBSCRIPTION_CALLBACK_HPP_
 #define RCLCPP__ANY_SUBSCRIPTION_CALLBACK_HPP_

-#include <atomic>
 #include <functional>
 #include <memory>
-#include <mutex>
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
@@ -377,19 +375,7 @@ public:
    allocator::set_allocator_for_deleter(&ros_message_type_deleter_, &ros_message_type_allocator_);
  }

-  AnySubscriptionCallback(const AnySubscriptionCallback & other)
-  : callback_variant_(other.callback_variant_),
-    callback_disabled_(other.callback_disabled_.load()),
-    subscribed_type_allocator_(other.subscribed_type_allocator_),
-    subscribed_type_deleter_(other.subscribed_type_deleter_),
-    ros_message_type_allocator_(other.ros_message_type_allocator_),
-    ros_message_type_deleter_(other.ros_message_type_deleter_),
-    serialized_message_allocator_(other.serialized_message_allocator_),
-    serialized_message_deleter_(other.serialized_message_deleter_)
-  {
-    allocator::set_allocator_for_deleter(&subscribed_type_deleter_, &subscribed_type_allocator_);
-    allocator::set_allocator_for_deleter(&ros_message_type_deleter_, &ros_message_type_allocator_);
-  }
+  AnySubscriptionCallback(const AnySubscriptionCallback &) = default;

  /// Generic function for setting the callback.
  /**
@@ -407,91 +393,12 @@ public:
    // converted to one another, e.g. shared_ptr and unique_ptr.
    using scbth = detail::SubscriptionCallbackTypeHelper<MessageT, CallbackT>;

-    // Determine if the given CallbackT is a deprecated signature or not.
-    constexpr auto is_deprecated =
-      rclcpp::function_traits::same_arguments<
-      typename scbth::callback_type,
-      std::function<void(std::shared_ptr<SubscribedType>)>
-      >::value ||
-      rclcpp::function_traits::same_arguments<
-      typename scbth::callback_type,
-      std::function<void(std::shared_ptr<SubscribedType>, const rclcpp::MessageInfo &)>
-      >::value ||
-      rclcpp::function_traits::same_arguments<
-      typename scbth::callback_type,
-      std::function<void(std::shared_ptr<ROSMessageType>)>
-      >::value ||
-      rclcpp::function_traits::same_arguments<
-      typename scbth::callback_type,
-      std::function<void(std::shared_ptr<ROSMessageType>, const rclcpp::MessageInfo &)>
-      >::value ||
-      rclcpp::function_traits::same_arguments<
-      typename scbth::callback_type,
-      std::function<void(std::shared_ptr<rclcpp::SerializedMessage>)>
-      >::value ||
-      rclcpp::function_traits::same_arguments<
-      typename scbth::callback_type,
-      std::function<void(std::shared_ptr<rclcpp::SerializedMessage>, const rclcpp::MessageInfo &)>
-      >::value;
-
-    // Use the discovered type to force the type of callback when assigning
-    // into the variant.
-    if constexpr (is_deprecated) {
-      // If deprecated, call sub-routine that is deprecated.
-      set_deprecated(static_cast<typename scbth::callback_type>(callback));
-    } else {
-      // Otherwise just assign it.
-      callback_variant_ = static_cast<typename scbth::callback_type>(callback);
-    }
+    callback_variant_ = static_cast<typename scbth::callback_type>(callback);

    // Return copy of self for easier testing, normally will be compiled out.
    return *this;
  }

-  /// Function for shared_ptr to non-const MessageT, which is deprecated.
-  template<typename SetT>
-  // *INDENT-OFF*
-  #if !defined(RCLCPP_AVOID_DEPRECATIONS_FOR_UNIT_TESTS)
-  // suppress deprecation warnings in `test_any_subscription_callback.cpp`
-  [[deprecated("use 'void(std::shared_ptr<const MessageT>)' instead")]]
-  #endif
-  // *INDENT-ON*
-  void
-  set_deprecated(std::function<void(std::shared_ptr<SetT>)> callback)
-  {
-    callback_variant_ = callback;
-  }
-
-  /// Function for shared_ptr to non-const MessageT with MessageInfo, which is deprecated.
-  template<typename SetT>
-  // *INDENT-OFF*
-  #if !defined(RCLCPP_AVOID_DEPRECATIONS_FOR_UNIT_TESTS)
-  // suppress deprecation warnings in `test_any_subscription_callback.cpp`
-  [[deprecated(
-          "use 'void(std::shared_ptr<const MessageT>, const rclcpp::MessageInfo &)' instead"
-  )]]
-  #endif
-  // *INDENT-ON*
-  void
-  set_deprecated(std::function<void(std::shared_ptr<SetT>, const rclcpp::MessageInfo &)> callback)
-  {
-    callback_variant_ = callback;
-  }
-
-  /// Disable the callback from being called during dispatch.
-  void disable()
-  {
-    std::unique_lock<std::recursive_mutex> callback_lock(callback_mutex_);
-    callback_disabled_.store(true);
-  }
-
-  /// Enable the callback to be called during dispatch.
-  void enable()
-  {
-    std::unique_lock<std::recursive_mutex> callback_lock(callback_mutex_);
-    callback_disabled_.store(false);
-  }
-
  std::unique_ptr<ROSMessageType, ROSMessageTypeDeleter>
  create_ros_unique_ptr_from_ros_shared_ptr_message(
    const std::shared_ptr<const ROSMessageType> & message)
@@ -562,10 +469,6 @@ public:
    std::shared_ptr<ROSMessageType> message,
    const rclcpp::MessageInfo & message_info)
  {
-    std::unique_lock<std::recursive_mutex> callback_lock(callback_mutex_);
-    if (callback_disabled_.load()) {
-      return;
-    }
    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), false);
    // Check if the variant is "unset", throw if it is.
    if (callback_variant_.index() == 0) {
@@ -666,10 +569,6 @@ public:
    std::shared_ptr<const rclcpp::SerializedMessage> serialized_message,
    const rclcpp::MessageInfo & message_info)
  {
-    std::unique_lock<std::recursive_mutex> callback_lock(callback_mutex_);
-    if (callback_disabled_.load()) {
-      return;
-    }
    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), false);
    // Check if the variant is "unset", throw if it is.
    if (callback_variant_.index() == 0) {
@@ -749,10 +648,6 @@ public:
    std::shared_ptr<const SubscribedType> message,
    const rclcpp::MessageInfo & message_info)
  {
-    std::unique_lock<std::recursive_mutex> callback_lock(callback_mutex_);
-    if (callback_disabled_.load()) {
-      return;
-    }
    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), true);
    // Check if the variant is "unset", throw if it is.
    if (callback_variant_.index() == 0) {
@@ -883,10 +778,6 @@ public:
    std::unique_ptr<SubscribedType, SubscribedTypeDeleter> message,
    const rclcpp::MessageInfo & message_info)
  {
-    std::unique_lock<std::recursive_mutex> callback_lock(callback_mutex_);
-    if (callback_disabled_.load()) {
-      return;
-    }
    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), true);
    // Check if the variant is "unset", throw if it is.
    if (callback_variant_.index() == 0) {
@@ -1081,8 +972,6 @@ private:
  //   http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2162r0.html
  // For now, compose the variant into this class as a private attribute.
  typename HelperT::variant_type callback_variant_;
-  std::recursive_mutex callback_mutex_;
-  std::atomic_bool callback_disabled_{false};

  SubscribedTypeAllocator subscribed_type_allocator_;
  SubscribedTypeDeleter subscribed_type_deleter_;
--- a/rclcpp/include/rclcpp/callback_group.hpp
+++ b/rclcpp/include/rclcpp/callback_group.hpp
@@ -97,7 +97,7 @@ public:
  RCLCPP_PUBLIC
  explicit CallbackGroup(
    CallbackGroupType group_type,
-    const rclcpp::Context::WeakPtr & context,
+    rclcpp::Context::WeakPtr context,
    bool automatically_add_to_executor_with_node = true);

  /// Default destructor.
@@ -106,35 +106,35 @@ public:

  template<typename Function>
  rclcpp::SubscriptionBase::SharedPtr
-  find_subscription_ptrs_if(const Function & func) const
+  find_subscription_ptrs_if(Function func) const
  {
    return _find_ptrs_if_impl<rclcpp::SubscriptionBase, Function>(func, subscription_ptrs_);
  }

  template<typename Function>
  rclcpp::TimerBase::SharedPtr
-  find_timer_ptrs_if(const Function & func) const
+  find_timer_ptrs_if(Function func) const
  {
    return _find_ptrs_if_impl<rclcpp::TimerBase, Function>(func, timer_ptrs_);
  }

  template<typename Function>
  rclcpp::ServiceBase::SharedPtr
-  find_service_ptrs_if(const Function & func) const
+  find_service_ptrs_if(Function func) const
  {
    return _find_ptrs_if_impl<rclcpp::ServiceBase, Function>(func, service_ptrs_);
  }

  template<typename Function>
  rclcpp::ClientBase::SharedPtr
-  find_client_ptrs_if(const Function & func) const
+  find_client_ptrs_if(Function func) const
  {
    return _find_ptrs_if_impl<rclcpp::ClientBase, Function>(func, client_ptrs_);
  }

  template<typename Function>
  rclcpp::Waitable::SharedPtr
-  find_waitable_ptrs_if(const Function & func) const
+  find_waitable_ptrs_if(Function func) const
  {
    return _find_ptrs_if_impl<rclcpp::Waitable, Function>(func, waitable_ptrs_);
  }
@@ -179,11 +179,11 @@ public:
  RCLCPP_PUBLIC
  void
  collect_all_ptrs(
-    const std::function<void(const rclcpp::SubscriptionBase::SharedPtr &)> & sub_func,
-    const std::function<void(const rclcpp::ServiceBase::SharedPtr &)> & service_func,
-    const std::function<void(const rclcpp::ClientBase::SharedPtr &)> & client_func,
-    const std::function<void(const rclcpp::TimerBase::SharedPtr &)> & timer_func,
-    const std::function<void(const rclcpp::Waitable::SharedPtr &)> & waitable_func) const;
+    std::function<void(const rclcpp::SubscriptionBase::SharedPtr &)> sub_func,
+    std::function<void(const rclcpp::ServiceBase::SharedPtr &)> service_func,
+    std::function<void(const rclcpp::ClientBase::SharedPtr &)> client_func,
+    std::function<void(const rclcpp::TimerBase::SharedPtr &)> timer_func,
+    std::function<void(const rclcpp::Waitable::SharedPtr &)> waitable_func) const;

  /// Return a reference to the 'associated with executor' atomic boolean.
  /**
@@ -228,31 +228,31 @@ protected:

  RCLCPP_PUBLIC
  void
-  add_publisher(const rclcpp::PublisherBase::SharedPtr & publisher_ptr);
+  add_publisher(const rclcpp::PublisherBase::SharedPtr publisher_ptr);

  RCLCPP_PUBLIC
  void
-  add_subscription(const rclcpp::SubscriptionBase::SharedPtr & subscription_ptr);
+  add_subscription(const rclcpp::SubscriptionBase::SharedPtr subscription_ptr);

  RCLCPP_PUBLIC
  void
-  add_timer(const rclcpp::TimerBase::SharedPtr & timer_ptr);
+  add_timer(const rclcpp::TimerBase::SharedPtr timer_ptr);

  RCLCPP_PUBLIC
  void
-  add_service(const rclcpp::ServiceBase::SharedPtr & service_ptr);
+  add_service(const rclcpp::ServiceBase::SharedPtr service_ptr);

  RCLCPP_PUBLIC
  void
-  add_client(const rclcpp::ClientBase::SharedPtr & client_ptr);
+  add_client(const rclcpp::ClientBase::SharedPtr client_ptr);

  RCLCPP_PUBLIC
  void
-  add_waitable(const rclcpp::Waitable::SharedPtr & waitable_ptr);
+  add_waitable(const rclcpp::Waitable::SharedPtr waitable_ptr);

  RCLCPP_PUBLIC
  void
-  remove_waitable(const rclcpp::Waitable::SharedPtr & waitable_ptr) noexcept;
+  remove_waitable(const rclcpp::Waitable::SharedPtr waitable_ptr) noexcept;

  CallbackGroupType type_;
  // Mutex to protect the subsequent vectors of pointers.
@@ -274,7 +274,7 @@ protected:
 private:
  template<typename TypeT, typename Function>
  typename TypeT::SharedPtr _find_ptrs_if_impl(
-    const Function & func, const std::vector<typename TypeT::WeakPtr> & vect_ptrs) const
+    Function func, const std::vector<typename TypeT::WeakPtr> & vect_ptrs) const
  {
    std::lock_guard<std::mutex> lock(mutex_);
    for (auto & weak_ptr : vect_ptrs) {
--- a/rclcpp/include/rclcpp/client.hpp
+++ b/rclcpp/include/rclcpp/client.hpp
@@ -145,7 +145,7 @@ public:
  RCLCPP_PUBLIC
  ClientBase(
    rclcpp::node_interfaces::NodeBaseInterface * node_base,
-    const rclcpp::node_interfaces::NodeGraphInterface::SharedPtr & node_graph);
+    rclcpp::node_interfaces::NodeGraphInterface::SharedPtr node_graph);

  RCLCPP_PUBLIC
  virtual ~ClientBase() = default;
@@ -221,8 +221,7 @@ public:
  virtual std::shared_ptr<void> create_response() = 0;
  virtual std::shared_ptr<rmw_request_id_t> create_request_header() = 0;
  virtual void handle_response(
-    const std::shared_ptr<rmw_request_id_t> & request_header,
-    const std::shared_ptr<void> & response) = 0;
+    std::shared_ptr<rmw_request_id_t> request_header, std::shared_ptr<void> response) = 0;

  /// Exchange the "in use by wait set" state for this client.
  /**
@@ -297,7 +296,7 @@ public:
   * \param[in] callback functor to be called when a new response is received
   */
  void
-  set_on_new_response_callback(const std::function<void(size_t)> & callback)
+  set_on_new_response_callback(std::function<void(size_t)> callback)
  {
    if (!callback) {
      throw std::invalid_argument(
@@ -478,7 +477,7 @@ public:
   */
  Client(
    rclcpp::node_interfaces::NodeBaseInterface * node_base,
-    const rclcpp::node_interfaces::NodeGraphInterface::SharedPtr & node_graph,
+    rclcpp::node_interfaces::NodeGraphInterface::SharedPtr node_graph,
    const std::string & service_name,
    rcl_client_options_t & client_options)
  : ClientBase(node_base, node_graph),
@@ -557,8 +556,8 @@ public:
   */
  void
  handle_response(
-    const std::shared_ptr<rmw_request_id_t> & request_header,
-    const std::shared_ptr<void> & response) override
+    std::shared_ptr<rmw_request_id_t> request_header,
+    std::shared_ptr<void> response) override
  {
    std::optional<CallbackInfoVariant>
    optional_pending_request = this->get_and_erase_pending_request(request_header->sequence_number);
@@ -567,7 +566,7 @@ public:
    }
    auto & value = *optional_pending_request;
    auto typed_response = std::static_pointer_cast<typename ServiceT::Response>(
-      response);
+      std::move(response));
    if (std::holds_alternative<Promise>(value)) {
      auto & promise = std::get<Promise>(value);
      promise.set_value(std::move(typed_response));
@@ -618,7 +617,7 @@ public:
   * \return a FutureAndRequestId instance.
   */
  FutureAndRequestId
-  async_send_request(const SharedRequest & request)
+  async_send_request(SharedRequest request)
  {
    Promise promise;
    auto future = promise.get_future();
@@ -653,7 +652,7 @@ public:
    >::type * = nullptr
  >
  SharedFutureAndRequestId
-  async_send_request(const SharedRequest & request, CallbackT && cb)
+  async_send_request(SharedRequest request, CallbackT && cb)
  {
    Promise promise;
    auto shared_future = promise.get_future().share();
@@ -684,7 +683,7 @@ public:
    >::type * = nullptr
  >
  SharedFutureWithRequestAndRequestId
-  async_send_request(const SharedRequest & request, CallbackT && cb)
+  async_send_request(SharedRequest request, CallbackT && cb)
  {
    PromiseWithRequest promise;
    auto shared_future = promise.get_future().share();
@@ -790,13 +789,10 @@ 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(
-    const Clock::SharedPtr & clock, const QoS & qos_service_event_pub,
+    Clock::SharedPtr clock, const QoS & qos_service_event_pub,
    rcl_service_introspection_state_t introspection_state)
  {
    rcl_publisher_options_t pub_opts = rcl_publisher_get_default_options();
--- a/rclcpp/include/rclcpp/clock.hpp
+++ b/rclcpp/include/rclcpp/clock.hpp
@@ -60,13 +60,6 @@ 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.
   */
@@ -117,8 +110,8 @@ public:
  RCLCPP_PUBLIC
  bool
  sleep_until(
-    const Time & until,
-    const Context::SharedPtr & context = contexts::get_global_default_context());
+    Time until,
+    Context::SharedPtr context = contexts::get_global_default_context());

  /**
   * Sleep for a specified Duration.
@@ -141,8 +134,8 @@ public:
  RCLCPP_PUBLIC
  bool
  sleep_for(
-    const Duration & rel_time,
-    const Context::SharedPtr & context = contexts::get_global_default_context());
+    Duration rel_time,
+    Context::SharedPtr context = contexts::get_global_default_context());

  /**
   * Check if the clock is started.
@@ -168,7 +161,7 @@ public:
   */
  RCLCPP_PUBLIC
  bool
-  wait_until_started(const Context::SharedPtr & context = contexts::get_global_default_context());
+  wait_until_started(Context::SharedPtr context = contexts::get_global_default_context());

  /**
   * Wait for clock to start, with timeout.
@@ -186,7 +179,7 @@ public:
  bool
  wait_until_started(
    const rclcpp::Duration & timeout,
-    const Context::SharedPtr & context = contexts::get_global_default_context(),
+    Context::SharedPtr context = contexts::get_global_default_context(),
    const rclcpp::Duration & wait_tick_ns = rclcpp::Duration(0, static_cast<uint32_t>(1e7)));

  /**
@@ -200,6 +193,16 @@ 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 *
@@ -238,8 +241,8 @@ public:
  RCLCPP_PUBLIC
  JumpHandler::SharedPtr
  create_jump_callback(
-    const JumpHandler::pre_callback_t & pre_callback,
-    const JumpHandler::post_callback_t & post_callback,
+    JumpHandler::pre_callback_t pre_callback,
+    JumpHandler::post_callback_t post_callback,
    const rcl_jump_threshold_t & threshold);

 private:
@@ -257,117 +260,6 @@ 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,
-    const 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, const 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_
--- a/rclcpp/include/rclcpp/context.hpp
+++ b/rclcpp/include/rclcpp/context.hpp
@@ -37,10 +37,6 @@

 namespace rclcpp
 {
-namespace graph_listener
-{
-class GraphListener;
-}  // namespace graph_listener

 /// Thrown when init is called on an already initialized context.
 class ContextAlreadyInitialized : public std::runtime_error
@@ -229,7 +225,7 @@ public:
  RCLCPP_PUBLIC
  virtual
  OnShutdownCallback
-  on_shutdown(const OnShutdownCallback & callback);
+  on_shutdown(OnShutdownCallback callback);

  /// Add a on_shutdown callback to be called when shutdown is called for this context.
  /**
@@ -253,7 +249,7 @@ public:
  RCLCPP_PUBLIC
  virtual
  OnShutdownCallbackHandle
-  add_on_shutdown_callback(const OnShutdownCallback & callback);
+  add_on_shutdown_callback(OnShutdownCallback callback);

  /// Remove an registered on_shutdown callbacks.
  /**
@@ -280,7 +276,7 @@ public:
  RCLCPP_PUBLIC
  virtual
  PreShutdownCallbackHandle
-  add_pre_shutdown_callback(const PreShutdownCallback & callback);
+  add_pre_shutdown_callback(PreShutdownCallback callback);

  /// Remove an registered pre_shutdown callback.
  /**
@@ -313,10 +309,6 @@ public:
  std::shared_ptr<rcl_context_t>
  get_rcl_context();

-  RCLCPP_PUBLIC
-  std::shared_ptr<rclcpp::graph_listener::GraphListener>
-  get_graph_listener();
-
  /// Sleep for a given period of time or until shutdown() is called.
  /**
   * This function can be interrupted early if:
@@ -389,19 +381,16 @@ private:
  std::recursive_mutex sub_contexts_mutex_;

  std::vector<std::shared_ptr<OnShutdownCallback>> on_shutdown_callbacks_;
-  mutable std::recursive_mutex on_shutdown_callbacks_mutex_;
+  mutable std::mutex on_shutdown_callbacks_mutex_;

  std::vector<std::shared_ptr<PreShutdownCallback>> pre_shutdown_callbacks_;
-  mutable std::recursive_mutex pre_shutdown_callbacks_mutex_;
+  mutable std::mutex pre_shutdown_callbacks_mutex_;

  /// Condition variable for timed sleep (see sleep_for).
  std::condition_variable interrupt_condition_variable_;
  /// Mutex for protecting the global condition variable.
  std::mutex interrupt_mutex_;

-  /// Graph Listener which waits on graph changes for the node and is shared across nodes.
-  std::shared_ptr<rclcpp::graph_listener::GraphListener> graph_listener_;
-
  /// Keep shared ownership of global vector of weak contexts
  std::shared_ptr<WeakContextsWrapper> weak_contexts_;

@@ -417,7 +406,7 @@ private:
  RCLCPP_LOCAL
  ShutdownCallbackHandle
  add_shutdown_callback(
-    const ShutdownCallback & callback);
+    ShutdownCallback callback);

  template<ShutdownType shutdown_type>
  RCLCPP_LOCAL
--- a/rclcpp/include/rclcpp/create_generic_client.hpp
+++ b/rclcpp/include/rclcpp/create_generic_client.hpp
@@ -46,13 +46,13 @@ namespace rclcpp
 RCLCPP_PUBLIC
 rclcpp::GenericClient::SharedPtr
 create_generic_client(
-  const std::shared_ptr<node_interfaces::NodeBaseInterface> & node_base,
-  const std::shared_ptr<node_interfaces::NodeGraphInterface> & node_graph,
-  const std::shared_ptr<node_interfaces::NodeServicesInterface> & node_services,
+  std::shared_ptr<node_interfaces::NodeBaseInterface> node_base,
+  std::shared_ptr<node_interfaces::NodeGraphInterface> node_graph,
+  std::shared_ptr<node_interfaces::NodeServicesInterface> node_services,
  const std::string & service_name,
  const std::string & service_type,
  const rclcpp::QoS & qos = rclcpp::ServicesQoS(),
-  const rclcpp::CallbackGroup::SharedPtr & group = rclcpp::CallbackGroup::SharedPtr());
+  rclcpp::CallbackGroup::SharedPtr group = nullptr);

 /// Create a generic service client with a name of given type.
 /**
--- a/rclcpp/include/rclcpp/detail/qos_parameters.hpp
+++ b/rclcpp/include/rclcpp/detail/qos_parameters.hpp
@@ -97,9 +97,6 @@ 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 &) {
@@ -270,8 +267,8 @@ apply_qos_override(
      RCLCPP_DETAIL_APPLY_QOS_OVERRIDE_FROM_PARAMETER_STRING(
        reliability, RELIABILITY, value, qos);
      break;
-    case QosPolicyKind::Invalid:
-      throw std::invalid_argument{"invalid QosPolicyKind"};
+    default:
+      throw std::invalid_argument{"unknown QosPolicyKind"};
  }
 }

@@ -332,11 +329,9 @@ get_default_qos_param_value(rclcpp::QosPolicyKind kind, const rclcpp::QoS & qos)
      return ParameterValue(
        check_if_stringified_policy_is_null(
          rmw_qos_reliability_policy_to_str(rmw_qos.reliability), kind));
-    case QosPolicyKind::Invalid:
-      throw std::invalid_argument{"invalid QoS policy kind"};
+    default:
+      throw std::invalid_argument{"unknown QoS policy kind"};
  }
-
-  return ParameterValue();
 }

 }  // namespace detail
--- a/rclcpp/include/rclcpp/detail/resolve_enable_topic_statistics.hpp
+++ b/rclcpp/include/rclcpp/detail/resolve_enable_topic_statistics.hpp
@@ -29,7 +29,7 @@ template<typename OptionsT, typename NodeBaseT>
 bool
 resolve_enable_topic_statistics(const OptionsT & options, const NodeBaseT & node_base)
 {
-  bool topic_stats_enabled = false;
+  bool topic_stats_enabled;
  switch (options.topic_stats_options.state) {
    case TopicStatisticsState::Enable:
      topic_stats_enabled = true;
--- a/rclcpp/include/rclcpp/detail/resolve_use_intra_process.hpp
+++ b/rclcpp/include/rclcpp/detail/resolve_use_intra_process.hpp
@@ -30,7 +30,7 @@ template<typename OptionsT, typename NodeBaseT>
 bool
 resolve_use_intra_process(const OptionsT & options, const NodeBaseT & node_base)
 {
-  bool use_intra_process = false;
+  bool use_intra_process;
  switch (options.use_intra_process_comm) {
    case IntraProcessSetting::Enable:
      use_intra_process = true;
@@ -43,6 +43,7 @@ resolve_use_intra_process(const OptionsT & options, const NodeBaseT & node_base)
      break;
    default:
      throw std::runtime_error("Unrecognized IntraProcessSetting value");
+      break;
  }

  return use_intra_process;
--- a/rclcpp/include/rclcpp/dynamic_subscription.hpp
+++ b/rclcpp/include/rclcpp/dynamic_subscription.hpp
@@ -0,0 +1,175 @@
+// 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_
--- a/rclcpp/include/rclcpp/dynamic_typesupport/detail/dynamic_message_impl.hpp
+++ b/rclcpp/include/rclcpp/dynamic_typesupport/detail/dynamic_message_impl.hpp
@@ -0,0 +1,327 @@
+// 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_
--- a/rclcpp/include/rclcpp/dynamic_typesupport/detail/dynamic_message_type_builder_impl.hpp
+++ b/rclcpp/include/rclcpp/dynamic_typesupport/detail/dynamic_message_type_builder_impl.hpp
@@ -0,0 +1,189 @@
+// 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_
--- a/rclcpp/include/rclcpp/dynamic_typesupport/dynamic_message.hpp
+++ b/rclcpp/include/rclcpp/dynamic_typesupport/dynamic_message.hpp
@@ -32,16 +32,372 @@ namespace rclcpp
 namespace dynamic_typesupport
 {

+class DynamicMessageType;
+class DynamicMessageTypeBuilder;
+
 /// Utility wrapper class for rosidl_dynamic_typesupport_dynamic_data_t
-/// STUBBED OUT
+/**
+ * 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.
+ */
 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
@@ -62,6 +418,12 @@ 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
--- a/rclcpp/include/rclcpp/dynamic_typesupport/dynamic_message_type.hpp
+++ b/rclcpp/include/rclcpp/dynamic_typesupport/dynamic_message_type.hpp
@@ -30,16 +30,143 @@ namespace rclcpp
 namespace dynamic_typesupport
 {

+class DynamicMessage;
+class DynamicMessageTypeBuilder;
+
 /// Utility wrapper class for `rosidl_dynamic_typesupport_dynamic_type_t`
-/// STUBBED OUT
+/**
+ * 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.
+ */
 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
@@ -56,6 +183,12 @@ 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
--- a/rclcpp/include/rclcpp/dynamic_typesupport/dynamic_message_type_builder.hpp
+++ b/rclcpp/include/rclcpp/dynamic_typesupport/dynamic_message_type_builder.hpp
@@ -30,16 +30,347 @@ namespace rclcpp
 namespace dynamic_typesupport
 {

+class DynamicMessage;
+class DynamicMessageType;
+
 /// Utility wrapper class for `rosidl_dynamic_typesupport_dynamic_type_builder_t *`
-/// STUBBED OUT
+/**
+ * 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.
+ */
 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
@@ -56,6 +387,19 @@ 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
--- a/rclcpp/include/rclcpp/dynamic_typesupport/dynamic_message_type_support.hpp
+++ b/rclcpp/include/rclcpp/dynamic_typesupport/dynamic_message_type_support.hpp
@@ -38,16 +38,115 @@ namespace dynamic_typesupport
 {

 /// Utility wrapper class for `rosidl_message_type_support_t` containing managed
-/// STUBBED OUT
+/// 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.
+ */
 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_;
--- a/rclcpp/include/rclcpp/dynamic_typesupport/dynamic_serialization_support.hpp
+++ b/rclcpp/include/rclcpp/dynamic_typesupport/dynamic_serialization_support.hpp
@@ -31,22 +31,60 @@ 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_;

--- a/rclcpp/include/rclcpp/event_handler.hpp
+++ b/rclcpp/include/rclcpp/event_handler.hpp
@@ -15,13 +15,11 @@
 #ifndef RCLCPP__EVENT_HANDLER_HPP_
 #define RCLCPP__EVENT_HANDLER_HPP_

-#include <atomic>
 #include <functional>
 #include <memory>
 #include <mutex>
 #include <stdexcept>
 #include <string>
-#include <vector>

 #include "rcl/error_handling.h"
 #include "rcl/event_callback.h"
@@ -111,14 +109,6 @@ public:
  RCLCPP_PUBLIC
  virtual ~EventHandlerBase();

-  RCLCPP_PUBLIC
-  virtual
-  void enable() = 0;
-
-  RCLCPP_PUBLIC
-  virtual
-  void disable() = 0;
-
  /// Get the number of ready events
  RCLCPP_PUBLIC
  size_t
@@ -201,7 +191,7 @@ public:
        }
      };

-    std::lock_guard<std::recursive_mutex> lock(on_new_event_callback_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);

    // Set it temporarily to the new callback, while we replace the old one.
    // This two-step setting, prevents a gap where the old std::function has
@@ -224,26 +214,19 @@ public:
  void
  clear_on_ready_callback() override
  {
-    std::lock_guard<std::recursive_mutex> lock(on_new_event_callback_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);
    if (on_new_event_callback_) {
      set_on_new_event_callback(nullptr, nullptr);
      on_new_event_callback_ = nullptr;
    }
  }

-  RCLCPP_PUBLIC
-  std::vector<std::shared_ptr<rclcpp::TimerBase>>
-  get_timers() const override
-  {
-    return {};
-  }
-
 protected:
  RCLCPP_PUBLIC
  void
  set_on_new_event_callback(rcl_event_callback_t callback, const void * user_data);

-  std::recursive_mutex on_new_event_callback_mutex_;
+  std::recursive_mutex callback_mutex_;
  std::function<void(size_t)> on_new_event_callback_{nullptr};

  rcl_event_t event_handle_;
@@ -295,15 +278,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([[maybe_unused]] size_t id) override
+  take_data_by_entity_id(size_t id) override
  {
+    (void)id;
    return take_data();
  }

@@ -311,10 +294,6 @@ public:
  void
  execute(const std::shared_ptr<void> & data) override
  {
-    std::unique_lock<std::mutex> event_callback_lock(event_callback_mutex_);
-    if (disabled_.load()) {
-      return;
-    }
    if (!data) {
      throw std::runtime_error("'data' is empty");
    }
@@ -323,53 +302,12 @@ public:
    callback_ptr.reset();
  }

-  /// Disable the event callback from being called when execute(..) invoked
-  /**
-   * This will also temporarily remove the on_new_event_callback from the underlying rmw layer,
-   *  so that it is not called from the middleware while disabled.
-   */
-  void disable() override
-  {
-    {
-      // Temporary remove the on_new_event_callback_ to prevent it from being called
-      std::lock_guard<std::recursive_mutex> on_new_event_lock(on_new_event_callback_mutex_);
-      if (on_new_event_callback_) {
-        set_on_new_event_callback(nullptr, nullptr);
-      }
-    }
-    std::lock_guard<std::mutex> event_callback_lock(event_callback_mutex_);
-    disabled_.store(true);
-  }
-
-  /// Enable the event callback to be called when execute(..) invoked
-  /**
-   * This will also set back the on_new_event_callback to the underlying rmw layer, if it was
-   * previously removed with disable().
-   */
-  void enable() override
-  {
-    {
-      // Set callback again if it was previously removed in disable()
-      std::lock_guard<std::recursive_mutex> on_new_event_lock(on_new_event_callback_mutex_);
-      if (on_new_event_callback_) {
-        set_on_new_event_callback(
-          rclcpp::detail::cpp_callback_trampoline<
-            decltype(on_new_event_callback_), const void *, size_t>,
-          static_cast<const void *>(&on_new_event_callback_));
-      }
-    }
-    std::lock_guard<std::mutex> event_callback_lock(event_callback_mutex_);
-    disabled_.store(false);
-  }
-
 private:
  using EventCallbackInfoT = typename std::remove_reference<typename
      rclcpp::function_traits::function_traits<EventCallbackT>::template argument_type<0>>::type;

  ParentHandleT parent_handle_;
  EventCallbackT event_callback_;
-  std::mutex event_callback_mutex_;
-  std::atomic_bool disabled_{false};
 };
 }  // namespace rclcpp

--- a/rclcpp/include/rclcpp/executor.hpp
+++ b/rclcpp/include/rclcpp/executor.hpp
@@ -102,8 +102,8 @@ public:
  RCLCPP_PUBLIC
  virtual void
  add_callback_group(
-    const rclcpp::CallbackGroup::SharedPtr & group_ptr,
-    const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_ptr,
+    rclcpp::CallbackGroup::SharedPtr group_ptr,
+    rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
    bool notify = true);

  /// Get callback groups that belong to executor.
@@ -173,7 +173,7 @@ public:
  RCLCPP_PUBLIC
  virtual void
  remove_callback_group(
-    const rclcpp::CallbackGroup::SharedPtr & group_ptr,
+    rclcpp::CallbackGroup::SharedPtr group_ptr,
    bool notify = true);

  /// Add a node to the executor.
@@ -197,9 +197,7 @@ public:
   */
  RCLCPP_PUBLIC
  virtual void
-  add_node(
-    const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_ptr,
-    bool notify = true);
+  add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify = true);

  /// Convenience function which takes Node and forwards NodeBaseInterface.
  /**
@@ -207,7 +205,7 @@ public:
   */
  RCLCPP_PUBLIC
  virtual void
-  add_node(const std::shared_ptr<rclcpp::Node> & node_ptr, bool notify = true);
+  add_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify = true);

  /// Remove a node from the executor.
  /**
@@ -227,9 +225,7 @@ public:
   */
  RCLCPP_PUBLIC
  virtual void
-  remove_node(
-    const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_ptr,
-    bool notify = true);
+  remove_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify = true);

  /// Convenience function which takes Node and forwards NodeBaseInterface.
  /**
@@ -237,7 +233,7 @@ public:
   */
  RCLCPP_PUBLIC
  virtual void
-  remove_node(const std::shared_ptr<rclcpp::Node> & node_ptr, bool notify = true);
+  remove_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify = true);

  /// Add a node to executor, execute the next available unit of work, and remove the node.
  /**
@@ -249,7 +245,7 @@ public:
  template<typename RepT = int64_t, typename T = std::milli>
  void
  spin_node_once(
-    const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node,
+    rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node,
    std::chrono::duration<RepT, T> timeout = std::chrono::duration<RepT, T>(-1))
  {
    return spin_node_once_nanoseconds(
@@ -262,7 +258,7 @@ public:
  template<typename NodeT = rclcpp::Node, typename RepT = int64_t, typename T = std::milli>
  void
  spin_node_once(
-    const std::shared_ptr<NodeT> & node,
+    std::shared_ptr<NodeT> node,
    std::chrono::duration<RepT, T> timeout = std::chrono::duration<RepT, T>(-1))
  {
    return spin_node_once_nanoseconds(
@@ -277,12 +273,12 @@ public:
   */
  RCLCPP_PUBLIC
  virtual void
-  spin_node_some(const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node);
+  spin_node_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node);

  /// Convenience function which takes Node and forwards NodeBaseInterface.
  RCLCPP_PUBLIC
  virtual void
-  spin_node_some(const std::shared_ptr<rclcpp::Node> & node);
+  spin_node_some(std::shared_ptr<rclcpp::Node> node);

  /// Collect work once and execute all available work, optionally within a max duration.
  /**
@@ -291,18 +287,6 @@ 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
@@ -325,13 +309,13 @@ public:
  RCLCPP_PUBLIC
  virtual void
  spin_node_all(
-    const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node,
+    rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node,
    std::chrono::nanoseconds max_duration);

  /// Convenience function which takes Node and forwards NodeBaseInterface.
  RCLCPP_PUBLIC
  virtual void
-  spin_node_all(const std::shared_ptr<rclcpp::Node> & node, std::chrono::nanoseconds max_duration);
+  spin_node_all(std::shared_ptr<rclcpp::Node> node, std::chrono::nanoseconds max_duration);

  /// Collect and execute work repeatedly within a duration or until no more work is available.
  /**
@@ -375,9 +359,6 @@ public:
   *   If the time spent inside the blocking loop exceeds this timeout, return a TIMEOUT return
   *   code.
   * \return The return code, one of `SUCCESS`, `INTERRUPTED`, or `TIMEOUT`.
-   * \note This method will check the future and the timeout only when the executor is woken up.
-   *   If this future is unrelated to an executor's entity, this method will not correctly detect
-   *   when it's completed and therefore may wait forever and never time out.
   */
  template<typename FutureT, typename TimeRepT = int64_t, typename TimeT = std::milli>
  FutureReturnCode
@@ -431,7 +412,7 @@ protected:
  RCLCPP_PUBLIC
  void
  spin_node_once_nanoseconds(
-    const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node,
+    rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node,
    std::chrono::nanoseconds timeout);

  /// Spin (blocking) until the future is complete, it times out waiting, or rclcpp is interrupted.
@@ -482,7 +463,7 @@ protected:
  RCLCPP_PUBLIC
  static void
  execute_subscription(
-    const rclcpp::SubscriptionBase::SharedPtr & subscription);
+    rclcpp::SubscriptionBase::SharedPtr subscription);

  /// Run timer executable.
  /**
@@ -491,7 +472,7 @@ protected:
   */
  RCLCPP_PUBLIC
  static void
-  execute_timer(const rclcpp::TimerBase::SharedPtr & timer, const std::shared_ptr<void> & data_ptr);
+  execute_timer(rclcpp::TimerBase::SharedPtr timer, const std::shared_ptr<void> & data_ptr);

  /// Run service server executable.
  /**
@@ -500,7 +481,7 @@ protected:
   */
  RCLCPP_PUBLIC
  static void
-  execute_service(const rclcpp::ServiceBase::SharedPtr & service);
+  execute_service(rclcpp::ServiceBase::SharedPtr service);

  /// Run service client executable.
  /**
@@ -509,7 +490,7 @@ protected:
   */
  RCLCPP_PUBLIC
  static void
-  execute_client(const rclcpp::ClientBase::SharedPtr & client);
+  execute_client(rclcpp::ClientBase::SharedPtr client);

  /// Gather all of the waitable entities from associated nodes and callback groups.
  RCLCPP_PUBLIC
--- a/rclcpp/include/rclcpp/executors.hpp
+++ b/rclcpp/include/rclcpp/executors.hpp
@@ -20,6 +20,7 @@

 #include "rclcpp/executors/multi_threaded_executor.hpp"
 #include "rclcpp/executors/single_threaded_executor.hpp"
+#include "rclcpp/executors/static_single_threaded_executor.hpp"
 #include "rclcpp/experimental/executors/events_executor/events_executor.hpp"
 #include "rclcpp/node.hpp"
 #include "rclcpp/utilities.hpp"
@@ -28,95 +29,37 @@
 namespace rclcpp
 {

-/**
- * @brief Create a default single-threaded executor and execute all available work exhaustively.
- * @param node_ptr Shared pointer to the base interface of the node to spin.
- * @param max_duration max duration to spin
- *
- * This method is deprecated because it can lead to very bad performance if used in a loop:
- * each call will create a new executor and register the node, which is an expensive operation.
- * It's recommended to always manually instantiate an executor and call the methods with
- * the same name on it.
- * For example:
- *     SingleThreadedExecutor executor;
- *     executor.add_node(node_ptr);
- *     executor.spin_all(max_duration);
- * If you are using a non-default context, this should be passed to the executor's constructor.
- */
-[[deprecated("use SingleThreadedExecutor::spin_all instead")]]
+/// Create a default single-threaded executor and execute all available work exhaustively.
+/** \param[in] node_ptr Shared pointer to the node to spin. */
 RCLCPP_PUBLIC
 void
 spin_all(
-  const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_ptr,
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
  std::chrono::nanoseconds max_duration);

-/**
- * @brief Create a default single-threaded executor and execute all available work exhaustively.
- * @param node_ptr Shared pointer to the node to spin.
- * @param max_duration max duration to spin
- *
- * This method is deprecated because it can lead to very bad performance if used in a loop:
- * each call will create a new executor and register the node, which is an expensive operation.
- * It's recommended to always manually instantiate an executor and call the methods with
- * the same name on it.
- * For example:
- *     SingleThreadedExecutor executor;
- *     executor.add_node(node_ptr);
- *     executor.spin_all(max_duration);
- * If you are using a non-default context, this should be passed to the executor's constructor.
- */
-[[deprecated("use SingleThreadedExecutor::spin_all instead")]]
 RCLCPP_PUBLIC
 void
-spin_all(const rclcpp::Node::SharedPtr & node_ptr, std::chrono::nanoseconds max_duration);
+spin_all(rclcpp::Node::SharedPtr node_ptr, std::chrono::nanoseconds max_duration);

-/**
- * @brief Create a default single-threaded executor and execute any immediately available work.
- * @param node_ptr Shared pointer to the base interface of the node to spin.
- *
- * This method is deprecated because it can lead to very bad performance if used in a loop:
- * each call will create a new executor and register the node, which is an expensive operation.
- * It's recommended to always manually instantiate an executor and call the methods with
- * the same name on it.
- * For example:
- *     SingleThreadedExecutor executor;
- *     executor.add_node(node_ptr);
- *     executor.spin_some();
- * If you are using a non-default context, this should be passed to the executor's constructor.
- */
-[[deprecated("use SingleThreadedExecutor::spin_some instead")]]
+/// Create a default single-threaded executor and execute any immediately available work.
+/** \param[in] node_ptr Shared pointer to the node to spin. */
 RCLCPP_PUBLIC
 void
-spin_some(const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_ptr);
+spin_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr);

-/**
- * @brief Create a default single-threaded executor and execute any immediately available work.
- * @param node_ptr Shared pointer to the node to spin.
- *
- * This method is deprecated because it can lead to very bad performance if used in a loop:
- * each call will create a new executor and register the node, which is an expensive operation.
- * It's recommended to always manually instantiate an executor and call the methods with
- * the same name on it.
- * For example:
- *     SingleThreadedExecutor executor;
- *     executor.add_node(node_ptr);
- *     executor.spin_some();
- * If you are using a non-default context, this should be passed to the executor's constructor.
- */
-[[deprecated("use SingleThreadedExecutor::spin_some instead")]]
 RCLCPP_PUBLIC
 void
-spin_some(const rclcpp::Node::SharedPtr & node_ptr);
+spin_some(rclcpp::Node::SharedPtr node_ptr);

 /// Create a default single-threaded executor and spin the specified node.
 /** \param[in] node_ptr Shared pointer to the node to spin. */
 RCLCPP_PUBLIC
 void
-spin(const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_ptr);
+spin(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr);

 RCLCPP_PUBLIC
 void
-spin(const rclcpp::Node::SharedPtr & node_ptr);
+spin(rclcpp::Node::SharedPtr node_ptr);

 namespace executors
 {
@@ -140,7 +83,7 @@ template<typename FutureT, typename TimeRepT = int64_t, typename TimeT = std::mi
 rclcpp::FutureReturnCode
 spin_node_until_future_complete(
  rclcpp::Executor & executor,
-  const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_ptr,
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
  const FutureT & future,
  std::chrono::duration<TimeRepT, TimeT> timeout = std::chrono::duration<TimeRepT, TimeT>(-1))
 {
@@ -157,7 +100,7 @@ template<typename NodeT = rclcpp::Node, typename FutureT, typename TimeRepT = in
 rclcpp::FutureReturnCode
 spin_node_until_future_complete(
  rclcpp::Executor & executor,
-  const std::shared_ptr<NodeT> & node_ptr,
+  std::shared_ptr<NodeT> node_ptr,
  const FutureT & future,
  std::chrono::duration<TimeRepT, TimeT> timeout = std::chrono::duration<TimeRepT, TimeT>(-1))
 {
@@ -173,7 +116,7 @@ spin_node_until_future_complete(
 template<typename FutureT, typename TimeRepT = int64_t, typename TimeT = std::milli>
 rclcpp::FutureReturnCode
 spin_until_future_complete(
-  const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_ptr,
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
  const FutureT & future,
  std::chrono::duration<TimeRepT, TimeT> timeout = std::chrono::duration<TimeRepT, TimeT>(-1))
 {
@@ -187,7 +130,7 @@ template<typename NodeT = rclcpp::Node, typename FutureT, typename TimeRepT = in
  typename TimeT = std::milli>
 rclcpp::FutureReturnCode
 spin_until_future_complete(
-  const std::shared_ptr<NodeT> & node_ptr,
+  std::shared_ptr<NodeT> node_ptr,
  const FutureT & future,
  std::chrono::duration<TimeRepT, TimeT> timeout = std::chrono::duration<TimeRepT, TimeT>(-1))
 {
--- a/rclcpp/include/rclcpp/executors/executor_entities_collector.hpp
+++ b/rclcpp/include/rclcpp/executors/executor_entities_collector.hpp
@@ -63,7 +63,7 @@ public:
   */
  RCLCPP_PUBLIC
  explicit ExecutorEntitiesCollector(
-    const std::shared_ptr<ExecutorNotifyWaitable> & notify_waitable);
+    std::shared_ptr<ExecutorNotifyWaitable> notify_waitable);

  /// Destructor
  RCLCPP_PUBLIC
@@ -82,7 +82,7 @@ public:
   */
  RCLCPP_PUBLIC
  void
-  add_node(const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_ptr);
+  add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr);

  /// Remove a node from the entity collector
  /**
@@ -92,7 +92,7 @@ public:
   */
  RCLCPP_PUBLIC
  void
-  remove_node(const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_ptr);
+  remove_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr);

  /// Add a callback group to the entity collector
  /**
@@ -101,7 +101,7 @@ public:
   */
  RCLCPP_PUBLIC
  void
-  add_callback_group(const rclcpp::CallbackGroup::SharedPtr & group_ptr);
+  add_callback_group(rclcpp::CallbackGroup::SharedPtr group_ptr);

  /// Remove a callback group from the entity collector
  /**
@@ -111,7 +111,7 @@ public:
   */
  RCLCPP_PUBLIC
  void
-  remove_callback_group(const rclcpp::CallbackGroup::SharedPtr & group_ptr);
+  remove_callback_group(rclcpp::CallbackGroup::SharedPtr group_ptr);

  /// Get all callback groups known to this entity collector
  /**
@@ -211,7 +211,7 @@ protected:
  RCLCPP_PUBLIC
  void
  add_callback_group_to_collection(
-    const rclcpp::CallbackGroup::SharedPtr & group_ptr,
+    rclcpp::CallbackGroup::SharedPtr group_ptr,
    CallbackGroupCollection & collection)  RCPPUTILS_TSA_REQUIRES(mutex_);

  /// Iterate over queued added/remove nodes and callback_groups
--- a/rclcpp/include/rclcpp/executors/executor_notify_waitable.hpp
+++ b/rclcpp/include/rclcpp/executors/executor_notify_waitable.hpp
@@ -19,7 +19,6 @@
 #include <memory>
 #include <mutex>
 #include <set>
-#include <vector>

 #include "rclcpp/guard_condition.hpp"
 #include "rclcpp/waitable.hpp"
@@ -42,10 +41,7 @@ public:
   *   of this waitable has signaled the wait_set.
   */
  RCLCPP_PUBLIC
-  explicit ExecutorNotifyWaitable(
-    const std::function<void(void)> & on_execute_callback = {},
-    const rclcpp::Context::SharedPtr & context =
-    rclcpp::contexts::get_global_default_context());
+  explicit ExecutorNotifyWaitable(std::function<void(void)> on_execute_callback = {});

  // Destructor
  RCLCPP_PUBLIC
@@ -116,7 +112,7 @@ public:
   */
  RCLCPP_PUBLIC
  void
-  add_guard_condition(const rclcpp::GuardCondition::WeakPtr & guard_condition);
+  add_guard_condition(rclcpp::GuardCondition::WeakPtr guard_condition);

  /// Unset any callback registered via set_on_ready_callback.
  /**
@@ -140,7 +136,7 @@ public:
   */
  RCLCPP_PUBLIC
  void
-  remove_guard_condition(const rclcpp::GuardCondition::WeakPtr & weak_guard_condition);
+  remove_guard_condition(rclcpp::GuardCondition::WeakPtr weak_guard_condition);

  /// Get the number of ready guard_conditions
  /**
@@ -150,14 +146,6 @@ 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_;
@@ -170,17 +158,8 @@ private:
  std::function<void(size_t)> on_ready_callback_;

  /// The collection of guard conditions to be waited on.
-  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_;
+  std::set<rclcpp::GuardCondition::WeakPtr,
+    std::owner_less<rclcpp::GuardCondition::WeakPtr>> notify_guard_conditions_;
 };

 }  // namespace executors
--- a/rclcpp/include/rclcpp/executors/static_single_threaded_executor.hpp
+++ b/rclcpp/include/rclcpp/executors/static_single_threaded_executor.hpp
@@ -0,0 +1,145 @@
+// Copyright 2019 Nobleo Technology
+//
+// 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__EXECUTORS__STATIC_SINGLE_THREADED_EXECUTOR_HPP_
+#define RCLCPP__EXECUTORS__STATIC_SINGLE_THREADED_EXECUTOR_HPP_
+
+#include <atomic>
+#include <chrono>
+#include <memory>
+
+#include "rclcpp/executor.hpp"
+#include "rclcpp/executors/executor_entities_collection.hpp"
+#include "rclcpp/executors/single_threaded_executor.hpp"
+
+namespace rclcpp
+{
+namespace executors
+{
+
+/// Static executor implementation
+/**
+ * This executor is a static version of the original single threaded executor.
+ * It contains some performance optimization to avoid unnecessary reconstructions of
+ * the executable list for every iteration.
+ * All nodes, callbackgroups, timers, subscriptions etc. are created before
+ * spin() is called, and modified only when an entity is added/removed to/from a node.
+ * This executor is deprecated because these performance improvements have now been
+ * applied to all other executors.
+ * This executor is also considered unstable due to known bugs.
+ * See the unit-tests that are only applied to `StandardExecutors` for information
+ * on the known limitations.
+ *
+ * To run this executor instead of SingleThreadedExecutor replace:
+ * rclcpp::executors::SingleThreadedExecutor exec;
+ * by
+ * rclcpp::executors::StaticSingleThreadedExecutor exec;
+ * in your source code and spin node(s) in the following way:
+ * exec.add_node(node);
+ * exec.spin();
+ * exec.remove_node(node);
+ */
+class [[deprecated("Use rclcpp::executors::SingleThreadedExecutor")]] StaticSingleThreadedExecutor
+  : public rclcpp::Executor
+{
+public:
+  RCLCPP_SMART_PTR_DEFINITIONS(StaticSingleThreadedExecutor)
+
+  /// Default constructor. See the default constructor for Executor.
+  RCLCPP_PUBLIC
+  explicit StaticSingleThreadedExecutor(
+    const rclcpp::ExecutorOptions & options = rclcpp::ExecutorOptions());
+
+  /// Default destructor.
+  RCLCPP_PUBLIC
+  virtual ~StaticSingleThreadedExecutor();
+
+  /// Static executor implementation of spin.
+  /**
+   * This function will block until work comes in, execute it, and keep blocking.
+   * It will only be interrupted by a CTRL-C (managed by the global signal handler).
+   * \throws std::runtime_error when spin() called while already spinning
+   */
+  RCLCPP_PUBLIC
+  void
+  spin() override;
+
+  /// Static executor implementation of spin some
+  /**
+   * This non-blocking function will execute entities that
+   * were ready when this API was called, until timeout or no
+   * more work available. Entities that got ready while
+   * executing work, won't be taken into account here.
+   *
+   * Example:
+   *   while(condition) {
+   *     spin_some();
+   *     sleep(); // User should have some sync work or
+   *              // sleep to avoid a 100% CPU usage
+   *   }
+   */
+  RCLCPP_PUBLIC
+  void
+  spin_some(std::chrono::nanoseconds max_duration = std::chrono::nanoseconds(0)) override;
+
+  /// Static executor implementation of spin all
+  /**
+   * This non-blocking function will execute entities until timeout (must be >= 0)
+   * or no more work available.
+   * If timeout is `0`, potentially it blocks forever until no more work is available.
+   * If new entities get ready while executing work available, they will be executed
+   * as long as the timeout hasn't expired.
+   *
+   * Example:
+   *   while(condition) {
+   *     spin_all();
+   *     sleep(); // User should have some sync work or
+   *              // sleep to avoid a 100% CPU usage
+   *   }
+   */
+  RCLCPP_PUBLIC
+  void
+  spin_all(std::chrono::nanoseconds max_duration) override;
+
+protected:
+  /**
+   * @brief Executes ready executables from wait set.
+   * @param collection entities to evaluate for ready executables.
+   * @param wait_result result to check for ready executables.
+   * @param spin_once if true executes only the first ready executable.
+   * @return true if any executable was ready.
+   */
+  bool
+  execute_ready_executables(
+    const rclcpp::executors::ExecutorEntitiesCollection & collection,
+    rclcpp::WaitResult<rclcpp::WaitSet> & wait_result,
+    bool spin_once);
+
+  void
+  spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive);
+
+  void
+  spin_once_impl(std::chrono::nanoseconds timeout) override;
+
+  std::optional<rclcpp::WaitResult<rclcpp::WaitSet>>
+  collect_and_wait(std::chrono::nanoseconds timeout);
+
+private:
+  RCLCPP_DISABLE_COPY(StaticSingleThreadedExecutor)
+};
+
+}  // namespace executors
+}  // namespace rclcpp
+
+#endif  // RCLCPP__EXECUTORS__STATIC_SINGLE_THREADED_EXECUTOR_HPP_
--- a/rclcpp/include/rclcpp/experimental/buffers/ring_buffer_implementation.hpp
+++ b/rclcpp/include/rclcpp/experimental/buffers/ring_buffer_implementation.hpp
@@ -178,8 +178,6 @@ public:
  void clear() override
  {
    TRACETOOLS_TRACEPOINT(rclcpp_ring_buffer_clear, static_cast<const void *>(this));
-    std::lock_guard<std::mutex> lock(mutex_);
-    clear_();
  }

 private:
@@ -229,14 +227,6 @@ 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 {};
@@ -265,13 +255,9 @@ private:
    std::vector<BufferT> result_vtr;
    result_vtr.reserve(size_);
    for (size_t id = 0; id < size_; ++id) {
-      const auto & elem(ring_buffer_[(read_index_ + id) % capacity_]);
-      if (elem != nullptr) {
-        result_vtr.emplace_back(new typename is_std_unique_ptr<T>::Ptr_type(
-          *elem));
-      } else {
-        result_vtr.emplace_back(nullptr);
-      }
+      result_vtr.emplace_back(
+        new typename is_std_unique_ptr<T>::Ptr_type(
+          *(ring_buffer_[(read_index_ + id) % capacity_])));
    }
    return result_vtr;
  }
@@ -306,7 +292,7 @@ private:
    return {};
  }

-  const size_t capacity_;
+  size_t capacity_;

  std::vector<BufferT> ring_buffer_;

--- a/rclcpp/include/rclcpp/experimental/create_intra_process_buffer.hpp
+++ b/rclcpp/include/rclcpp/experimental/create_intra_process_buffer.hpp
@@ -82,9 +82,10 @@ create_intra_process_buffer(

        break;
      }
-    case IntraProcessBufferType::CallbackDefault:
+    default:
      {
-        throw std::runtime_error("IntraProcessBufferType::CallbackDefault is not allowed");
+        throw std::runtime_error("Unrecognized IntraProcessBufferType value");
+        break;
      }
  }

--- a/rclcpp/include/rclcpp/experimental/executors/events_executor/events_executor.hpp
+++ b/rclcpp/include/rclcpp/experimental/executors/events_executor/events_executor.hpp
@@ -64,17 +64,17 @@ public:

  /// Default constructor. See the default constructor for Executor.
  /**
-   * \param[in] options Options used to configure the executor.
   * \param[in] events_queue The queue used to store events.
   * \param[in] execute_timers_separate_thread If true, timers are executed in a separate
   * thread. If false, timers are executed in the same thread as all other entities.
+   * \param[in] options Options used to configure the executor.
   */
  RCLCPP_PUBLIC
  EventsExecutor(
-    const rclcpp::ExecutorOptions & options = rclcpp::ExecutorOptions(),
    rclcpp::experimental::executors::EventsQueue::UniquePtr events_queue = std::make_unique<
      rclcpp::experimental::executors::SimpleEventsQueue>(),
-    bool execute_timers_separate_thread = false);
+    bool execute_timers_separate_thread = false,
+    const rclcpp::ExecutorOptions & options = rclcpp::ExecutorOptions());

  /// Default destructor.
  RCLCPP_PUBLIC
--- a/rclcpp/include/rclcpp/experimental/intra_process_manager.hpp
+++ b/rclcpp/include/rclcpp/experimental/intra_process_manager.hpp
@@ -19,7 +19,6 @@

 #include <shared_mutex>

-#include <algorithm>
 #include <iterator>
 #include <memory>
 #include <stdexcept>
@@ -119,8 +118,7 @@ public:
    typename Alloc = std::allocator<ROSMessageType>
  >
  uint64_t
-  add_subscription(
-    const rclcpp::experimental::SubscriptionIntraProcessBase::SharedPtr & subscription)
+  add_subscription(rclcpp::experimental::SubscriptionIntraProcessBase::SharedPtr subscription)
  {
    std::unique_lock<std::shared_timed_mutex> lock(mutex_);

@@ -177,8 +175,8 @@ public:
  RCLCPP_PUBLIC
  uint64_t
  add_publisher(
-    const rclcpp::PublisherBase::SharedPtr & publisher,
-    const rclcpp::experimental::buffers::IntraProcessBufferBase::SharedPtr & buffer =
+    rclcpp::PublisherBase::SharedPtr publisher,
+    rclcpp::experimental::buffers::IntraProcessBufferBase::SharedPtr buffer =
    rclcpp::experimental::buffers::IntraProcessBufferBase::SharedPtr());

  /// Unregister a publisher using the publisher's unique id.
@@ -388,39 +386,6 @@ private:
    std::vector<uint64_t> take_ownership_subscriptions;
  };

-  /// Hash function for rmw_gid_t to enable use in unordered_map
-  struct rmw_gid_hash
-  {
-    std::size_t operator()(const rmw_gid_t & gid) const noexcept
-    {
-      // Using the FNV-1a hash algorithm on the gid data
-      constexpr std::size_t FNV_prime = 1099511628211u;
-      std::size_t result = 14695981039346656037u;
-
-      for (std::size_t i = 0; i < RMW_GID_STORAGE_SIZE; ++i) {
-        result ^= gid.data[i];
-        result *= FNV_prime;
-      }
-      return result;
-    }
-  };
-
-  /// Equality comparison for rmw_gid_t to enable use in unordered_map
-  struct rmw_gid_equal
-  {
-    bool operator()(const rmw_gid_t & lhs, const rmw_gid_t & rhs) const noexcept
-    {
-      // Compare the data bytes only.
-      // implementation_identifier pointer comparison is not used here because
-      // intra-process communication is always within the same process and RMW,
-      // and pointer comparison is fragile across dynamically loaded components.
-      return std::equal(
-        std::begin(lhs.data),
-        std::end(lhs.data),
-        std::begin(rhs.data));
-    }
-  };
-
  using SubscriptionMap =
    std::unordered_map<uint64_t, rclcpp::experimental::SubscriptionIntraProcessBase::WeakPtr>;

@@ -433,16 +398,6 @@ private:
  using PublisherToSubscriptionIdsMap =
    std::unordered_map<uint64_t, SplittedSubscriptions>;

-  /// Structure to store publisher information in GID lookup map
-  struct PublisherInfo
-  {
-    uint64_t pub_id;
-    rclcpp::PublisherBase::WeakPtr publisher;
-  };
-
-  using GidToPublisherInfoMap =
-    std::unordered_map<rmw_gid_t, PublisherInfo, rmw_gid_hash, rmw_gid_equal>;
-
  RCLCPP_PUBLIC
  static
  uint64_t
@@ -455,8 +410,8 @@ private:
  RCLCPP_PUBLIC
  bool
  can_communicate(
-    const rclcpp::PublisherBase::SharedPtr & pub,
-    const rclcpp::experimental::SubscriptionIntraProcessBase::SharedPtr & sub) const;
+    rclcpp::PublisherBase::SharedPtr pub,
+    rclcpp::experimental::SubscriptionIntraProcessBase::SharedPtr sub) const;

  template<
    typename ROSMessageType,
@@ -687,8 +642,6 @@ private:
  PublisherBufferMap publisher_buffers_;

  mutable std::shared_timed_mutex mutex_;
-
-  GidToPublisherInfoMap gid_to_publisher_info_;
 };

 }  // namespace experimental
--- a/rclcpp/include/rclcpp/experimental/subscription_intra_process.hpp
+++ b/rclcpp/include/rclcpp/experimental/subscription_intra_process.hpp
@@ -154,29 +154,6 @@ public:
    execute_impl<SubscribedType>(data);
  }

-  /// Disable callbacks from being called
-  /**
-    * This method will block, until any subscription's callbacks currently being executed are
-    * finished.
-    * This method is thread safe, and provides a safe way to atomically disable the callbacks.
-    */
-  void disable_callbacks() override
-  {
-    SubscriptionIntraProcessBase::disable_callbacks();
-    any_callback_.disable();
-  }
-
-  /// Enable the callbacks to be called
-  /**
-    * This method is thread safe, and provides a safe way to atomically enable the callbacks
-    * in a multithreaded environment.
-    */
-  void enable_callbacks() override
-  {
-    SubscriptionIntraProcessBase::enable_callbacks();
-    any_callback_.enable();
-  }
-
 protected:
  template<typename T>
  typename std::enable_if<std::is_same<T, rcl_serialized_message_t>::value, void>::type
--- a/rclcpp/include/rclcpp/experimental/subscription_intra_process_base.hpp
+++ b/rclcpp/include/rclcpp/experimental/subscription_intra_process_base.hpp
@@ -19,7 +19,6 @@
 #include <memory>
 #include <mutex>
 #include <string>
-#include <vector>

 #include "rcl/wait.h"
 #include "rmw/impl/cpp/demangle.hpp"
@@ -79,30 +78,15 @@ public:
  take_data() override = 0;

  std::shared_ptr<void>
-  take_data_by_entity_id([[maybe_unused]] size_t id) override
+  take_data_by_entity_id(size_t id) override
  {
+    (void)id;
    return take_data();
  }

  void
  execute(const std::shared_ptr<void> & data) override = 0;

-  /// Disable callbacks from being called
-  /**
-   * This function temporary disable on_new_message_callback to prevent it from being called.
-   */
-  RCLCPP_PUBLIC
-  virtual
-  void disable_callbacks();
-
-  /// Enable the callbacks to be called
-  /**
-    * This function enable the on_new_message_callback if it was previously set.
-    */
-  RCLCPP_PUBLIC
-  virtual
-  void enable_callbacks();
-
  virtual
  bool
  use_take_shared_method() const = 0;
@@ -174,7 +158,7 @@ public:
        }
      };

-    std::lock_guard<std::recursive_mutex> lock(on_new_message_callback_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);
    on_new_message_callback_ = new_callback;

    if (unread_count_ > 0) {
@@ -192,21 +176,13 @@ public:
  void
  clear_on_ready_callback() override
  {
-    std::lock_guard<std::recursive_mutex> lock(on_new_message_callback_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);
    on_new_message_callback_ = nullptr;
  }

-  RCLCPP_PUBLIC
-  std::vector<std::shared_ptr<rclcpp::TimerBase>>
-  get_timers() const override
-  {
-    return {};
-  }
-
 protected:
-  std::recursive_mutex on_new_message_callback_mutex_;
+  std::recursive_mutex callback_mutex_;
  std::function<void(size_t)> on_new_message_callback_ {nullptr};
-  bool on_new_message_callback_disabled_{false};
  size_t unread_count_{0};
  rclcpp::GuardCondition gc_;

@@ -216,13 +192,11 @@ protected:
  void
  invoke_on_new_message()
  {
-    std::lock_guard<std::recursive_mutex> lock(this->on_new_message_callback_mutex_);
-    if (!on_new_message_callback_disabled_) {
-      if (this->on_new_message_callback_) {
-        this->on_new_message_callback_(1);
-      } else {
-        this->unread_count_++;
-      }
+    std::lock_guard<std::recursive_mutex> lock(this->callback_mutex_);
+    if (this->on_new_message_callback_) {
+      this->on_new_message_callback_(1);
+    } else {
+      this->unread_count_++;
    }
  }

--- a/rclcpp/include/rclcpp/experimental/subscription_intra_process_buffer.hpp
+++ b/rclcpp/include/rclcpp/experimental/subscription_intra_process_buffer.hpp
@@ -110,8 +110,9 @@ public:
  }

  bool
-  is_ready([[maybe_unused]] const rcl_wait_set_t & wait_set) override
+  is_ready(const rcl_wait_set_t & wait_set) override
  {
+    (void) wait_set;
    return buffer_->has_data();
  }

--- a/rclcpp/include/rclcpp/experimental/timers_manager.hpp
+++ b/rclcpp/include/rclcpp/experimental/timers_manager.hpp
@@ -103,7 +103,7 @@ public:
   * @throws std::invalid_argument if timer is a nullptr.
   */
  RCLCPP_PUBLIC
-  void add_timer(const rclcpp::TimerBase::SharedPtr & timer);
+  void add_timer(rclcpp::TimerBase::SharedPtr timer);

  /**
   * @brief Remove a single timer from the object storage.
@@ -113,7 +113,7 @@ public:
   * @param timer the timer to remove.
   */
  RCLCPP_PUBLIC
-  void remove_timer(const rclcpp::TimerBase::SharedPtr & timer);
+  void remove_timer(rclcpp::TimerBase::SharedPtr timer);

  /**
   * @brief Remove all the timers stored in the object.
--- a/rclcpp/include/rclcpp/generic_client.hpp
+++ b/rclcpp/include/rclcpp/generic_client.hpp
@@ -95,7 +95,7 @@ public:

  GenericClient(
    rclcpp::node_interfaces::NodeBaseInterface * node_base,
-    const rclcpp::node_interfaces::NodeGraphInterface::SharedPtr & node_graph,
+    rclcpp::node_interfaces::NodeGraphInterface::SharedPtr node_graph,
    const std::string & service_name,
    const std::string & service_type,
    rcl_client_options_t & client_options);
@@ -111,8 +111,8 @@ public:
  RCLCPP_PUBLIC
  void
  handle_response(
-    const std::shared_ptr<rmw_request_id_t> & request_header,
-    const std::shared_ptr<void> & response) override;
+    std::shared_ptr<rmw_request_id_t> request_header,
+    std::shared_ptr<void> response) override;

  /// Send a request to the service server.
  /**
@@ -144,7 +144,7 @@ public:
   */
  RCLCPP_PUBLIC
  FutureAndRequestId
-  async_send_request(const Request & request);
+  async_send_request(const Request request);

  /// Send a request to the service server and schedule a callback in the executor.
  /**
@@ -172,7 +172,7 @@ public:
    >::type * = nullptr
  >
  SharedFutureAndRequestId
-  async_send_request(const Request & request, CallbackT && cb)
+  async_send_request(const Request request, CallbackT && cb)
  {
    Promise promise;
    auto shared_future = promise.get_future().share();
@@ -280,7 +280,7 @@ protected:
  RCLCPP_PUBLIC
  int64_t
  async_send_request_impl(
-    const Request & request,
+    const Request request,
    CallbackInfoVariant value);

  std::optional<CallbackInfoVariant>
--- a/rclcpp/include/rclcpp/generic_service.hpp
+++ b/rclcpp/include/rclcpp/generic_service.hpp
@@ -159,10 +159,10 @@ public:
    if (std::holds_alternative<SharedPtrCallback>(callback_)) {
      (void)request_header;
      const auto & cb = std::get<SharedPtrCallback>(callback_);
-      cb(std::move(request), response);
+      cb(std::move(request), std::move(response));
    } else if (std::holds_alternative<SharedPtrWithRequestHeaderCallback>(callback_)) {
      const auto & cb = std::get<SharedPtrWithRequestHeaderCallback>(callback_);
-      cb(request_header, std::move(request), response);
+      cb(request_header, std::move(request), std::move(response));
    }
    TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
    return response;
@@ -245,7 +245,7 @@ public:
   */
  RCLCPP_PUBLIC
  GenericService(
-    const std::shared_ptr<rcl_node_t> & node_handle,
+    std::shared_ptr<rcl_node_t> node_handle,
    const std::string & service_name,
    const std::string & service_type,
    GenericServiceCallback any_callback,
@@ -270,7 +270,7 @@ public:
   */
  RCLCPP_PUBLIC
  bool
-  take_request(SharedRequest & request_out, rmw_request_id_t & request_id_out);
+  take_request(SharedRequest request_out, rmw_request_id_t & request_id_out);

  RCLCPP_PUBLIC
  std::shared_ptr<void>
@@ -287,8 +287,8 @@ public:
  RCLCPP_PUBLIC
  void
  handle_request(
-    const std::shared_ptr<rmw_request_id_t> & request_header,
-    const std::shared_ptr<void> & request) override;
+    std::shared_ptr<rmw_request_id_t> request_header,
+    std::shared_ptr<void> request) override;

  RCLCPP_PUBLIC
  void
--- a/rclcpp/include/rclcpp/generic_subscription.hpp
+++ b/rclcpp/include/rclcpp/generic_subscription.hpp
@@ -80,7 +80,7 @@ public:
      node_base,
      *rclcpp::get_message_typesupport_handle(topic_type, "rosidl_typesupport_cpp", *ts_lib),
      topic_name,
-      force_cpu_buffer_backend_(options).to_rcl_subscription_options(qos),
+      options.to_rcl_subscription_options(qos),
      options.event_callbacks,
      options.use_default_callbacks,
      DeliveredMessageKind::SERIALIZED_MESSAGE),
@@ -111,26 +111,6 @@ public:
  RCLCPP_PUBLIC
  std::shared_ptr<rclcpp::SerializedMessage> create_serialized_message() override;

-  /// Disable callbacks from being called
-  /**
-    * This method will block, until any subscription's callbacks provided during construction
-    * currently being executed are finished.
-    * \note This method also temporary removes the on new message callback and all
-    * on new event callbacks from the rmw layer to prevent them from being called. However, this
-    * method will not block and wait until the currently executing on_new_[message]event callbacks
-    * are finished.
-    */
-  RCLCPP_PUBLIC
-  void disable_callbacks() override;
-
-  /// Enable the callbacks to be called
-  /**
-    * This method is thread safe, and provides a safe way to atomically enable the callbacks
-    * in a multithreaded environment.
-    */
-  RCLCPP_PUBLIC
-  void enable_callbacks() override;
-
  /// Cast the message to a rclcpp::SerializedMessage and call the callback.
  RCLCPP_PUBLIC
  void handle_message(
@@ -182,17 +162,6 @@ public:

 private:
  RCLCPP_DISABLE_COPY(GenericSubscription)
-
-  template<typename AllocatorT>
-  static rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>
-  force_cpu_buffer_backend_(
-    const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options)
-  {
-    auto opts = options;
-    opts.acceptable_buffer_backends = "cpu";
-    return opts;
-  }
-
  AnySubscriptionCallback<rclcpp::SerializedMessage, std::allocator<void>> any_callback_;
  // The type support library should stay loaded, so it is stored in the GenericSubscription
  std::shared_ptr<rcpputils::SharedLibrary> ts_lib_;
--- a/rclcpp/include/rclcpp/graph_listener.hpp
+++ b/rclcpp/include/rclcpp/graph_listener.hpp
@@ -154,12 +154,6 @@ public:
  bool
  is_shutdown();

-  /// Return true if the graph listener was started.
-  RCLCPP_PUBLIC
-  virtual
-  bool
-  is_started();
-
 protected:
  /// Main function for the listening thread.
  RCLCPP_PUBLIC
@@ -187,6 +181,7 @@ private:
  void
  __shutdown();

+  std::weak_ptr<rclcpp::Context> weak_parent_context_;
  std::shared_ptr<rcl_context_t> rcl_parent_context_;

  std::thread listener_thread_;
--- a/rclcpp/include/rclcpp/guard_condition.hpp
+++ b/rclcpp/include/rclcpp/guard_condition.hpp
@@ -120,7 +120,7 @@ public:
   */
  RCLCPP_PUBLIC
  void
-  set_on_trigger_callback(const std::function<void(size_t)> & callback);
+  set_on_trigger_callback(std::function<void(size_t)> callback);

 protected:
  rcl_guard_condition_t rcl_guard_condition_;
--- a/rclcpp/include/rclcpp/logger.hpp
+++ b/rclcpp/include/rclcpp/logger.hpp
@@ -78,6 +78,34 @@ 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,
--- a/rclcpp/include/rclcpp/logging.hpp
+++ b/rclcpp/include/rclcpp/logging.hpp
@@ -1,983 +0,0 @@
-// Copyright 2017 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__LOGGING_HPP_
-#define RCLCPP__LOGGING_HPP_
-
-#include <sstream>
-#include <type_traits>
-
-#include "rclcpp/logger.hpp"
-#include "rcutils/logging_macros.h"
-
-// These are used for compiling out logging macros lower than a minimum severity.
-#define RCLCPP_LOG_MIN_SEVERITY_DEBUG 0
-#define RCLCPP_LOG_MIN_SEVERITY_INFO 1
-#define RCLCPP_LOG_MIN_SEVERITY_WARN 2
-#define RCLCPP_LOG_MIN_SEVERITY_ERROR 3
-#define RCLCPP_LOG_MIN_SEVERITY_FATAL 4
-#define RCLCPP_LOG_MIN_SEVERITY_NONE 5
-
-#define RCLCPP_STATIC_ASSERT_LOGGER(logger) \
-  do { \
-    static_assert( \
-      ::std::is_convertible_v<decltype(logger), ::rclcpp::Logger>, \
-      "First argument to logging macros must be an rclcpp::Logger"); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG
- * Log a message with given severity.
- * \param logger The `rclcpp::Logger` to use
- * \param ... The format string, followed by the variable arguments for the format string.
- */
-#define RCLCPP_LOG(severity, logger, ...) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    RCUTILS_LOG_NAMED(severity, (logger).get_name(), __VA_ARGS__); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_ONCE
- * Log a message with given severity with the following condition:
- * - All log calls except the first one are ignored.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param ... The format string, followed by the variable arguments for the format string.
- */
-#define RCLCPP_LOG_ONCE(severity, logger, ...) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    RCUTILS_LOG_ONCE_NAMED(severity, (logger).get_name(), __VA_ARGS__); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_EXPRESSION
- * Log a message with given severity with the following condition:
- * - Log calls are ignored when the expression evaluates to false.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param expression The expression determining if the message should be logged
- * \param ... The format string, followed by the variable arguments for the format string.
- */
-#define RCLCPP_LOG_EXPRESSION(severity, logger, expression, ...) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    RCUTILS_LOG_EXPRESSION_NAMED(severity, expression, (logger).get_name(), __VA_ARGS__); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_FUNCTION
- * Log a message with given severity with the following condition:
- * - Log calls are ignored when the function returns false.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param function The functions return value determines if the message should be logged
- * \param ... The format string, followed by the variable arguments for the format string.
- */
-#define RCLCPP_LOG_FUNCTION(severity, logger, function, ...) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    RCUTILS_LOG_FUNCTION_NAMED(severity, function, (logger).get_name(), __VA_ARGS__); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_SKIPFIRST
- * Log a message with given severity with the following condition:
- * - The first log call is ignored but all subsequent calls are processed.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param ... The format string, followed by the variable arguments for the format string.
- */
-#define RCLCPP_LOG_SKIPFIRST(severity, logger, ...) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    RCUTILS_LOG_SKIPFIRST_NAMED(severity, (logger).get_name(), __VA_ARGS__); \
-  } while (0)
-
-#define RCLCPP_LOG_TIME_POINT_FUNC(clock) \
-  [&c = clock](rcutils_time_point_value_t * time_point)->rcutils_ret_t { \
-    try { \
-      *time_point = c.now().nanoseconds(); \
-    } catch (...) { \
-      RCUTILS_SAFE_FWRITE_TO_STDERR( \
-      "[rclcpp|logging.hpp] RCLCPP_DEBUG_THROTTLE could not get current time stamp\n"); \
-      return RCUTILS_RET_ERROR; \
-    } \
-    return RCUTILS_RET_OK; \
-  }
-
-/**
- * \def RCLCPP_LOG_THROTTLE
- * Log a message with given severity with the following condition:
- * - Log calls are ignored if the last logged message is not longer ago than the specified duration.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param clock rclcpp::Clock that will be used to get the time point.
- * \param duration The duration of the throttle interval as an integral value in milliseconds.
- * \param ... The format string, followed by the variable arguments for the format string.
- */
-#define RCLCPP_LOG_THROTTLE(severity, logger, clock, duration, ...) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    RCUTILS_LOG_THROTTLE_NAMED( \
-      severity, \
-      RCLCPP_LOG_TIME_POINT_FUNC(clock), \
-      duration, \
-      (logger).get_name(), \
-      __VA_ARGS__); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_SKIPFIRST_THROTTLE
- * Log a message with given severity with the following conditions:
- * - The first log call is ignored but all subsequent calls are processed.
- * - Log calls are ignored if the last logged message is not longer ago than the specified duration.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param clock rclcpp::Clock that will be used to get the time point.
- * \param duration The duration of the throttle interval as an integral value in milliseconds.
- * \param ... The format string, followed by the variable arguments for the format string.
- */
-#define RCLCPP_LOG_SKIPFIRST_THROTTLE(severity, logger, clock, duration, ...) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    RCUTILS_LOG_SKIPFIRST_THROTTLE_NAMED( \
-      severity, \
-      RCLCPP_LOG_TIME_POINT_FUNC(clock), \
-      duration, \
-      (logger).get_name(), \
-      __VA_ARGS__); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_STREAM
- * Log a message with given severity.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param stream_arg The argument << into a stringstream
- */
-#define RCLCPP_LOG_STREAM(severity, logger, stream_arg) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    std::stringstream rclcpp_stream_ss_; \
-    rclcpp_stream_ss_ << stream_arg; \
-    RCUTILS_LOG_NAMED(severity, (logger).get_name(), "%s", rclcpp_stream_ss_.str().c_str()); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_STREAM_ONCE
- * Log a message with given severity with the following condition:
- * - All log calls except the first one are ignored.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param stream_arg The argument << into a stringstream
- */
-#define RCLCPP_LOG_STREAM_ONCE(severity, logger, stream_arg) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    std::stringstream rclcpp_stream_ss_; \
-    rclcpp_stream_ss_ << stream_arg; \
-    RCUTILS_LOG_ONCE_NAMED(severity, (logger).get_name(), "%s", rclcpp_stream_ss_.str().c_str()); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_STREAM_EXPRESSION
- * Log a message with given severity with the following condition:
- * - Log calls are being ignored when the expression evaluates to false.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param expression The expression determining if the message should be logged
- * \param stream_arg The argument << into a stringstream
- */
-#define RCLCPP_LOG_STREAM_EXPRESSION(severity, logger, expression, stream_arg) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    std::stringstream rclcpp_stream_ss_; \
-    rclcpp_stream_ss_ << stream_arg; \
-    RCUTILS_LOG_EXPRESSION_NAMED( \
-      severity, \
-      expression, \
-      (logger).get_name(), \
-      "%s", rclcpp_stream_ss_.str().c_str()); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_STREAM_FUNCTION
- * Log a message with given severity with the following condition:
- * - Log calls are being ignored when the function returns false.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param function The functions return value determines if the message should be logged
- * \param stream_arg The argument << into a stringstream
- */
-#define RCLCPP_LOG_STREAM_FUNCTION(severity, logger, function, stream_arg) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    std::stringstream rclcpp_stream_ss_; \
-    rclcpp_stream_ss_ << stream_arg; \
-    RCUTILS_LOG_FUNCTION_NAMED( \
-      severity, \
-      function, \
-      (logger).get_name(), \
-      "%s", rclcpp_stream_ss_.str().c_str()); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_STREAM_SKIPFIRST
- * Log a message with given severity with the following condition:
- * - The first log call is ignored but all subsequent calls are processed.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param stream_arg The argument << into a stringstream
- */
-#define RCLCPP_LOG_STREAM_SKIPFIRST(severity, logger, stream_arg) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    std::stringstream rclcpp_stream_ss_; \
-    rclcpp_stream_ss_ << stream_arg; \
-    RCUTILS_LOG_SKIPFIRST_NAMED( \
-      severity, \
-      (logger).get_name(), \
-      "%s", rclcpp_stream_ss_.str().c_str()); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_STREAM_THROTTLE
- * Log a message with given severity with the following condition:
- * - Log calls are ignored if the last logged message is not longer ago than the specified duration.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param clock rclcpp::Clock that will be used to get the time point.
- * \param duration The duration of the throttle interval as an integral value in milliseconds.
- * \param stream_arg The argument << into a stringstream
- */
-#define RCLCPP_LOG_STREAM_THROTTLE(severity, logger, clock, duration, stream_arg) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    std::stringstream rclcpp_stream_ss_; \
-    rclcpp_stream_ss_ << stream_arg; \
-    RCUTILS_LOG_THROTTLE_NAMED( \
-      severity, \
-      RCLCPP_LOG_TIME_POINT_FUNC(clock), \
-      duration, \
-      (logger).get_name(), \
-      "%s", rclcpp_stream_ss_.str().c_str()); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
- * Log a message with given severity with the following conditions:
- * - The first log call is ignored but all subsequent calls are processed.
- * - Log calls are ignored if the last logged message is not longer ago than the specified duration.
- *
- * \param logger The `rclcpp::Logger` to use
- * \param clock rclcpp::Clock that will be used to get the time point.
- * \param duration The duration of the throttle interval as an integral value in milliseconds.
- * \param stream_arg The argument << into a stringstream
- */
-#define RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(severity, logger, clock, duration, stream_arg) \
-  do { \
-    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
-    std::stringstream rclcpp_stream_ss_; \
-    rclcpp_stream_ss_ << stream_arg; \
-    RCUTILS_LOG_SKIPFIRST_THROTTLE_NAMED( \
-      severity, \
-      RCLCPP_LOG_TIME_POINT_FUNC(clock), \
-      duration, \
-      (logger).get_name(), \
-      "%s", rclcpp_stream_ss_.str().c_str()); \
-  } while (0)
-
-/**
- * \def RCLCPP_LOG_MIN_SEVERITY
- * Define RCLCPP_LOG_MIN_SEVERITY=RCLCPP_LOG_MIN_SEVERITY_[DEBUG|INFO|WARN|ERROR|FATAL]
- * in your build options to compile out anything below that severity.
- * Use RCLCPP_LOG_MIN_SEVERITY_NONE to compile out all macros.
- */
-#ifndef RCLCPP_LOG_MIN_SEVERITY
-#define RCLCPP_LOG_MIN_SEVERITY RCLCPP_LOG_MIN_SEVERITY_DEBUG
-#endif
-
-/** @name Logging macros for severity DEBUG.
- */
-#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_DEBUG)
-// empty logging macros for severity DEBUG when being disabled at compile time
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_ONCE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_EXPRESSION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_FUNCTION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_SKIPFIRST(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_SKIPFIRST_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_STREAM(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_STREAM_ONCE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_STREAM_EXPRESSION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_STREAM_FUNCTION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_STREAM_SKIPFIRST(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_STREAM_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_DEBUG_STREAM_SKIPFIRST_THROTTLE(...)
-
-#else
-/**
- * \def RCLCPP_DEBUG
- * \copydoc RCLCPP_LOG
- */
-#define RCLCPP_DEBUG(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_DEBUG, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_DEBUG_ONCE
- * \copydoc RCLCPP_LOG_ONCE
- */
-#define RCLCPP_DEBUG_ONCE(logger, ...) \
-  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_DEBUG, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_DEBUG_EXPRESSION
- * \copydoc RCLCPP_LOG_EXPRESSION
- */
-#define RCLCPP_DEBUG_EXPRESSION(logger, expression, ...) \
-  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_DEBUG, logger, expression, __VA_ARGS__)
-
-/**
- * \def RCLCPP_DEBUG_FUNCTION
- * \copydoc RCLCPP_LOG_FUNCTION
- */
-#define RCLCPP_DEBUG_FUNCTION(logger, function, ...) \
-  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_DEBUG, logger, function, __VA_ARGS__)
-
-/**
- * \def RCLCPP_DEBUG_SKIPFIRST
- * \copydoc RCLCPP_LOG_SKIPFIRST
- */
-#define RCLCPP_DEBUG_SKIPFIRST(logger, ...) \
-  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_DEBUG, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_DEBUG_THROTTLE
- * \copydoc RCLCPP_LOG_THROTTLE
- */
-#define RCLCPP_DEBUG_THROTTLE(logger, clock, duration, ...) \
-  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_DEBUG, logger, clock, duration, __VA_ARGS__)
-
-/**
- * \def RCLCPP_DEBUG_SKIPFIRST_THROTTLE
- * \copydoc RCLCPP_LOG_SKIPFIRST_THROTTLE
- */
-#define RCLCPP_DEBUG_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
-  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_DEBUG, logger, clock, duration, __VA_ARGS__)
-
-/**
- * \def RCLCPP_DEBUG_STREAM
- * \copydoc RCLCPP_LOG_STREAM
- */
-#define RCLCPP_DEBUG_STREAM(logger, stream_arg) \
-  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_DEBUG, logger, stream_arg)
-
-/**
- * \def RCLCPP_DEBUG_STREAM_ONCE
- * \copydoc RCLCPP_LOG_STREAM_ONCE
- */
-#define RCLCPP_DEBUG_STREAM_ONCE(logger, stream_arg) \
-  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_DEBUG, logger, stream_arg)
-
-/**
- * \def RCLCPP_DEBUG_STREAM_EXPRESSION
- * \copydoc RCLCPP_LOG_STREAM_EXPRESSION
- */
-#define RCLCPP_DEBUG_STREAM_EXPRESSION(logger, expression, stream_arg) \
-  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_DEBUG, logger, expression, stream_arg)
-
-/**
- * \def RCLCPP_DEBUG_STREAM_FUNCTION
- * \copydoc RCLCPP_LOG_STREAM_FUNCTION
- */
-#define RCLCPP_DEBUG_STREAM_FUNCTION(logger, function, stream_arg) \
-  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_DEBUG, logger, function, stream_args)
-
-/**
- * \def RCLCPP_DEBUG_STREAM_SKIPFIRST
- * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST
- */
-#define RCLCPP_DEBUG_STREAM_SKIPFIRST(logger, stream_arg) \
-  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_DEBUG, logger, stream_arg)
-
-/**
- * \def RCLCPP_DEBUG_STREAM_THROTTLE
- * \copydoc RCLCPP_LOG_STREAM_THROTTLE
- */
-#define RCLCPP_DEBUG_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
-  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_DEBUG, logger, clock, duration, stream_arg)
-
-/**
- * \def RCLCPP_DEBUG_STREAM_SKIPFIRST_THROTTLE
- * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
- */
-#define RCLCPP_DEBUG_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
-  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_DEBUG, logger, clock, duration, \
-    stream_arg)
-
-#endif
-
-/** @name Logging macros for severity INFO.
- */
-#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_INFO)
-// empty logging macros for severity INFO when being disabled at compile time
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_ONCE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_EXPRESSION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_FUNCTION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_SKIPFIRST(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_SKIPFIRST_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_STREAM(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_STREAM_ONCE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_STREAM_EXPRESSION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_STREAM_FUNCTION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_STREAM_SKIPFIRST(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_STREAM_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_INFO_STREAM_SKIPFIRST_THROTTLE(...)
-
-#else
-/**
- * \def RCLCPP_INFO
- * \copydoc RCLCPP_LOG
- */
-#define RCLCPP_INFO(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_INFO, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_INFO_ONCE
- * \copydoc RCLCPP_LOG_ONCE
- */
-#define RCLCPP_INFO_ONCE(logger, ...) \
-  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_INFO, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_INFO_EXPRESSION
- * \copydoc RCLCPP_LOG_EXPRESSION
- */
-#define RCLCPP_INFO_EXPRESSION(logger, expression, ...) \
-  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_INFO, logger, expression, __VA_ARGS__)
-
-/**
- * \def RCLCPP_INFO_FUNCTION
- * \copydoc RCLCPP_LOG_FUNCTION
- */
-#define RCLCPP_INFO_FUNCTION(logger, function, ...) \
-  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_INFO, logger, function, __VA_ARGS__)
-
-/**
- * \def RCLCPP_INFO_SKIPFIRST
- * \copydoc RCLCPP_LOG_SKIPFIRST
- */
-#define RCLCPP_INFO_SKIPFIRST(logger, ...) \
-  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_INFO, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_INFO_THROTTLE
- * \copydoc RCLCPP_LOG_THROTTLE
- */
-#define RCLCPP_INFO_THROTTLE(logger, clock, duration, ...) \
-  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_INFO, logger, clock, duration, __VA_ARGS__)
-
-/**
- * \def RCLCPP_INFO_SKIPFIRST_THROTTLE
- * \copydoc RCLCPP_LOG_SKIPFIRST_THROTTLE
- */
-#define RCLCPP_INFO_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
-  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_INFO, logger, clock, duration, __VA_ARGS__)
-
-/**
- * \def RCLCPP_INFO_STREAM
- * \copydoc RCLCPP_LOG_STREAM
- */
-#define RCLCPP_INFO_STREAM(logger, stream_arg) \
-  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_INFO, logger, stream_arg)
-
-/**
- * \def RCLCPP_INFO_STREAM_ONCE
- * \copydoc RCLCPP_LOG_STREAM_ONCE
- */
-#define RCLCPP_INFO_STREAM_ONCE(logger, stream_arg) \
-  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_INFO, logger, stream_arg)
-
-/**
- * \def RCLCPP_INFO_STREAM_EXPRESSION
- * \copydoc RCLCPP_LOG_STREAM_EXPRESSION
- */
-#define RCLCPP_INFO_STREAM_EXPRESSION(logger, expression, stream_arg) \
-  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_INFO, logger, expression, stream_arg)
-
-/**
- * \def RCLCPP_INFO_STREAM_FUNCTION
- * \copydoc RCLCPP_LOG_STREAM_FUNCTION
- */
-#define RCLCPP_INFO_STREAM_FUNCTION(logger, function, stream_arg) \
-  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_INFO, logger, function, stream_args)
-
-/**
- * \def RCLCPP_INFO_STREAM_SKIPFIRST
- * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST
- */
-#define RCLCPP_INFO_STREAM_SKIPFIRST(logger, stream_arg) \
-  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_INFO, logger, stream_arg)
-
-/**
- * \def RCLCPP_INFO_STREAM_THROTTLE
- * \copydoc RCLCPP_LOG_STREAM_THROTTLE
- */
-#define RCLCPP_INFO_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
-  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_INFO, logger, clock, duration, stream_arg)
-
-/**
- * \def RCLCPP_INFO_STREAM_SKIPFIRST_THROTTLE
- * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
- */
-#define RCLCPP_INFO_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
-  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_INFO, logger, clock, duration, \
-    stream_arg)
-
-#endif
-
-/** @name Logging macros for severity WARN.
- */
-#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_WARN)
-// empty logging macros for severity WARN when being disabled at compile time
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_ONCE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_EXPRESSION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_FUNCTION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_SKIPFIRST(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_SKIPFIRST_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_STREAM(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_STREAM_ONCE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_STREAM_EXPRESSION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_STREAM_FUNCTION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_STREAM_SKIPFIRST(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_STREAM_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_WARN_STREAM_SKIPFIRST_THROTTLE(...)
-
-#else
-/**
- * \def RCLCPP_WARN
- * \copydoc RCLCPP_LOG
- */
-#define RCLCPP_WARN(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_WARN, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_WARN_ONCE
- * \copydoc RCLCPP_LOG_ONCE
- */
-#define RCLCPP_WARN_ONCE(logger, ...) \
-  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_WARN, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_WARN_EXPRESSION
- * \copydoc RCLCPP_LOG_EXPRESSION
- */
-#define RCLCPP_WARN_EXPRESSION(logger, expression, ...) \
-  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_WARN, logger, expression, __VA_ARGS__)
-
-/**
- * \def RCLCPP_WARN_FUNCTION
- * \copydoc RCLCPP_LOG_FUNCTION
- */
-#define RCLCPP_WARN_FUNCTION(logger, function, ...) \
-  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_WARN, logger, function, __VA_ARGS__)
-
-/**
- * \def RCLCPP_WARN_SKIPFIRST
- * \copydoc RCLCPP_LOG_SKIPFIRST
- */
-#define RCLCPP_WARN_SKIPFIRST(logger, ...) \
-  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_WARN, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_WARN_THROTTLE
- * \copydoc RCLCPP_LOG_THROTTLE
- */
-#define RCLCPP_WARN_THROTTLE(logger, clock, duration, ...) \
-  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_WARN, logger, clock, duration, __VA_ARGS__)
-
-/**
- * \def RCLCPP_WARN_SKIPFIRST_THROTTLE
- * \copydoc RCLCPP_LOG_SKIPFIRST_THROTTLE
- */
-#define RCLCPP_WARN_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
-  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_WARN, logger, clock, duration, __VA_ARGS__)
-
-/**
- * \def RCLCPP_WARN_STREAM
- * \copydoc RCLCPP_LOG_STREAM
- */
-#define RCLCPP_WARN_STREAM(logger, stream_arg) \
-  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_WARN, logger, stream_arg)
-
-/**
- * \def RCLCPP_WARN_STREAM_ONCE
- * \copydoc RCLCPP_LOG_STREAM_ONCE
- */
-#define RCLCPP_WARN_STREAM_ONCE(logger, stream_arg) \
-  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_WARN, logger, stream_arg)
-
-/**
- * \def RCLCPP_WARN_STREAM_EXPRESSION
- * \copydoc RCLCPP_LOG_STREAM_EXPRESSION
- */
-#define RCLCPP_WARN_STREAM_EXPRESSION(logger, expression, stream_arg) \
-  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_WARN, logger, expression, stream_arg)
-
-/**
- * \def RCLCPP_WARN_STREAM_FUNCTION
- * \copydoc RCLCPP_LOG_STREAM_FUNCTION
- */
-#define RCLCPP_WARN_STREAM_FUNCTION(logger, function, stream_arg) \
-  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_WARN, logger, function, stream_args)
-
-/**
- * \def RCLCPP_WARN_STREAM_SKIPFIRST
- * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST
- */
-#define RCLCPP_WARN_STREAM_SKIPFIRST(logger, stream_arg) \
-  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_WARN, logger, stream_arg)
-
-/**
- * \def RCLCPP_WARN_STREAM_THROTTLE
- * \copydoc RCLCPP_LOG_STREAM_THROTTLE
- */
-#define RCLCPP_WARN_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
-  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_WARN, logger, clock, duration, stream_arg)
-
-/**
- * \def RCLCPP_WARN_STREAM_SKIPFIRST_THROTTLE
- * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
- */
-#define RCLCPP_WARN_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
-  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_WARN, logger, clock, duration, \
-    stream_arg)
-
-#endif
-
-/** @name Logging macros for severity ERROR.
- */
-#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_ERROR)
-// empty logging macros for severity ERROR when being disabled at compile time
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_ONCE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_EXPRESSION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_FUNCTION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_SKIPFIRST(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_SKIPFIRST_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_STREAM(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_STREAM_ONCE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_STREAM_EXPRESSION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_STREAM_FUNCTION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_STREAM_SKIPFIRST(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_STREAM_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_ERROR_STREAM_SKIPFIRST_THROTTLE(...)
-
-#else
-/**
- * \def RCLCPP_ERROR
- * \copydoc RCLCPP_LOG
- */
-#define RCLCPP_ERROR(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_ERROR, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_ERROR_ONCE
- * \copydoc RCLCPP_LOG_ONCE
- */
-#define RCLCPP_ERROR_ONCE(logger, ...) \
-  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_ERROR, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_ERROR_EXPRESSION
- * \copydoc RCLCPP_LOG_EXPRESSION
- */
-#define RCLCPP_ERROR_EXPRESSION(logger, expression, ...) \
-  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_ERROR, logger, expression, __VA_ARGS__)
-
-/**
- * \def RCLCPP_ERROR_FUNCTION
- * \copydoc RCLCPP_LOG_FUNCTION
- */
-#define RCLCPP_ERROR_FUNCTION(logger, function, ...) \
-  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_ERROR, logger, function, __VA_ARGS__)
-
-/**
- * \def RCLCPP_ERROR_SKIPFIRST
- * \copydoc RCLCPP_LOG_SKIPFIRST
- */
-#define RCLCPP_ERROR_SKIPFIRST(logger, ...) \
-  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_ERROR, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_ERROR_THROTTLE
- * \copydoc RCLCPP_LOG_THROTTLE
- */
-#define RCLCPP_ERROR_THROTTLE(logger, clock, duration, ...) \
-  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_ERROR, logger, clock, duration, __VA_ARGS__)
-
-/**
- * \def RCLCPP_ERROR_SKIPFIRST_THROTTLE
- * \copydoc RCLCPP_LOG_SKIPFIRST_THROTTLE
- */
-#define RCLCPP_ERROR_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
-  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_ERROR, logger, clock, duration, __VA_ARGS__)
-
-/**
- * \def RCLCPP_ERROR_STREAM
- * \copydoc RCLCPP_LOG_STREAM
- */
-#define RCLCPP_ERROR_STREAM(logger, stream_arg) \
-  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_ERROR, logger, stream_arg)
-
-/**
- * \def RCLCPP_ERROR_STREAM_ONCE
- * \copydoc RCLCPP_LOG_STREAM_ONCE
- */
-#define RCLCPP_ERROR_STREAM_ONCE(logger, stream_arg) \
-  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_ERROR, logger, stream_arg)
-
-/**
- * \def RCLCPP_ERROR_STREAM_EXPRESSION
- * \copydoc RCLCPP_LOG_STREAM_EXPRESSION
- */
-#define RCLCPP_ERROR_STREAM_EXPRESSION(logger, expression, stream_arg) \
-  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_ERROR, logger, expression, stream_arg)
-
-/**
- * \def RCLCPP_ERROR_STREAM_FUNCTION
- * \copydoc RCLCPP_LOG_STREAM_FUNCTION
- */
-#define RCLCPP_ERROR_STREAM_FUNCTION(logger, function, stream_arg) \
-  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_ERROR, logger, function, stream_args)
-
-/**
- * \def RCLCPP_ERROR_STREAM_SKIPFIRST
- * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST
- */
-#define RCLCPP_ERROR_STREAM_SKIPFIRST(logger, stream_arg) \
-  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_ERROR, logger, stream_arg)
-
-/**
- * \def RCLCPP_ERROR_STREAM_THROTTLE
- * \copydoc RCLCPP_LOG_STREAM_THROTTLE
- */
-#define RCLCPP_ERROR_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
-  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_ERROR, logger, clock, duration, stream_arg)
-
-/**
- * \def RCLCPP_ERROR_STREAM_SKIPFIRST_THROTTLE
- * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
- */
-#define RCLCPP_ERROR_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
-  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_ERROR, logger, clock, duration, \
-    stream_arg)
-
-#endif
-
-/** @name Logging macros for severity FATAL.
- */
-#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_FATAL)
-// empty logging macros for severity FATAL when being disabled at compile time
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_ONCE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_EXPRESSION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_FUNCTION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_SKIPFIRST(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_SKIPFIRST_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_STREAM(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_STREAM_ONCE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_STREAM_EXPRESSION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_STREAM_FUNCTION(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_STREAM_SKIPFIRST(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_STREAM_THROTTLE(...)
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_FATAL_STREAM_SKIPFIRST_THROTTLE(...)
-
-#else
-/**
- * \def RCLCPP_FATAL
- * \copydoc RCLCPP_LOG
- */
-#define RCLCPP_FATAL(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_FATAL, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_FATAL_ONCE
- * \copydoc RCLCPP_LOG_ONCE
- */
-#define RCLCPP_FATAL_ONCE(logger, ...) \
-  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_FATAL, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_FATAL_EXPRESSION
- * \copydoc RCLCPP_LOG_EXPRESSION
- */
-#define RCLCPP_FATAL_EXPRESSION(logger, expression, ...) \
-  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_FATAL, logger, expression, __VA_ARGS__)
-
-/**
- * \def RCLCPP_FATAL_FUNCTION
- * \copydoc RCLCPP_LOG_FUNCTION
- */
-#define RCLCPP_FATAL_FUNCTION(logger, function, ...) \
-  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_FATAL, logger, function, __VA_ARGS__)
-
-/**
- * \def RCLCPP_FATAL_SKIPFIRST
- * \copydoc RCLCPP_LOG_SKIPFIRST
- */
-#define RCLCPP_FATAL_SKIPFIRST(logger, ...) \
-  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_FATAL, logger, __VA_ARGS__)
-
-/**
- * \def RCLCPP_FATAL_THROTTLE
- * \copydoc RCLCPP_LOG_THROTTLE
- */
-#define RCLCPP_FATAL_THROTTLE(logger, clock, duration, ...) \
-  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_FATAL, logger, clock, duration, __VA_ARGS__)
-
-/**
- * \def RCLCPP_FATAL_SKIPFIRST_THROTTLE
- * \copydoc RCLCPP_LOG_SKIPFIRST_THROTTLE
- */
-#define RCLCPP_FATAL_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
-  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_FATAL, logger, clock, duration, __VA_ARGS__)
-
-/**
- * \def RCLCPP_FATAL_STREAM
- * \copydoc RCLCPP_LOG_STREAM
- */
-#define RCLCPP_FATAL_STREAM(logger, stream_arg) \
-  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_FATAL, logger, stream_arg)
-
-/**
- * \def RCLCPP_FATAL_STREAM_ONCE
- * \copydoc RCLCPP_LOG_STREAM_ONCE
- */
-#define RCLCPP_FATAL_STREAM_ONCE(logger, stream_arg) \
-  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_FATAL, logger, stream_arg)
-
-/**
- * \def RCLCPP_FATAL_STREAM_EXPRESSION
- * \copydoc RCLCPP_LOG_STREAM_EXPRESSION
- */
-#define RCLCPP_FATAL_STREAM_EXPRESSION(logger, expression, stream_arg) \
-  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_FATAL, logger, expression, stream_arg)
-
-/**
- * \def RCLCPP_FATAL_STREAM_FUNCTION
- * \copydoc RCLCPP_LOG_STREAM_FUNCTION
- */
-#define RCLCPP_FATAL_STREAM_FUNCTION(logger, function, stream_arg) \
-  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_FATAL, logger, function, stream_args)
-
-/**
- * \def RCLCPP_FATAL_STREAM_SKIPFIRST
- * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST
- */
-#define RCLCPP_FATAL_STREAM_SKIPFIRST(logger, stream_arg) \
-  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_FATAL, logger, stream_arg)
-
-/**
- * \def RCLCPP_FATAL_STREAM_THROTTLE
- * \copydoc RCLCPP_LOG_STREAM_THROTTLE
- */
-#define RCLCPP_FATAL_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
-  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_FATAL, logger, clock, duration, stream_arg)
-
-/**
- * \def RCLCPP_FATAL_STREAM_SKIPFIRST_THROTTLE
- * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
- */
-#define RCLCPP_FATAL_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
-  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_FATAL, logger, clock, duration, \
-    stream_arg)
-
-#endif
-
-#endif  // RCLCPP__LOGGING_HPP_
--- a/rclcpp/include/rclcpp/message_memory_strategy.hpp
+++ b/rclcpp/include/rclcpp/message_memory_strategy.hpp
@@ -18,7 +18,6 @@
 #include <memory>
 #include <stdexcept>

-#include "rcl/allocator.h"
 #include "rcl/types.h"

 #include "rclcpp/allocator/allocator_common.hpp"
@@ -62,16 +61,7 @@ public:
    message_allocator_ = std::make_shared<MessageAlloc>();
    serialized_message_allocator_ = std::make_shared<SerializedMessageAlloc>();
    buffer_allocator_ = std::make_shared<BufferAlloc>();
-    if constexpr (std::is_same_v<Alloc, std::allocator<void>>) {
-      rcutils_allocator_ = rcl_get_default_allocator();
-    } else {
-      if constexpr (rclcpp::allocator::has_get_rcl_allocator_v<Alloc>) {
-        rcutils_allocator_ = message_allocator_->get_rcl_allocator();
-      } else {
-        rcutils_allocator_ = allocator::get_rcl_allocator<char,
-            BufferAlloc>(*buffer_allocator_.get());
-      }
-    }
+    rcutils_allocator_ = allocator::get_rcl_allocator<char, BufferAlloc>(*buffer_allocator_.get());
  }

  explicit MessageMemoryStrategy(std::shared_ptr<Alloc> allocator)
@@ -79,16 +69,7 @@ public:
    message_allocator_ = std::make_shared<MessageAlloc>(*allocator.get());
    serialized_message_allocator_ = std::make_shared<SerializedMessageAlloc>(*allocator.get());
    buffer_allocator_ = std::make_shared<BufferAlloc>(*allocator.get());
-    if constexpr (std::is_same_v<Alloc, std::allocator<void>>) {
-      rcutils_allocator_ = rcl_get_default_allocator();
-    } else {
-      if constexpr (rclcpp::allocator::has_get_rcl_allocator_v<Alloc>) {
-        rcutils_allocator_ = allocator->get_rcl_allocator();
-      } else {
-        rcutils_allocator_ = allocator::get_rcl_allocator<char,
-            BufferAlloc>(*buffer_allocator_.get());
-      }
-    }
+    rcutils_allocator_ = allocator::get_rcl_allocator<char, BufferAlloc>(*buffer_allocator_.get());
  }

  virtual ~MessageMemoryStrategy() = default;
--- a/rclcpp/include/rclcpp/node.hpp
+++ b/rclcpp/include/rclcpp/node.hpp
@@ -242,7 +242,7 @@ public:
  create_wall_timer(
    std::chrono::duration<DurationRepT, DurationT> period,
    CallbackT callback,
-    const rclcpp::CallbackGroup::SharedPtr & group = nullptr,
+    rclcpp::CallbackGroup::SharedPtr group = nullptr,
    bool autostart = true);

  /// Create a timer that uses the node clock to drive the callback.
@@ -256,7 +256,7 @@ public:
  create_timer(
    std::chrono::duration<DurationRepT, DurationT> period,
    CallbackT callback,
-    const rclcpp::CallbackGroup::SharedPtr & group = nullptr);
+    rclcpp::CallbackGroup::SharedPtr group = nullptr);

  /// Create and return a Client.
  /**
@@ -270,7 +270,7 @@ public:
  create_client(
    const std::string & service_name,
    const rclcpp::QoS & qos = rclcpp::ServicesQoS(),
-    const rclcpp::CallbackGroup::SharedPtr & group = nullptr);
+    rclcpp::CallbackGroup::SharedPtr group = nullptr);

  /// Create and return a Service.
  /**
@@ -286,7 +286,7 @@ public:
    const std::string & service_name,
    CallbackT && callback,
    const rclcpp::QoS & qos = rclcpp::ServicesQoS(),
-    const rclcpp::CallbackGroup::SharedPtr & group = nullptr);
+    rclcpp::CallbackGroup::SharedPtr group = nullptr);

  /// Create and return a GenericClient.
  /**
@@ -302,7 +302,7 @@ public:
    const std::string & service_name,
    const std::string & service_type,
    const rclcpp::QoS & qos = rclcpp::ServicesQoS(),
-    const rclcpp::CallbackGroup::SharedPtr & group = nullptr);
+    rclcpp::CallbackGroup::SharedPtr group = nullptr);

  /// Create and return a GenericService.
  /**
@@ -320,7 +320,7 @@ public:
    const std::string & service_type,
    CallbackT && callback,
    const rclcpp::QoS & qos = rclcpp::ServicesQoS(),
-    const rclcpp::CallbackGroup::SharedPtr & group = nullptr);
+    rclcpp::CallbackGroup::SharedPtr group = nullptr);

  /// Create and return a GenericPublisher.
  /**
@@ -1388,66 +1388,6 @@ public:
  std::vector<rclcpp::TopicEndpointInfo>
  get_subscriptions_info_by_topic(const std::string & topic_name, bool no_mangle = false) const;

-  /// Return the service endpoint information about clients on a given service.
-  /**
-   * The returned parameter is a list of service endpoint information, where each item will contain
-   * the node name, node namespace, service type, endpoint type, endpoint count,
-   * service endpoint's GIDs, and its QoS profiles.
-   *
-   * When the `no_mangle` parameter is `true`, the provided `service_name` should be a valid service
-   * name for the middleware (useful when combining ROS with native middleware apps).
-   * When the `no_mangle` parameter is `false`, the provided `service_name` should follow
-   * ROS service name conventions. In DDS-based RMWs, services are implemented as topics with mangled
-   * names (e.g., `rq/my_serviceRequest` and `rp/my_serviceReply`), so `no_mangle = true` is not
-   * supported and will result in an error. Use `get_publishers_info_by_topic` or
-   * `get_subscriptions_info_by_topic` for unmangled topic queries in such cases. Other RMWs
-   * (e.g., Zenoh) may support `no_mangle = true` if they natively handle services without topic-based
-   *
-   * 'service_name` may be a relative, private, or fully qualified service name.
-   * A relative or private service will be expanded using this node's namespace and name.
-   * The queried `service_name` is not remapped.
-   *
-   * \param[in] service_name the actual service name used; it will not be automatically remapped.
-   * \param[in] no_mangle if `true`, `service_name` needs to be a valid middleware service name,
-   *   otherwise it should be a valid ROS service name. Defaults to `false`.
-   * \return a list of SeviceEndpointInfo representing all the clients on this service.
-   * \throws InvalidServiceNameError if the given service_name is invalid.
-   * \throws std::runtime_error if internal error happens.
-   */
-  RCLCPP_PUBLIC
-  std::vector<rclcpp::ServiceEndpointInfo>
-  get_clients_info_by_service(const std::string & service_name, bool no_mangle = false) const;
-
-  /// Return the service endpoint information about servers on a given service.
-  /**
-   * The returned parameter is a list of service endpoint information, where each item will contain
-   * the node name, node namespace, service type, endpoint type, endpoint count,
-   * service endpoint's GIDs, and its QoS profiles.
-   *
-   * When the `no_mangle` parameter is `true`, the provided `service_name` should be a valid service
-   * name for the middleware (useful when combining ROS with native middleware apps).
-   * When the `no_mangle` parameter is `false`, the provided `service_name` should follow
-   * ROS service name conventions. In DDS-based RMWs, services are implemented as topics with mangled
-   * names (e.g., `rq/my_serviceRequest` and `rp/my_serviceReply`), so `no_mangle = true` is not
-   * supported and will result in an error. Use `rcl_get_publishers_info_by_topic` or
-   * `rcl_get_subscriptions_info_by_topic` for unmangled topic queries in such cases. Other RMWs
-   * (e.g., Zenoh) may support `no_mangle = true` if they natively handle services without topic-based
-   *
-   * 'service_name` may be a relative, private, or fully qualified service name.
-   * A relative or private service will be expanded using this node's namespace and name.
-   * The queried `service_name` is not remapped.
-   *
-   * \param[in] service_name the actual service name used; it will not be automatically remapped.
-   * \param[in] no_mangle if `true`, `service_name` needs to be a valid middleware service name,
-   *   otherwise it should be a valid ROS service name. Defaults to `false`.
-   * \return a list of SeviceEndpointInfo representing all the servers on this service.
-   * \throws InvalidServiceNameError if the given service_name is invalid.
-   * \throws std::runtime_error if internal error happens.
-   */
-  RCLCPP_PUBLIC
-  std::vector<rclcpp::ServiceEndpointInfo>
-  get_servers_info_by_service(const std::string & service_name, bool no_mangle = false) const;
-
  /// Return a graph event, which will be set anytime a graph change occurs.
  /* The graph Event object is a loan which must be returned.
   * The Event object is scoped and therefore to return the loan just let it go
@@ -1471,7 +1411,7 @@ public:
  RCLCPP_PUBLIC
  void
  wait_for_graph_change(
-    const rclcpp::Event::SharedPtr & event,
+    rclcpp::Event::SharedPtr event,
    std::chrono::nanoseconds timeout);

  /// Get a clock as a non-const shared pointer which is managed by the node.
@@ -1619,10 +1559,6 @@ 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.
--- a/rclcpp/include/rclcpp/node_impl.hpp
+++ b/rclcpp/include/rclcpp/node_impl.hpp
@@ -111,7 +111,7 @@ typename rclcpp::WallTimer<CallbackT>::SharedPtr
 Node::create_wall_timer(
  std::chrono::duration<DurationRepT, DurationT> period,
  CallbackT callback,
-  const rclcpp::CallbackGroup::SharedPtr & group,
+  rclcpp::CallbackGroup::SharedPtr group,
  bool autostart)
 {
  return rclcpp::create_wall_timer(
@@ -128,7 +128,7 @@ typename rclcpp::GenericTimer<CallbackT>::SharedPtr
 Node::create_timer(
  std::chrono::duration<DurationRepT, DurationT> period,
  CallbackT callback,
-  const rclcpp::CallbackGroup::SharedPtr & group)
+  rclcpp::CallbackGroup::SharedPtr group)
 {
  return rclcpp::create_timer(
    this->get_clock(),
@@ -144,7 +144,7 @@ typename Client<ServiceT>::SharedPtr
 Node::create_client(
  const std::string & service_name,
  const rclcpp::QoS & qos,
-  const rclcpp::CallbackGroup::SharedPtr & group)
+  rclcpp::CallbackGroup::SharedPtr group)
 {
  return rclcpp::create_client<ServiceT>(
    node_base_,
@@ -161,7 +161,7 @@ Node::create_service(
  const std::string & service_name,
  CallbackT && callback,
  const rclcpp::QoS & qos,
-  const rclcpp::CallbackGroup::SharedPtr & group)
+  rclcpp::CallbackGroup::SharedPtr group)
 {
  return rclcpp::create_service<ServiceT, CallbackT>(
    node_base_,
@@ -179,7 +179,7 @@ Node::create_generic_service(
  const std::string & service_type,
  CallbackT && callback,
  const rclcpp::QoS & qos,
-  const rclcpp::CallbackGroup::SharedPtr & group)
+  rclcpp::CallbackGroup::SharedPtr group)
 {
  return rclcpp::create_generic_service<CallbackT>(
    node_base_,
@@ -323,9 +323,11 @@ 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(name, parameter_variant);
+  bool result = get_parameter(sub_name, parameter_variant);
  if (result) {
    parameter = static_cast<ParameterT>(parameter_variant.get_value<ParameterT>());
  }
@@ -340,7 +342,9 @@ Node::get_parameter_or(
  ParameterT & parameter,
  const ParameterT & alternative_value) const
 {
-  bool got_parameter = get_parameter(name, parameter);
+  std::string sub_name = extend_name_with_sub_namespace(name, this->get_sub_namespace());
+
+  bool got_parameter = get_parameter(sub_name, parameter);
  if (!got_parameter) {
    parameter = alternative_value;
  }
--- a/rclcpp/include/rclcpp/node_interfaces/detail/node_interfaces_helpers.hpp
+++ b/rclcpp/include/rclcpp/node_interfaces/detail/node_interfaces_helpers.hpp
@@ -199,12 +199,6 @@ init_tuple(NodeT & n)
    { \
      return StorageClassT::template get<NodeInterfaceType>(); \
    } \
- \
-    std::shared_ptr<const NodeInterfaceType> \
-    get_node_ ## NodeInterfaceName ## _interface() const \
-    { \
-      return StorageClassT::template get<NodeInterfaceType>(); \
-    } \
  }; \
  }  // namespace rclcpp::node_interfaces::detail
 // *INDENT-ON*
--- a/rclcpp/include/rclcpp/node_interfaces/node_base.hpp
+++ b/rclcpp/include/rclcpp/node_interfaces/node_base.hpp
@@ -121,6 +121,11 @@ public:
  std::atomic_bool &
  get_associated_with_executor_atomic() override;

+  [[deprecated("Use get_shared_notify_guard_condition or trigger_notify_guard_condition instead")]]
+  RCLCPP_PUBLIC
+  rclcpp::GuardCondition &
+  get_notify_guard_condition() override;
+
  RCLCPP_PUBLIC
  rclcpp::GuardCondition::SharedPtr
  get_shared_notify_guard_condition() override;
--- a/rclcpp/include/rclcpp/node_interfaces/node_base_interface.hpp
+++ b/rclcpp/include/rclcpp/node_interfaces/node_base_interface.hpp
@@ -144,6 +144,17 @@ public:
  std::atomic_bool &
  get_associated_with_executor_atomic() = 0;

+  /// Return a guard condition that should be notified when the internal node state changes.
+  /**
+   * For example, this should be notified when a publisher is added or removed.
+   *
+   * \return the GuardCondition if it is valid, else throw runtime error
+   */
+  RCLCPP_PUBLIC
+  virtual
+  rclcpp::GuardCondition &
+  get_notify_guard_condition() = 0;
+
  /// Return a guard condition that should be notified when the internal node state changes.
  /**
   * For example, this should be notified when a publisher is added or removed.
--- a/rclcpp/include/rclcpp/node_interfaces/node_graph.hpp
+++ b/rclcpp/include/rclcpp/node_interfaces/node_graph.hpp
@@ -33,7 +33,6 @@
 #include "rclcpp/node_interfaces/node_base_interface.hpp"
 #include "rclcpp/node_interfaces/node_graph_interface.hpp"
 #include "rclcpp/visibility_control.hpp"
-#include "rmw/service_endpoint_info_array.h"
 #include "rmw/topic_endpoint_info_array.h"

 namespace rclcpp
@@ -160,24 +159,14 @@ public:
    const std::string & topic_name,
    bool no_mangle = false) const override;

-  RCLCPP_PUBLIC
-  std::vector<rclcpp::ServiceEndpointInfo>
-  get_clients_info_by_service(
-    const std::string & service_name,
-    bool no_mangle = false) const override;
-
-  RCLCPP_PUBLIC
-  std::vector<rclcpp::ServiceEndpointInfo>
-  get_servers_info_by_service(
-    const std::string & service_name,
-    bool no_mangle = false) const override;
-
 private:
  RCLCPP_DISABLE_COPY(NodeGraph)

  /// Handle to the NodeBaseInterface given in the constructor.
  rclcpp::node_interfaces::NodeBaseInterface * node_base_;

+  /// Graph Listener which waits on graph changes for the node and is shared across nodes.
+  std::shared_ptr<rclcpp::graph_listener::GraphListener> graph_listener_;
  /// Whether or not this node needs to be added to the graph listener.
  std::atomic_bool should_add_to_graph_listener_;

--- a/rclcpp/include/rclcpp/node_interfaces/node_graph_interface.hpp
+++ b/rclcpp/include/rclcpp/node_interfaces/node_graph_interface.hpp
@@ -18,8 +18,6 @@
 #include <algorithm>
 #include <array>
 #include <chrono>
-#include <cstddef>
-#include <cstdint>
 #include <map>
 #include <string>
 #include <tuple>
@@ -42,9 +40,7 @@ enum class EndpointType
 {
  Invalid = RMW_ENDPOINT_INVALID,
  Publisher = RMW_ENDPOINT_PUBLISHER,
-  Subscription = RMW_ENDPOINT_SUBSCRIPTION,
-  Client = RMW_ENDPOINT_CLIENT,
-  Server = RMW_ENDPOINT_SERVER
+  Subscription = RMW_ENDPOINT_SUBSCRIPTION
 };

 /**
@@ -57,17 +53,13 @@ public:
  /// Construct a TopicEndpointInfo from a rcl_topic_endpoint_info_t.
  RCLCPP_PUBLIC
  explicit TopicEndpointInfo(const rcl_topic_endpoint_info_t & info)
-  : endpoint_type_(static_cast<rclcpp::EndpointType>(info.endpoint_type)),
+  : node_name_(info.node_name),
+    node_namespace_(info.node_namespace),
+    topic_type_(info.topic_type),
+    endpoint_type_(static_cast<rclcpp::EndpointType>(info.endpoint_type)),
    qos_profile_({info.qos_profile.history, info.qos_profile.depth}, info.qos_profile),
    topic_type_hash_(info.topic_type_hash)
  {
-    if (!info.node_name || !info.node_namespace || !info.topic_type) {
-      throw std::invalid_argument("Constructor TopicEndpointInfo with invalid topic endpoint info");
-    }
-    node_name_ = info.node_name;
-    node_namespace_ = info.node_namespace;
-    topic_type_ = info.topic_type;
-
    std::copy(info.endpoint_gid, info.endpoint_gid + RMW_GID_STORAGE_SIZE, endpoint_gid_.begin());
  }

@@ -151,125 +143,6 @@ private:
  rosidl_type_hash_t topic_type_hash_;
 };

-/**
- * Struct that contains service endpoint information like the associated node name, node namespace,
- * service type, endpoint type, endpoint count, endpoint GIDs, and its QoS profiles.
- */
-class ServiceEndpointInfo
-{
-public:
-  /// Construct a ServiceEndpointInfo from a rcl_service_endpoint_info_t.
-  RCLCPP_PUBLIC
-  explicit ServiceEndpointInfo(const rcl_service_endpoint_info_t & info)
-  : node_name_(info.node_name),
-    node_namespace_(info.node_namespace),
-    service_type_(info.service_type),
-    endpoint_type_(static_cast<rclcpp::EndpointType>(info.endpoint_type)),
-    service_type_hash_(info.service_type_hash),
-    endpoint_count_(info.endpoint_count)
-  {
-    for(size_t i = 0; i < endpoint_count_; i++) {
-      std::array<uint8_t, RMW_GID_STORAGE_SIZE> gid;
-      std::copy(info.endpoint_gids[i], info.endpoint_gids[i] + RMW_GID_STORAGE_SIZE, gid.begin());
-      endpoint_gids_.push_back(gid);
-
-      rclcpp::QoS qos(
-        {info.qos_profiles[i].history, info.qos_profiles[i].depth}, info.qos_profiles[i]);
-      qos_profiles_.push_back(qos);
-    }
-  }
-
-  /// Get a mutable reference to the node name.
-  RCLCPP_PUBLIC
-  std::string &
-  node_name();
-
-  /// Get a const reference to the node name.
-  RCLCPP_PUBLIC
-  const std::string &
-  node_name() const;
-
-  /// Get a mutable reference to the node namespace.
-  RCLCPP_PUBLIC
-  std::string &
-  node_namespace();
-
-  /// Get a const reference to the node namespace.
-  RCLCPP_PUBLIC
-  const std::string &
-  node_namespace() const;
-
-  /// Get a mutable reference to the service type string.
-  RCLCPP_PUBLIC
-  std::string &
-  service_type();
-
-  /// Get a const reference to the service type string.
-  RCLCPP_PUBLIC
-  const std::string &
-  service_type() const;
-
-  /// Get a mutable reference to the service endpoint type.
-  RCLCPP_PUBLIC
-  rclcpp::EndpointType &
-  endpoint_type();
-
-  /// Get a const reference to the service endpoint type.
-  RCLCPP_PUBLIC
-  const rclcpp::EndpointType &
-  endpoint_type() const;
-
-  /// Get a mutable reference to the endpoint count.
-  RCLCPP_PUBLIC
-  size_t &
-  endpoint_count();
-
-  /// Get a const reference to the endpoint count.
-  RCLCPP_PUBLIC
-  const size_t &
-  endpoint_count() const;
-
-  /// Get a mutable reference to the GID of the service endpoint.
-  RCLCPP_PUBLIC
-  std::vector<std::array<uint8_t, RMW_GID_STORAGE_SIZE>> &
-  endpoint_gids();
-
-  /// Get a const reference to the GID of the service endpoint.
-  RCLCPP_PUBLIC
-  const std::vector<std::array<uint8_t, RMW_GID_STORAGE_SIZE>> &
-  endpoint_gids() const;
-
-  /// Get a mutable reference to the QoS profile of the service endpoint.
-  RCLCPP_PUBLIC
-  std::vector<rclcpp::QoS> &
-  qos_profiles();
-
-  /// Get a const reference to the QoS profile of the service endpoint.
-  RCLCPP_PUBLIC
-  const std::vector<rclcpp::QoS> &
-  qos_profiles() const;
-
-  /// Get a mutable reference to the type hash of the service endpoint.
-  RCLCPP_PUBLIC
-  rosidl_type_hash_t &
-  service_type_hash();
-
-  /// Get a const reference to the type hash of the service endpoint.
-  RCLCPP_PUBLIC
-  const rosidl_type_hash_t &
-  service_type_hash() const;
-
-private:
-  std::string node_name_;
-  std::string node_namespace_;
-  std::string service_type_;
-  rclcpp::EndpointType endpoint_type_;
-  std::vector<std::array<uint8_t, RMW_GID_STORAGE_SIZE>> endpoint_gids_;
-  std::vector<rclcpp::QoS> qos_profiles_;
-  rosidl_type_hash_t service_type_hash_;
-  size_t endpoint_count_;
-};
-
 namespace node_interfaces
 {

@@ -535,30 +408,6 @@ public:
  virtual
  std::vector<rclcpp::TopicEndpointInfo>
  get_subscriptions_info_by_topic(const std::string & topic_name, bool no_mangle = false) const = 0;
-
-  /// Return the service endpoint information about clients on a given service.
-  /**
-   * \param[in] service_name the actual service name used; it will not be automatically remapped.
-   * \param[in] no_mangle if `true`, `service_name` needs to be a valid middleware service name,
-   *   otherwise it should be a valid ROS service name.
-   * \sa rclcpp::Node::get_clients_info_by_service
-   */
-  RCLCPP_PUBLIC
-  virtual
-  std::vector<rclcpp::ServiceEndpointInfo>
-  get_clients_info_by_service(const std::string & service_name, bool no_mangle = false) const = 0;
-
-  /// Return the service endpoint information about servers on a given service.
-  /**
-   * \param[in] service_name the actual service name used; it will not be automatically remapped.
-   * \param[in] no_mangle if `true`, `service_name` needs to be a valid middleware service name,
-   *   otherwise it should be a valid ROS service name.
-   * \sa rclcpp::Node::get_servers_info_by_service
-   */
-  RCLCPP_PUBLIC
-  virtual
-  std::vector<rclcpp::ServiceEndpointInfo>
-  get_servers_info_by_service(const std::string & service_name, bool no_mangle = false) const = 0;
 };

 }  // namespace node_interfaces
--- a/rclcpp/include/rclcpp/node_interfaces/node_logging.hpp
+++ b/rclcpp/include/rclcpp/node_interfaces/node_logging.hpp
@@ -38,7 +38,7 @@ public:
  RCLCPP_SMART_PTR_ALIASES_ONLY(NodeLoggingInterface)

  RCLCPP_PUBLIC
-  explicit NodeLogging(const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_base);
+  explicit NodeLogging(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base);

  RCLCPP_PUBLIC
  virtual
@@ -55,7 +55,7 @@ public:
  RCLCPP_PUBLIC
  void
  create_logger_services(
-    const node_interfaces::NodeServicesInterface::SharedPtr & node_services) override;
+    node_interfaces::NodeServicesInterface::SharedPtr node_services) override;

 private:
  RCLCPP_DISABLE_COPY(NodeLogging)
--- a/rclcpp/include/rclcpp/node_interfaces/node_logging_interface.hpp
+++ b/rclcpp/include/rclcpp/node_interfaces/node_logging_interface.hpp
@@ -61,7 +61,7 @@ public:
  virtual
  void
  create_logger_services(
-    const node_interfaces::NodeServicesInterface::SharedPtr & node_services) = 0;
+    node_interfaces::NodeServicesInterface::SharedPtr node_services) = 0;
 };

 }  // namespace node_interfaces
--- a/rclcpp/include/rclcpp/node_interfaces/node_parameters.hpp
+++ b/rclcpp/include/rclcpp/node_interfaces/node_parameters.hpp
@@ -214,10 +214,6 @@ 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>;
--- a/rclcpp/include/rclcpp/node_interfaces/node_parameters_interface.hpp
+++ b/rclcpp/include/rclcpp/node_interfaces/node_parameters_interface.hpp
@@ -270,26 +270,6 @@ 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
--- a/rclcpp/include/rclcpp/node_interfaces/node_type_descriptions.hpp
+++ b/rclcpp/include/rclcpp/node_interfaces/node_type_descriptions.hpp
@@ -39,10 +39,10 @@ public:

  RCLCPP_PUBLIC
  explicit NodeTypeDescriptions(
-    const NodeBaseInterface::SharedPtr & node_base,
-    const NodeLoggingInterface::SharedPtr & node_logging,
-    const NodeParametersInterface::SharedPtr & node_parameters,
-    const NodeServicesInterface::SharedPtr & node_services);
+    NodeBaseInterface::SharedPtr node_base,
+    NodeLoggingInterface::SharedPtr node_logging,
+    NodeParametersInterface::SharedPtr node_parameters,
+    NodeServicesInterface::SharedPtr node_services);

  RCLCPP_PUBLIC
  virtual
--- a/rclcpp/include/rclcpp/node_options.hpp
+++ b/rclcpp/include/rclcpp/node_options.hpp
@@ -100,7 +100,7 @@ public:
  /// Set the context, return this for parameter idiom.
  RCLCPP_PUBLIC
  NodeOptions &
-  context(const rclcpp::Context::SharedPtr & context);
+  context(rclcpp::Context::SharedPtr context);

  /// Return a reference to the list of arguments for the node.
  RCLCPP_PUBLIC
@@ -146,14 +146,6 @@ public:
    return *this;
  }

-  /// Append a single parameter override, parameter idiom style.
-  NodeOptions &
-  append_parameter_override(const rclcpp::Parameter & param)
-  {
-    this->parameter_overrides().push_back(param);
-    return *this;
-  }
-
  /// Return the use_global_arguments flag.
  RCLCPP_PUBLIC
  bool
--- a/rclcpp/include/rclcpp/parameter_client.hpp
+++ b/rclcpp/include/rclcpp/parameter_client.hpp
@@ -64,13 +64,13 @@ public:
   */
  RCLCPP_PUBLIC
  AsyncParametersClient(
-    const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_base_interface,
-    const rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr & node_topics_interface,
-    const rclcpp::node_interfaces::NodeGraphInterface::SharedPtr & node_graph_interface,
-    const rclcpp::node_interfaces::NodeServicesInterface::SharedPtr & node_services_interface,
+    const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base_interface,
+    const rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr node_topics_interface,
+    const rclcpp::node_interfaces::NodeGraphInterface::SharedPtr node_graph_interface,
+    const rclcpp::node_interfaces::NodeServicesInterface::SharedPtr node_services_interface,
    const std::string & remote_node_name = "",
    const rclcpp::QoS & qos_profile = rclcpp::ParametersQoS(),
-    const rclcpp::CallbackGroup::SharedPtr & group = nullptr);
+    rclcpp::CallbackGroup::SharedPtr group = nullptr);

  /**
   * \param[in] node The async parameters client will be added to this node.
@@ -80,10 +80,10 @@ public:
   */
  template<typename NodeT>
  explicit AsyncParametersClient(
-    const std::shared_ptr<NodeT> & node,
+    const std::shared_ptr<NodeT> node,
    const std::string & remote_node_name = "",
    const rclcpp::QoS & qos_profile = rclcpp::ParametersQoS(),
-    const rclcpp::CallbackGroup::SharedPtr & group = nullptr)
+    rclcpp::CallbackGroup::SharedPtr group = nullptr)
  : AsyncParametersClient(
      node->get_node_base_interface(),
      node->get_node_topics_interface(),
@@ -105,7 +105,7 @@ public:
    NodeT * node,
    const std::string & remote_node_name = "",
    const rclcpp::QoS & qos_profile = rclcpp::ParametersQoS(),
-    const rclcpp::CallbackGroup::SharedPtr & group = nullptr)
+    rclcpp::CallbackGroup::SharedPtr group = nullptr)
  : AsyncParametersClient(
      node->get_node_base_interface(),
      node->get_node_topics_interface(),
@@ -120,41 +120,41 @@ public:
  std::shared_future<std::vector<rclcpp::Parameter>>
  get_parameters(
    const std::vector<std::string> & names,
-    const std::function<
+    std::function<
      void(std::shared_future<std::vector<rclcpp::Parameter>>)
-    > & callback = nullptr);
+    > callback = nullptr);

  RCLCPP_PUBLIC
  std::shared_future<std::vector<rcl_interfaces::msg::ParameterDescriptor>>
  describe_parameters(
    const std::vector<std::string> & names,
-    const std::function<
+    std::function<
      void(std::shared_future<std::vector<rcl_interfaces::msg::ParameterDescriptor>>)
-    > & callback = nullptr);
+    > callback = nullptr);

  RCLCPP_PUBLIC
  std::shared_future<std::vector<rclcpp::ParameterType>>
  get_parameter_types(
    const std::vector<std::string> & names,
-    const std::function<
+    std::function<
      void(std::shared_future<std::vector<rclcpp::ParameterType>>)
-    > & callback = nullptr);
+    > callback = nullptr);

  RCLCPP_PUBLIC
  std::shared_future<std::vector<rcl_interfaces::msg::SetParametersResult>>
  set_parameters(
    const std::vector<rclcpp::Parameter> & parameters,
-    const std::function<
+    std::function<
      void(std::shared_future<std::vector<rcl_interfaces::msg::SetParametersResult>>)
-    > & callback = nullptr);
+    > callback = nullptr);

  RCLCPP_PUBLIC
  std::shared_future<rcl_interfaces::msg::SetParametersResult>
  set_parameters_atomically(
    const std::vector<rclcpp::Parameter> & parameters,
-    const std::function<
+    std::function<
      void(std::shared_future<rcl_interfaces::msg::SetParametersResult>)
-    > & callback = nullptr);
+    > callback = nullptr);

  /// Delete several parameters at once.
  /**
@@ -200,9 +200,9 @@ public:
  list_parameters(
    const std::vector<std::string> & prefixes,
    uint64_t depth,
-    const std::function<
+    std::function<
      void(std::shared_future<rcl_interfaces::msg::ListParametersResult>)
-    > & callback = nullptr);
+    > callback = nullptr);

  template<
    typename CallbackT,
@@ -304,7 +304,7 @@ public:

  template<typename NodeT>
  explicit SyncParametersClient(
-    const std::shared_ptr<NodeT> & node,
+    std::shared_ptr<NodeT> node,
    const std::string & remote_node_name = "",
    const rclcpp::QoS & qos_profile = rclcpp::ParametersQoS())
  : SyncParametersClient(
@@ -316,8 +316,8 @@ public:

  template<typename NodeT>
  SyncParametersClient(
-    const rclcpp::Executor::SharedPtr & executor,
-    const std::shared_ptr<NodeT> & node,
+    rclcpp::Executor::SharedPtr executor,
+    std::shared_ptr<NodeT> node,
    const std::string & remote_node_name = "",
    const rclcpp::QoS & qos_profile = rclcpp::ParametersQoS())
  : SyncParametersClient(
@@ -344,7 +344,7 @@ public:

  template<typename NodeT>
  SyncParametersClient(
-    const rclcpp::Executor::SharedPtr & executor,
+    rclcpp::Executor::SharedPtr executor,
    NodeT * node,
    const std::string & remote_node_name = "",
    const rclcpp::QoS & qos_profile = rclcpp::ParametersQoS())
@@ -360,11 +360,11 @@ public:

  RCLCPP_PUBLIC
  SyncParametersClient(
-    const rclcpp::Executor::SharedPtr & executor,
-    const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr & node_base_interface,
-    const rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr & node_topics_interface,
-    const rclcpp::node_interfaces::NodeGraphInterface::SharedPtr & node_graph_interface,
-    const rclcpp::node_interfaces::NodeServicesInterface::SharedPtr & node_services_interface,
+    rclcpp::Executor::SharedPtr executor,
+    const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base_interface,
+    const rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr node_topics_interface,
+    const rclcpp::node_interfaces::NodeGraphInterface::SharedPtr node_graph_interface,
+    const rclcpp::node_interfaces::NodeServicesInterface::SharedPtr node_services_interface,
    const std::string & remote_node_name = "",
    const rclcpp::QoS & qos_profile = rclcpp::ParametersQoS())
  : executor_(executor), node_base_interface_(node_base_interface)
--- a/rclcpp/include/rclcpp/parameter_descriptor_wrapper.hpp
+++ b/rclcpp/include/rclcpp/parameter_descriptor_wrapper.hpp
@@ -1,82 +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__PARAMETER_DESCRIPTOR_WRAPPER_HPP_
-#define RCLCPP__PARAMETER_DESCRIPTOR_WRAPPER_HPP_
-
-// C++ Standard library includes
-#include <functional>
-#include <utility>
-#include <memory>
-#include <string>
-
-// Additional ROS libraries needed
-#include "rcl_interfaces/msg/parameter_descriptor.hpp"
-
-#include "rclcpp/node.hpp"
-#include "rclcpp/parameter_value.hpp"
-#include "rclcpp/node_interfaces/get_node_parameters_interface.hpp"
-#include "rclcpp/visibility_control.hpp"
-#include "node_interfaces/node_parameters_interface.hpp"
-
-namespace rclcpp
-{
-
-// Implements ParameterDesription class with builder design pattern
-class ParameterDescription
-{
-public:
-  RCLCPP_SMART_PTR_DEFINITIONS(ParameterDescription)
-
-  // List of classes the builder manages
-  RCLCPP_PUBLIC
-  ParameterDescription();
-
-  // Our Main build methods which will construct the base class
-  RCLCPP_PUBLIC rcl_interfaces::msg::ParameterDescriptor build() const;
-
-  // Builder Methods:
-  // Describes the instances in a parameter_description object
-  RCLCPP_PUBLIC ParameterDescription & set_name(const std::string & name);
-  RCLCPP_PUBLIC ParameterDescription & set_type(std::uint8_t type);
-  RCLCPP_PUBLIC ParameterDescription & set_description_text(const std::string & description);
-  RCLCPP_PUBLIC ParameterDescription & set_additional_constraints(const std::string & constraints);
-  RCLCPP_PUBLIC ParameterDescription & set_read_only(bool read_only);
-  RCLCPP_PUBLIC ParameterDescription & set_dynamic_typing(bool dynamic_typing);
-  RCLCPP_PUBLIC ParameterDescription & set_floating_point_description_range(
-    float min, float max, float step);
-  RCLCPP_PUBLIC ParameterDescription & set_integer_description_range(int min, int max, int step);
-
-  // Need the current node in order to begin the configuration state
-  // for it via the declare_parameter function
-  template<typename NodeT>
-  ParameterDescription & declare_parameter(
-    const rclcpp::ParameterValue & default_value,
-    NodeT && node)
-  {
-    auto node_param = rclcpp::node_interfaces::get_node_parameters_interface(node);
-    node_param->declare_parameter(
-      parameter_descriptor.name, default_value,
-      parameter_descriptor);
-    return *this;
-  }
-
-private:
-  // The main descriptor object we're meant to initialize and adjust
-  rcl_interfaces::msg::ParameterDescriptor parameter_descriptor;
-};
-
-}  // namespace rclcpp
-
-#endif  // RCLCPP__PARAMETER_DESCRIPTOR_WRAPPER_HPP_
--- a/rclcpp/include/rclcpp/parameter_event_handler.hpp
+++ b/rclcpp/include/rclcpp/parameter_event_handler.hpp
@@ -184,7 +184,7 @@ public:
   */
  template<typename NodeT>
  explicit ParameterEventHandler(
-    const NodeT & node,
+    NodeT node,
    const rclcpp::QoS & qos =
    rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(rmw_qos_profile_parameter_events)))
  : node_base_(rclcpp::node_interfaces::get_node_base_interface(node))
@@ -217,7 +217,7 @@ public:
  RCUTILS_WARN_UNUSED
  ParameterEventCallbackHandle::SharedPtr
  add_parameter_event_callback(
-    const ParameterEventCallbackType & callback);
+    ParameterEventCallbackType callback);

  /// Remove parameter event callback registered with add_parameter_event_callback.
  /**
@@ -226,7 +226,7 @@ public:
  RCLCPP_PUBLIC
  void
  remove_parameter_event_callback(
-    const ParameterEventCallbackHandle::SharedPtr & callback_handle);
+    ParameterEventCallbackHandle::SharedPtr callback_handle);

  using ParameterCallbackType = ParameterCallbackHandle::ParameterCallbackType;

@@ -234,10 +234,6 @@ public:
  /**
   * If a node_name is not provided, defaults to the current node.
   *
-   * The configure_nodes_filter() function will affect the behavior of this function.
-   * If the node specified in this function isn't included in the nodes specified in
-   * configure_nodes_filter(), the callback will never be called.
-   *
   * Note: if the returned callback handle smart pointer is not captured, the callback
   * is immediately unregistered. A compiler warning should be generated to warn
   * of this.
@@ -252,34 +248,9 @@ public:
  ParameterCallbackHandle::SharedPtr
  add_parameter_callback(
    const std::string & parameter_name,
-    const ParameterCallbackType & callback,
+    ParameterCallbackType callback,
    const std::string & node_name = "");

-  /// Configure which node parameter events will be received.
-  /**
-   * This function depends on rmw implementation support for content filtering.
-   * If middleware doesn't support contentfilter, return false.
-   *
-   * If node_names is empty, the configured node filter will be cleared.
-   *
-   * If this function return true, only parameter events from the specified node will be received.
-   * It affects the behavior of the following two functions.
-   * - add_parameter_event_callback()
-   *   The callback will only be called for parameter events from the specified nodes which are
-   *   configured in this function.
-   * - add_parameter_callback()
-   *   The callback will only be called for parameter events from the specified nodes which are
-   *   configured in this function and add_parameter_callback().
-   *   If the nodes specified in this function is different from the nodes specified in
-   *   add_parameter_callback(), the callback will never be called.
-   *
-   * \param[in] node_names Node names to filter parameter events from.
-   * \returns true if configuring was successfully applied, false otherwise.
-   * \throws rclcpp::exceptions::RCLError if internal error occurred when calling the rcl function.
-   */
-  RCLCPP_PUBLIC
-  bool configure_nodes_filter(const std::vector<std::string> & node_names);
-
  /// Remove a parameter callback registered with add_parameter_callback.
  /**
   * The parameter name and node name are inspected from the callback handle. The callback handle
@@ -291,7 +262,7 @@ public:
  RCLCPP_PUBLIC
  void
  remove_parameter_callback(
-    const ParameterCallbackHandle::SharedPtr & callback_handle);
+    ParameterCallbackHandle::SharedPtr callback_handle);

  /// Get an rclcpp::Parameter from a parameter event.
  /**
--- a/rclcpp/include/rclcpp/parameter_events_filter.hpp
+++ b/rclcpp/include/rclcpp/parameter_events_filter.hpp
@@ -45,7 +45,6 @@ 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:
   *
--- a/rclcpp/include/rclcpp/parameter_service.hpp
+++ b/rclcpp/include/rclcpp/parameter_service.hpp
@@ -42,8 +42,8 @@ public:

  RCLCPP_PUBLIC
  ParameterService(
-    const std::shared_ptr<node_interfaces::NodeBaseInterface> & node_base,
-    const std::shared_ptr<node_interfaces::NodeServicesInterface> & node_services,
+    const std::shared_ptr<node_interfaces::NodeBaseInterface> node_base,
+    const std::shared_ptr<node_interfaces::NodeServicesInterface> node_services,
    rclcpp::node_interfaces::NodeParametersInterface * node_params,
    const rclcpp::QoS & qos_profile = rclcpp::ParametersQoS());

--- a/rclcpp/include/rclcpp/publisher.hpp
+++ b/rclcpp/include/rclcpp/publisher.hpp
@@ -143,9 +143,12 @@ public:
  post_init_setup(
    rclcpp::node_interfaces::NodeBaseInterface * node_base,
    const std::string & topic,
-    [[maybe_unused]] const rclcpp::QoS & qos,
-    [[maybe_unused]] const rclcpp::PublisherOptionsWithAllocator<AllocatorT> & options)
+    const rclcpp::QoS & qos,
+    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();
@@ -574,13 +577,6 @@ protected:
  std::unique_ptr<PublishedType, PublishedTypeDeleter>
  duplicate_type_adapt_message_as_unique_ptr(const PublishedType & msg)
  {
-    /// Assert that the published type has no overloaded operator new since this leads to
-    /// new/delete mismatch (see https://github.com/ros2/rclcpp/issues/2951)
-    static_assert(!detail::has_overloaded_operator_new_v<PublishedType>,
-        "When publishing by value (i.e. when calling publish(const T& msg)), the published "
-    "message type must not have an overloaded operator new. In this case, please use the "
-    "publish(std::unique_ptr<T> msg) method instead.");
-
    auto ptr = PublishedTypeAllocatorTraits::allocate(published_type_allocator_, 1);
    PublishedTypeAllocatorTraits::construct(published_type_allocator_, ptr, msg);
    return std::unique_ptr<PublishedType, PublishedTypeDeleter>(ptr, published_type_deleter_);
--- a/rclcpp/include/rclcpp/publisher_base.hpp
+++ b/rclcpp/include/rclcpp/publisher_base.hpp
@@ -210,7 +210,7 @@ public:
  void
  setup_intra_process(
    uint64_t intra_process_publisher_id,
-    const IntraProcessManagerSharedPtr & ipm);
+    IntraProcessManagerSharedPtr ipm);

  /// Get network flow endpoints
  /**
@@ -300,7 +300,7 @@ public:
   */
  void
  set_on_new_qos_event_callback(
-    const std::function<void(size_t)> & callback,
+    std::function<void(size_t)> callback,
    rcl_publisher_event_type_t event_type)
  {
    if (event_handlers_.count(event_type) == 0) {
@@ -319,7 +319,7 @@ public:
    // The on_ready_callback signature has an extra `int` argument used to disambiguate between
    // possible different entities within a generic waitable.
    // We hide that detail to users of this method.
-    std::function<void(size_t, int)> new_callback = [callback] (size_t nr, int) {callback(nr);};
+    std::function<void(size_t, int)> new_callback = std::bind(callback, std::placeholders::_1);
    event_handlers_[event_type]->set_on_ready_callback(new_callback);
  }

--- a/rclcpp/include/rclcpp/publisher_options.hpp
+++ b/rclcpp/include/rclcpp/publisher_options.hpp
@@ -123,20 +123,11 @@ private:
  rcl_allocator_t
  get_rcl_allocator() const
  {
-    if constexpr (std::is_same_v<Allocator, std::allocator<void>>) {
-      return rcl_get_default_allocator();
-    } else {
-      if constexpr (rclcpp::allocator::has_get_rcl_allocator_v<Allocator>) {
-        return get_allocator()->get_rcl_allocator();
-      } else {
-        if (!plain_allocator_storage_) {
-          plain_allocator_storage_ =
-            std::make_shared<PlainAllocator>(*this->get_allocator());
-        }
-
-        return rclcpp::allocator::get_rcl_allocator<char>(*plain_allocator_storage_);
-      }
+    if (!plain_allocator_storage_) {
+      plain_allocator_storage_ =
+        std::make_shared<PlainAllocator>(*this->get_allocator());
    }
+    return rclcpp::allocator::get_rcl_allocator<char>(*plain_allocator_storage_);
  }

  // This is a temporal workaround, to make sure that get_allocator()
--- a/rclcpp/include/rclcpp/qos.hpp
+++ b/rclcpp/include/rclcpp/qos.hpp
@@ -146,18 +146,10 @@ 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;

@@ -483,7 +475,7 @@ public:
  explicit
  RosoutQoS(
    const QoSInitialization & rosout_qos_initialization = (
-      QoSInitialization::from_rmw(rmw_qos_profile_rosout_default)
+      QoSInitialization::from_rmw(rcl_qos_profile_rosout_default)
  ));
 };

--- a/rclcpp/include/rclcpp/rate.hpp
+++ b/rclcpp/include/rclcpp/rate.hpp
@@ -58,12 +58,12 @@ public:
  RCLCPP_PUBLIC
  explicit Rate(
    const double rate,
-    const Clock::SharedPtr & clock = std::make_shared<Clock>(RCL_SYSTEM_TIME));
+    Clock::SharedPtr clock = std::make_shared<Clock>(RCL_SYSTEM_TIME));

  RCLCPP_PUBLIC
  explicit Rate(
    const Duration & period,
-    const Clock::SharedPtr & clock = std::make_shared<Clock>(RCL_SYSTEM_TIME));
+    Clock::SharedPtr clock = std::make_shared<Clock>(RCL_SYSTEM_TIME));

  RCLCPP_PUBLIC
  virtual bool
--- a/rclcpp/include/rclcpp/rclcpp.hpp
+++ b/rclcpp/include/rclcpp/rclcpp.hpp
@@ -68,6 +68,8 @@
 *
 * - Executors (responsible for execution of callbacks through a blocking spin):
 *   - rclcpp::spin()
+ *   - rclcpp::spin_some()
+ *   - rclcpp::spin_until_future_complete()
 *   - rclcpp::executors::SingleThreadedExecutor
 *   - rclcpp::executors::SingleThreadedExecutor::add_node()
 *   - rclcpp::executors::SingleThreadedExecutor::spin()
@@ -131,6 +133,9 @@
 * - 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
@@ -175,7 +180,6 @@
 #include "rclcpp/parameter_event_handler.hpp"
 #include "rclcpp/parameter.hpp"
 #include "rclcpp/parameter_service.hpp"
-#include "rclcpp/parameter_descriptor_wrapper.hpp"
 #include "rclcpp/rate.hpp"
 #include "rclcpp/time.hpp"
 #include "rclcpp/utilities.hpp"
@@ -183,4 +187,6 @@
 #include "rclcpp/waitable.hpp"
 #include "rclcpp/wait_set.hpp"

+#include "rclcpp/dynamic_subscription.hpp"
+
 #endif  // RCLCPP__RCLCPP_HPP_
--- a/rclcpp/include/rclcpp/serialized_message.hpp
+++ b/rclcpp/include/rclcpp/serialized_message.hpp
@@ -58,10 +58,10 @@ public:
  explicit SerializedMessage(const rcl_serialized_message_t & other);

  /// Move Constructor for a SerializedMessage
-  SerializedMessage(SerializedMessage && other) noexcept;
+  SerializedMessage(SerializedMessage && other);

  /// Constructor for a SerializedMessage from a moved rcl_serialized_message_t
-  explicit SerializedMessage(rcl_serialized_message_t && other) noexcept;
+  explicit SerializedMessage(rcl_serialized_message_t && other);

  /// Copy assignment operator
  SerializedMessage & operator=(const SerializedMessage & other);
@@ -70,10 +70,10 @@ public:
  SerializedMessage & operator=(const rcl_serialized_message_t & other);

  /// Move assignment operator
-  SerializedMessage & operator=(SerializedMessage && other) noexcept;
+  SerializedMessage & operator=(SerializedMessage && other);

  /// Move assignment operator from a rcl_serialized_message_t
-  SerializedMessage & operator=(rcl_serialized_message_t && other) noexcept;
+  SerializedMessage & operator=(rcl_serialized_message_t && other);

  /// Destructor for a SerializedMessage
  virtual ~SerializedMessage();
--- a/rclcpp/include/rclcpp/service.hpp
+++ b/rclcpp/include/rclcpp/service.hpp
@@ -22,7 +22,6 @@
 #include <mutex>
 #include <sstream>
 #include <string>
-#include <utility>

 #include "rcl/error_handling.h"
 #include "rcl/event_callback.h"
@@ -55,7 +54,7 @@ public:
  RCLCPP_SMART_PTR_DEFINITIONS_NOT_COPYABLE(ServiceBase)

  RCLCPP_PUBLIC
-  explicit ServiceBase(const std::shared_ptr<rcl_node_t> & node_handle);
+  explicit ServiceBase(std::shared_ptr<rcl_node_t> node_handle);

  RCLCPP_PUBLIC
  virtual ~ServiceBase() = default;
@@ -114,8 +113,8 @@ public:
  virtual
  void
  handle_request(
-    const std::shared_ptr<rmw_request_id_t> & request_header,
-    const std::shared_ptr<void> & request) = 0;
+    std::shared_ptr<rmw_request_id_t> request_header,
+    std::shared_ptr<void> request) = 0;

  /// Exchange the "in use by wait set" state for this service.
  /**
@@ -191,7 +190,7 @@ public:
   * \param[in] callback functor to be called when a new request is received
   */
  void
-  set_on_new_request_callback(const std::function<void(size_t)> & callback)
+  set_on_new_request_callback(std::function<void(size_t)> callback)
  {
    if (!callback) {
      throw std::invalid_argument(
@@ -287,7 +286,6 @@ class Service
  public std::enable_shared_from_this<Service<ServiceT>>
 {
 public:
-  using ServiceType = ServiceT;
  using CallbackType = std::function<
    void (
      const std::shared_ptr<typename ServiceT::Request>,
@@ -374,10 +372,10 @@ public:
   * \param[in] any_callback User defined callback to call when a client request is received.
   */
  Service(
-    const std::shared_ptr<rcl_node_t> & node_handle,
-    const std::shared_ptr<rcl_service_t> & service_handle,
+    std::shared_ptr<rcl_node_t> node_handle,
+    std::shared_ptr<rcl_service_t> service_handle,
    AnyServiceCallback<ServiceT> any_callback)
-  : ServiceBase(node_handle), any_callback_(std::move(any_callback)),
+  : ServiceBase(node_handle), any_callback_(any_callback),
    srv_type_support_handle_(rosidl_typesupport_cpp::get_service_type_support_handle<ServiceT>())
  {
    // check if service handle was initialized
@@ -409,10 +407,10 @@ public:
   * \param[in] any_callback User defined callback to call when a client request is received.
   */
  Service(
-    const std::shared_ptr<rcl_node_t> & node_handle,
+    std::shared_ptr<rcl_node_t> node_handle,
    rcl_service_t * service_handle,
    AnyServiceCallback<ServiceT> any_callback)
-  : ServiceBase(node_handle), any_callback_(std::move(any_callback)),
+  : ServiceBase(node_handle), any_callback_(any_callback),
    srv_type_support_handle_(rosidl_typesupport_cpp::get_service_type_support_handle<ServiceT>())
  {
    // check if service handle was initialized
@@ -473,8 +471,8 @@ public:

  void
  handle_request(
-    const std::shared_ptr<rmw_request_id_t> & request_header,
-    const std::shared_ptr<void> & request) override
+    std::shared_ptr<rmw_request_id_t> request_header,
+    std::shared_ptr<void> request) override
  {
    auto typed_request = std::static_pointer_cast<typename ServiceT::Request>(request);
    auto response = any_callback_.dispatch(this->shared_from_this(), request_header, typed_request);
@@ -506,13 +504,10 @@ 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(
-    const Clock::SharedPtr & clock, const QoS & qos_service_event_pub,
+    Clock::SharedPtr clock, const QoS & qos_service_event_pub,
    rcl_service_introspection_state_t introspection_state)
  {
    rcl_publisher_options_t pub_opts = rcl_publisher_get_default_options();
--- a/rclcpp/include/rclcpp/strategies/allocator_memory_strategy.hpp
+++ b/rclcpp/include/rclcpp/strategies/allocator_memory_strategy.hpp
@@ -99,92 +99,49 @@ public:
    // Important to use subscription_handles_.size() instead of wait set's size since
    // there may be more subscriptions in the wait set due to Waitables added to the end.
    // The same logic applies for other entities.
-
-    // Mark corresponding weak_ptr as expired for entities that are null in the wait set
-    size_t valid_subscription_count = 0;
    for (size_t i = 0; i < subscription_handles_.size(); ++i) {
-      if (valid_subscription_count < wait_set->size_of_subscriptions &&
-        !wait_set->subscriptions[valid_subscription_count])
-      {
-        subscription_handles_[i] = std::weak_ptr<const rcl_subscription_t>{};
-      }
-      if (subscription_handles_[i].lock()) {
-        ++valid_subscription_count;
+      if (!wait_set->subscriptions[i]) {
+        subscription_handles_[i].reset();
      }
    }
-
-    size_t valid_service_count = 0;
    for (size_t i = 0; i < service_handles_.size(); ++i) {
-      if (valid_service_count < wait_set->size_of_services &&
-        !wait_set->services[valid_service_count])
-      {
-        service_handles_[i] = std::weak_ptr<const rcl_service_t>{};
-      }
-      if (service_handles_[i].lock()) {
-        ++valid_service_count;
+      if (!wait_set->services[i]) {
+        service_handles_[i].reset();
      }
    }
-
-    size_t valid_client_count = 0;
    for (size_t i = 0; i < client_handles_.size(); ++i) {
-      if (valid_client_count < wait_set->size_of_clients &&
-        !wait_set->clients[valid_client_count])
-      {
-        client_handles_[i] = std::weak_ptr<const rcl_client_t>{};
-      }
-      if (client_handles_[i].lock()) {
-        ++valid_client_count;
+      if (!wait_set->clients[i]) {
+        client_handles_[i].reset();
      }
    }
-
-    size_t valid_timer_count = 0;
    for (size_t i = 0; i < timer_handles_.size(); ++i) {
-      if (valid_timer_count < wait_set->size_of_timers &&
-        !wait_set->timers[valid_timer_count])
-      {
-        timer_handles_[i] = std::weak_ptr<const rcl_timer_t>{};
-      }
-      if (timer_handles_[i].lock()) {
-        ++valid_timer_count;
+      if (!wait_set->timers[i]) {
+        timer_handles_[i].reset();
      }
    }
-
    for (size_t i = 0; i < waitable_handles_.size(); ++i) {
      if (!waitable_handles_[i]->is_ready(*wait_set)) {
        waitable_handles_[i].reset();
      }
    }

-    // Remove expired weak_ptr instances
    subscription_handles_.erase(
-      std::remove_if(subscription_handles_.begin(), subscription_handles_.end(),
-      [](const std::weak_ptr<const rcl_subscription_t> & weak_ptr) {
-        return weak_ptr.expired();
-        }),
+      std::remove(subscription_handles_.begin(), subscription_handles_.end(), nullptr),
      subscription_handles_.end()
    );

    service_handles_.erase(
-      std::remove_if(service_handles_.begin(), service_handles_.end(),
-      [](const std::weak_ptr<const rcl_service_t> & weak_ptr) {
-        return weak_ptr.expired();
-        }),
+      std::remove(service_handles_.begin(), service_handles_.end(), nullptr),
      service_handles_.end()
    );

    client_handles_.erase(
-      std::remove_if(client_handles_.begin(), client_handles_.end(),
-      [](const std::weak_ptr<const rcl_client_t> & weak_ptr) {
-        return weak_ptr.expired();
-        }),
+      std::remove(client_handles_.begin(), client_handles_.end(), nullptr),
      client_handles_.end()
    );

    timer_handles_.erase(
-      std::remove_if(timer_handles_.begin(), timer_handles_.end(),
-      [](const std::weak_ptr<const rcl_timer_t> & weak_ptr) {
-        return weak_ptr.expired();
-        }),
+      std::remove(timer_handles_.begin(), timer_handles_.end(), nullptr),
      timer_handles_.end()
    );

@@ -239,60 +196,38 @@ public:

  bool add_handles_to_wait_set(rcl_wait_set_t * wait_set) override
  {
-    for (const std::weak_ptr<const rcl_subscription_t> & weak_subscription :
-      subscription_handles_)
-    {
-      auto subscription = weak_subscription.lock();
-      if (!subscription) {
-        continue;  // Skip expired handles
-      }
+    for (const std::shared_ptr<const rcl_subscription_t> & subscription : subscription_handles_) {
      if (rcl_wait_set_add_subscription(wait_set, subscription.get(), NULL) != RCL_RET_OK) {
        RCUTILS_LOG_ERROR_NAMED(
          "rclcpp",
          "Couldn't add subscription to wait set: %s", rcl_get_error_string().str);
-        rcl_reset_error();
        return false;
      }
    }

-    for (const std::weak_ptr<const rcl_client_t> & weak_client : client_handles_) {
-      auto client = weak_client.lock();
-      if (!client) {
-        continue;  // Skip expired handles
-      }
+    for (const std::shared_ptr<const rcl_client_t> & client : client_handles_) {
      if (rcl_wait_set_add_client(wait_set, client.get(), NULL) != RCL_RET_OK) {
        RCUTILS_LOG_ERROR_NAMED(
          "rclcpp",
          "Couldn't add client to wait set: %s", rcl_get_error_string().str);
-        rcl_reset_error();
        return false;
      }
    }

-    for (const std::weak_ptr<const rcl_service_t> & weak_service : service_handles_) {
-      auto service = weak_service.lock();
-      if (!service) {
-        continue;  // Skip expired handles
-      }
+    for (const std::shared_ptr<const rcl_service_t> & service : service_handles_) {
      if (rcl_wait_set_add_service(wait_set, service.get(), NULL) != RCL_RET_OK) {
        RCUTILS_LOG_ERROR_NAMED(
          "rclcpp",
          "Couldn't add service to wait set: %s", rcl_get_error_string().str);
-        rcl_reset_error();
        return false;
      }
    }

-    for (const std::weak_ptr<const rcl_timer_t> & weak_timer : timer_handles_) {
-      auto timer = weak_timer.lock();
-      if (!timer) {
-        continue;  // Skip expired handles
-      }
+    for (const std::shared_ptr<const rcl_timer_t> & timer : timer_handles_) {
      if (rcl_wait_set_add_timer(wait_set, timer.get(), NULL) != RCL_RET_OK) {
        RCUTILS_LOG_ERROR_NAMED(
          "rclcpp",
          "Couldn't add timer to wait set: %s", rcl_get_error_string().str);
-        rcl_reset_error();
        return false;
      }
    }
@@ -314,13 +249,7 @@ public:
  {
    auto it = subscription_handles_.begin();
    while (it != subscription_handles_.end()) {
-      auto subscription_handle = it->lock();
-      if (!subscription_handle) {
-        // Handle expired, remove it and continue
-        it = subscription_handles_.erase(it);
-        continue;
-      }
-      auto subscription = get_subscription_by_handle(subscription_handle, weak_groups_to_nodes);
+      auto subscription = get_subscription_by_handle(*it, weak_groups_to_nodes);
      if (subscription) {
        // Find the group for this handle and see if it can be serviced
        auto group = get_group_by_subscription(subscription, weak_groups_to_nodes);
@@ -355,13 +284,7 @@ public:
  {
    auto it = service_handles_.begin();
    while (it != service_handles_.end()) {
-      auto service_handle = it->lock();
-      if (!service_handle) {
-        // Handle expired, remove it and continue
-        it = service_handles_.erase(it);
-        continue;
-      }
-      auto service = get_service_by_handle(service_handle, weak_groups_to_nodes);
+      auto service = get_service_by_handle(*it, weak_groups_to_nodes);
      if (service) {
        // Find the group for this handle and see if it can be serviced
        auto group = get_group_by_service(service, weak_groups_to_nodes);
@@ -396,13 +319,7 @@ public:
  {
    auto it = client_handles_.begin();
    while (it != client_handles_.end()) {
-      auto client_handle = it->lock();
-      if (!client_handle) {
-        // Handle expired, remove it and continue
-        it = client_handles_.erase(it);
-        continue;
-      }
-      auto client = get_client_by_handle(client_handle, weak_groups_to_nodes);
+      auto client = get_client_by_handle(*it, weak_groups_to_nodes);
      if (client) {
        // Find the group for this handle and see if it can be serviced
        auto group = get_group_by_client(client, weak_groups_to_nodes);
@@ -437,13 +354,7 @@ public:
  {
    auto it = timer_handles_.begin();
    while (it != timer_handles_.end()) {
-      auto timer_handle = it->lock();
-      if (!timer_handle) {
-        // Handle expired, remove it and continue
-        it = timer_handles_.erase(it);
-        continue;
-      }
-      auto timer = get_timer_by_handle(timer_handle, weak_groups_to_nodes);
+      auto timer = get_timer_by_handle(*it, weak_groups_to_nodes);
      if (timer) {
        // Find the group for this handle and see if it can be serviced
        auto group = get_group_by_timer(timer, weak_groups_to_nodes);
@@ -515,22 +426,12 @@ public:

  rcl_allocator_t get_allocator() override
  {
-    if constexpr (std::is_same_v<Alloc, std::allocator<void>>) {
-      return rcl_get_default_allocator();
-    } else {
-      return rclcpp::allocator::get_rcl_allocator<void *, VoidAlloc>(*allocator_.get());
-    }
+    return rclcpp::allocator::get_rcl_allocator<void *, VoidAlloc>(*allocator_.get());
  }

  size_t number_of_ready_subscriptions() const override
  {
-    size_t number_of_subscriptions = 0;
-    // Count only non-expired weak_ptr references
-    for (const auto & weak_subscription : subscription_handles_) {
-      if (!weak_subscription.expired()) {
-        ++number_of_subscriptions;
-      }
-    }
+    size_t number_of_subscriptions = subscription_handles_.size();
    for (const std::shared_ptr<Waitable> & waitable : waitable_handles_) {
      number_of_subscriptions += waitable->get_number_of_ready_subscriptions();
    }
@@ -539,13 +440,7 @@ public:

  size_t number_of_ready_services() const override
  {
-    size_t number_of_services = 0;
-    // Count only non-expired weak_ptr references
-    for (const auto & weak_service : service_handles_) {
-      if (!weak_service.expired()) {
-        ++number_of_services;
-      }
-    }
+    size_t number_of_services = service_handles_.size();
    for (const std::shared_ptr<Waitable> & waitable : waitable_handles_) {
      number_of_services += waitable->get_number_of_ready_services();
    }
@@ -563,13 +458,7 @@ public:

  size_t number_of_ready_clients() const override
  {
-    size_t number_of_clients = 0;
-    // Count only non-expired weak_ptr references
-    for (const auto & weak_client : client_handles_) {
-      if (!weak_client.expired()) {
-        ++number_of_clients;
-      }
-    }
+    size_t number_of_clients = client_handles_.size();
    for (const std::shared_ptr<Waitable> & waitable : waitable_handles_) {
      number_of_clients += waitable->get_number_of_ready_clients();
    }
@@ -587,13 +476,7 @@ public:

  size_t number_of_ready_timers() const override
  {
-    size_t number_of_timers = 0;
-    // Count only non-expired weak_ptr references
-    for (const auto & weak_timer : timer_handles_) {
-      if (!weak_timer.expired()) {
-        ++number_of_timers;
-      }
-    }
+    size_t number_of_timers = timer_handles_.size();
    for (const std::shared_ptr<Waitable> & waitable : waitable_handles_) {
      number_of_timers += waitable->get_number_of_ready_timers();
    }
@@ -612,10 +495,10 @@ private:

  VectorRebind<const rclcpp::GuardCondition *> guard_conditions_;

-  VectorRebind<std::weak_ptr<const rcl_subscription_t>> subscription_handles_;
-  VectorRebind<std::weak_ptr<const rcl_service_t>> service_handles_;
-  VectorRebind<std::weak_ptr<const rcl_client_t>> client_handles_;
-  VectorRebind<std::weak_ptr<const rcl_timer_t>> timer_handles_;
+  VectorRebind<std::shared_ptr<const rcl_subscription_t>> subscription_handles_;
+  VectorRebind<std::shared_ptr<const rcl_service_t>> service_handles_;
+  VectorRebind<std::shared_ptr<const rcl_client_t>> client_handles_;
+  VectorRebind<std::shared_ptr<const rcl_timer_t>> timer_handles_;
  VectorRebind<std::shared_ptr<Waitable>> waitable_handles_;

  std::shared_ptr<VoidAlloc> allocator_;
--- a/rclcpp/include/rclcpp/strategies/message_pool_memory_strategy.hpp
+++ b/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([[maybe_unused]] std::shared_ptr<MessageT> & msg)
+  void return_message(std::shared_ptr<MessageT> & msg)
  {
-    // This function is intentionally left empty.
+    (void)msg;
  }

 protected:
--- a/rclcpp/include/rclcpp/subscription.hpp
+++ b/rclcpp/include/rclcpp/subscription.hpp
@@ -209,11 +209,13 @@ public:
  /// Called after construction to continue setup that requires shared_from_this().
  void
  post_init_setup(
-    [[maybe_unused]] rclcpp::node_interfaces::NodeBaseInterface * node_base,
-    [[maybe_unused]] const rclcpp::QoS & qos,
-    [[maybe_unused]] const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options)
+    rclcpp::node_interfaces::NodeBaseInterface * node_base,
+    const rclcpp::QoS & qos,
+    const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options)
  {
-    // This function is intentionally left empty.
+    (void)node_base;
+    (void)qos;
+    (void)options;
  }

  /// Take the next message from the inter-process subscription.
@@ -279,50 +281,6 @@ public:
    return message_memory_strategy_->borrow_serialized_message();
  }

-  /// Disable callbacks from being called
-  /**
-    * This method will block, until any subscription's callbacks provided during construction
-    * currently being executed are finished.
-    * \note This method also temporary removes the on new message callback and all
-    * on new event callbacks from the rmw layer to prevent them from being called. However, this
-    * method will not block and wait until the currently executing on_new_[message]event callbacks
-    * are finished.
-    */
-  void
-  disable_callbacks() override
-  {
-    SubscriptionBase::disable_callbacks();
-    any_callback_.disable();
-    if (subscription_intra_process_) {
-      subscription_intra_process_->disable_callbacks();
-    }
-    for (const auto & [_, event_ptr] : event_handlers_) {
-      if (event_ptr) {
-        event_ptr->disable();
-      }
-    }
-  }
-
-  /// Enable the callbacks to be called
-  /**
-    * This method is thread safe, and provides a safe way to atomically enable the callbacks
-    * in a multithreaded environment.
-    */
-  void
-  enable_callbacks() override
-  {
-    SubscriptionBase::enable_callbacks();
-    any_callback_.enable();
-    if (subscription_intra_process_) {
-      subscription_intra_process_->enable_callbacks();
-    }
-    for (const auto & [_, event_ptr] : event_handlers_) {
-      if (event_ptr) {
-        event_ptr->enable();
-      }
-    }
-  }
-
  void
  handle_message(
    std::shared_ptr<void> & message,
@@ -464,17 +422,20 @@ public:

  void
  return_dynamic_message(
-    [[maybe_unused]] rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message) override
+    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(
-    [[maybe_unused]] const rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message,
-    [[maybe_unused]] const rclcpp::MessageInfo & message_info) override
+    const rclcpp::dynamic_typesupport::DynamicMessage::SharedPtr & message,
+    const rclcpp::MessageInfo & message_info) override
  {
+    (void) message;
+    (void) message_info;
    throw rclcpp::exceptions::UnimplementedError(
            "handle_dynamic_message is not implemented for Subscription");
  }
--- a/rclcpp/include/rclcpp/subscription_base.hpp
+++ b/rclcpp/include/rclcpp/subscription_base.hpp
@@ -20,8 +20,8 @@
 #include <mutex>
 #include <string>
 #include <unordered_map>
-#include <utility>
 #include <vector>
+#include <utility>

 #include "rcl/event_callback.h"
 #include "rcl/subscription.h"
@@ -212,23 +212,6 @@ public:
  std::shared_ptr<rclcpp::SerializedMessage>
  create_serialized_message() = 0;

-  /// Disable callbacks from being called
-  /**
-   * This function temporary removes the on_new_message_callback to prevent it from being called.
-   */
-  RCLCPP_PUBLIC
-  virtual
-  void disable_callbacks();
-
-  /// Enable the callbacks to be called
-  /**
-    * This function sets back the on_new_message_callback if it was previously removed in
-    * disable_callbacks().
-    */
-  RCLCPP_PUBLIC
-  virtual
-  void enable_callbacks();
-
  /// Check if we need to handle the message, and execute the callback if we do.
  /**
   * \param[in] message Shared pointer to the message to handle.
@@ -372,7 +355,7 @@ public:
   * \param[in] callback functor to be called when a new message is received
   */
  void
-  set_on_new_message_callback(const std::function<void(size_t)> & callback)
+  set_on_new_message_callback(std::function<void(size_t)> callback)
  {
    if (!callback) {
      throw std::invalid_argument(
@@ -400,7 +383,7 @@ public:
        }
      };

-    std::lock_guard<std::recursive_mutex> lock(on_new_message_callback_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);

    // Set it temporarily to the new callback, while we replace the old one.
    // This two-step setting, prevents a gap where the old std::function has
@@ -423,7 +406,7 @@ public:
  void
  clear_on_new_message_callback()
  {
-    std::lock_guard<std::recursive_mutex> lock(on_new_message_callback_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);

    if (on_new_message_callback_) {
      set_on_new_message_callback(nullptr, nullptr);
@@ -450,7 +433,7 @@ public:
   * \param[in] callback functor to be called when a new message is received
   */
  void
-  set_on_new_intra_process_message_callback(const std::function<void(size_t)> & callback)
+  set_on_new_intra_process_message_callback(std::function<void(size_t)> callback)
  {
    if (!use_intra_process_) {
      RCLCPP_WARN(
@@ -468,7 +451,7 @@ public:
    // The on_ready_callback signature has an extra `int` argument used to disambiguate between
    // possible different entities within a generic waitable.
    // We hide that detail to users of this method.
-    std::function<void(size_t, int)> new_callback = [callback] (size_t nr, int) {callback(nr);};
+    std::function<void(size_t, int)> new_callback = std::bind(callback, std::placeholders::_1);
    subscription_intra_process_->set_on_ready_callback(new_callback);
  }

@@ -514,7 +497,7 @@ public:
   */
  void
  set_on_new_qos_event_callback(
-    const std::function<void(size_t)> & callback,
+    std::function<void(size_t)> callback,
    rcl_subscription_event_type_t event_type)
  {
    if (event_handlers_.count(event_type) == 0) {
@@ -533,7 +516,7 @@ public:
    // The on_ready_callback signature has an extra `int` argument used to disambiguate between
    // possible different entities within a generic waitable.
    // We hide that detail to users of this method.
-    std::function<void(size_t, int)> new_callback = [callback] (size_t nr, int) {callback(nr);};
+    std::function<void(size_t, int)> new_callback = std::bind(callback, std::placeholders::_1);
    event_handlers_[event_type]->set_on_ready_callback(new_callback);
  }

@@ -661,9 +644,13 @@ 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 on_new_message_callback_mutex_;
+  std::recursive_mutex callback_mutex_;
  // It is important to declare on_new_message_callback_ before
  // subscription_handle_, so on destruction the subscription is
  // destroyed first. Otherwise, the rmw subscription callback
--- a/rclcpp/include/rclcpp/subscription_options.hpp
+++ b/rclcpp/include/rclcpp/subscription_options.hpp
@@ -89,15 +89,6 @@ struct SubscriptionOptionsBase
  QosOverridingOptions qos_overriding_options;

  ContentFilterOptions content_filter_options;
-
-  /// Acceptable buffer backend names for this subscription.
-  /**
-   * Empty string or "cpu" means CPU-only (default for backward compatibility).
-   * "any" means all installed backends are acceptable.
-   * Comma-separated for specific backends, e.g. "cuda,demo".
-   * CPU is always implicitly acceptable regardless of this value.
-   */
-  std::string acceptable_buffer_backends{"cpu"};
 };

 /// Structure containing optional configuration for Subscriptions.
@@ -154,11 +145,6 @@ struct SubscriptionOptionsWithAllocator : public SubscriptionOptionsBase
      }
    }

-    if (!acceptable_buffer_backends.empty()) {
-      result.rmw_subscription_options.acceptable_buffer_backends =
-        acceptable_buffer_backends.c_str();
-    }
-
    return result;
  }

@@ -181,20 +167,11 @@ private:
  rcl_allocator_t
  get_rcl_allocator() const
  {
-    if constexpr (std::is_same_v<Allocator, std::allocator<void>>) {
-      return rcl_get_default_allocator();
-    } else {
-      if constexpr (rclcpp::allocator::has_get_rcl_allocator_v<Allocator>) {
-        return get_allocator()->get_rcl_allocator();
-      } else {
-        if (!plain_allocator_storage_) {
-          plain_allocator_storage_ =
-            std::make_shared<PlainAllocator>(*this->get_allocator());
-        }
-
-        return rclcpp::allocator::get_rcl_allocator<char>(*plain_allocator_storage_);
-      }
+    if (!plain_allocator_storage_) {
+      plain_allocator_storage_ =
+        std::make_shared<PlainAllocator>(*this->get_allocator());
    }
+    return rclcpp::allocator::get_rcl_allocator<char>(*plain_allocator_storage_);
  }

  // This is a temporal workaround, to make sure that get_allocator()
--- a/rclcpp/include/rclcpp/time.hpp
+++ b/rclcpp/include/rclcpp/time.hpp
@@ -33,11 +33,12 @@ class Time
 public:
  /// Time constructor
  /**
-   * Indicates a specific point in time, relative to a clock's 0 point (its epoch).
-   * The total time since the epoch is given by seconds + nanoseconds.
+   * Initializes the time values for seconds and nanoseconds individually.
+   * Large values for nanoseconds are wrapped automatically with the remainder added to seconds.
+   * Both inputs must be integers.
   *
-   * \param seconds the seconds component, valid only if positive
-   * \param nanoseconds the nanoseconds component, to be added to the seconds component
+   * \param seconds part of the time in seconds since time epoch
+   * \param nanoseconds part of the time in nanoseconds since time epoch
   * \param clock_type clock type
   * \throws std::runtime_error if seconds are negative
   */
@@ -46,7 +47,7 @@ public:

  /// Time constructor
  /**
-   * \param nanoseconds the total time since the epoch in nanoseconds
+   * \param nanoseconds since time epoch
   * \param clock_type clock type
   * \throws std::runtime_error if nanoseconds are negative
   */
@@ -189,7 +190,7 @@ public:

  /// Get the nanoseconds since epoch
  /**
-   * \return the total time since the epoch in nanoseconds, as a rcl_time_point_value_t structure.
+   * \return the nanoseconds since epoch as a rcl_time_point_value_t structure.
   */
  RCLCPP_PUBLIC
  rcl_time_point_value_t
@@ -208,7 +209,7 @@ public:
   * \warning Depending on sizeof(double) there could be significant precision loss.
   * When an exact time is required use nanoseconds() instead.
   *
-   * \return the total time since the epoch in seconds, as a floating point number.
+   * \return the seconds since epoch as a floating point number.
   */
  RCLCPP_PUBLIC
  double
--- a/rclcpp/include/rclcpp/time_source.hpp
+++ b/rclcpp/include/rclcpp/time_source.hpp
@@ -60,7 +60,7 @@ public:
   */
  RCLCPP_PUBLIC
  explicit TimeSource(
-    const rclcpp::Node::SharedPtr & node,
+    rclcpp::Node::SharedPtr node,
    const rclcpp::QoS & qos = rclcpp::ClockQoS(),
    bool use_clock_thread = true);

@@ -89,7 +89,7 @@ public:
   * \param node std::shared pointer to a initialized node
   */
  RCLCPP_PUBLIC
-  void attachNode(const rclcpp::Node::SharedPtr & node);
+  void attachNode(rclcpp::Node::SharedPtr node);

  /// Attach node to the time source.
  /**
@@ -124,11 +124,11 @@ public:
   * \throws std::invalid_argument the time source must be a RCL_ROS_TIME otherwise throws an exception
   */
  RCLCPP_PUBLIC
-  void attachClock(const rclcpp::Clock::SharedPtr & clock);
+  void attachClock(rclcpp::Clock::SharedPtr clock);

  /// Detach a clock from the time source
  RCLCPP_PUBLIC
-  void detachClock(const rclcpp::Clock::SharedPtr & clock);
+  void detachClock(rclcpp::Clock::SharedPtr clock);

  /// Get whether a separate clock thread is used or not
  RCLCPP_PUBLIC
--- a/rclcpp/include/rclcpp/timer.hpp
+++ b/rclcpp/include/rclcpp/timer.hpp
@@ -183,7 +183,7 @@ public:
   */
  RCLCPP_PUBLIC
  void
-  set_on_reset_callback(const std::function<void(size_t)> & callback);
+  set_on_reset_callback(std::function<void(size_t)> callback);

  /// Unset the callback registered for reset timer
  RCLCPP_PUBLIC
--- a/rclcpp/include/rclcpp/type_adapter.hpp
+++ b/rclcpp/include/rclcpp/type_adapter.hpp
@@ -16,7 +16,6 @@
 #define RCLCPP__TYPE_ADAPTER_HPP_

 #include <type_traits>
-#include <new>

 namespace rclcpp
 {
@@ -129,24 +128,6 @@ struct assert_type_pair_is_specialized_type_adapter
    "No type adapter for this custom type/ros message type pair");
 };

-template<typename, typename = void>
-struct has_overloaded_operator_new : std::false_type {};
-template<typename T>
-struct has_overloaded_operator_new<T, std::void_t<
-    decltype(T::operator new(std::size_t()))
-  >>: std::true_type {};
-
-template<typename, typename = void>
-struct has_overloaded_aligned_operator_new : std::false_type {};
-template<typename T>
-struct has_overloaded_aligned_operator_new<T,
-  std::void_t<decltype( T::operator new(std::size_t(), std::align_val_t()) )>>
-  : std::true_type {};
-
-template<typename T>
-inline constexpr bool has_overloaded_operator_new_v = has_overloaded_operator_new<T>::value ||
-  has_overloaded_aligned_operator_new<T>::value;
-
 }  // namespace detail

 /// Template metafunction that can make the type being adapted explicit.
--- a/rclcpp/include/rclcpp/typesupport_helpers.hpp
+++ b/rclcpp/include/rclcpp/typesupport_helpers.hpp
@@ -21,7 +21,6 @@
 #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"

@@ -29,48 +28,26 @@

 namespace rclcpp
 {
-
-/// \brief Extract the package name, middle module, and type name from a full type string.
-/// \details This function takes a full type string (e.g., "std_msgs/msg/String") and extracts
-/// the package name, middle module (if any), and type name. The middle module is the part
-/// between the package name and the type name, which is typically used for message types.
-/// For example, for "std_msgs/msg/String", it returns ("std_msgs", "msg", "String").
-/// \param[in] full_type
-/// \throws std::runtime_error if the input full type string is malformed or does not follow the
-/// expected format.
-/// \return A tuple containing the package name, middle module (if any), and type name.
-RCLCPP_PUBLIC
-std::tuple<std::string, std::string, std::string>
-extract_type_identifier(const std::string & full_type);
-
-/// \brief Look for the library in the ament prefix paths and return the path to the type support
-/// library.
-/// \param[in] package_name The name of the package containing the type support library,
-/// e.g. "std_msgs".
-/// \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
-/// \throws std::runtime_error if the library is not found.
-/// \return The path to the type support library.
-RCLCPP_PUBLIC
-std::string get_typesupport_library_path(
-  const std::string & package_name, const std::string & typesupport_identifier);
-
-/// \brief Load the type support library for the given type.
-/// \param[in] type The topic type, e.g. "std_msgs/msg/String"
-/// \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
-/// \throws std::runtime_error if the library is not found or cannot be loaded.
-/// \return A shared library
+/// Load the type support library for the given type.
+/**
+ * \param[in] type The topic type, e.g. "std_msgs/msg/String"
+ * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
+ * \return A shared library
+ */
 RCLCPP_PUBLIC
 std::shared_ptr<rcpputils::SharedLibrary>
 get_typesupport_library(const std::string & type, const std::string & typesupport_identifier);

-/// \brief Extracts the message type support handle from the library.
-/// \note The library needs to match the topic type. The shared library must stay loaded for the
-/// lifetime of the result.
-/// \param[in] type The topic type, e.g. "std_msgs/msg/String"
-/// \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 message type support handle
+/// Extract the message 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.
+ *
+ * \param[in] type The topic type, e.g. "std_msgs/msg/String"
+ * \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 message type support handle
+ */
 RCLCPP_PUBLIC
 const rosidl_message_type_support_t *
 get_message_typesupport_handle(
@@ -78,14 +55,16 @@ get_message_typesupport_handle(
  const std::string & typesupport_identifier,
  rcpputils::SharedLibrary & library);

-/// \brief Extracts the service type support handle from the library.
-/// \note 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"
-/// \param[in] library The shared type support library
-/// \throws std::runtime_error if the symbol of type not found in the library.
-/// \return A service type support 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.
+ *
+ * \param[in] type The service type, e.g. "std_srvs/srv/Empty"
+ * \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 service type support handle
+ */
 RCLCPP_PUBLIC
 const rosidl_service_type_support_t *
 get_service_typesupport_handle(
@@ -93,21 +72,6 @@ get_service_typesupport_handle(
  const std::string & typesupport_identifier,
  rcpputils::SharedLibrary & library);

-/// \brief Extracts the action type support handle from the library.
-/// \note 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_
--- a/rclcpp/include/rclcpp/utilities.hpp
+++ b/rclcpp/include/rclcpp/utilities.hpp
@@ -22,7 +22,6 @@
 #include <vector>

 #include "rclcpp/context.hpp"
-#include "rclcpp/contexts/default_context.hpp"
 #include "rclcpp/init_options.hpp"
 #include "rclcpp/visibility_control.hpp"

@@ -174,7 +173,7 @@ remove_ros_arguments(int argc, char const * const * argv);
 */
 RCLCPP_PUBLIC
 bool
-ok(const rclcpp::Context::SharedPtr & context = rclcpp::contexts::get_global_default_context());
+ok(rclcpp::Context::SharedPtr context = nullptr);

 /// Shutdown rclcpp context, invalidating it for derived entities.
 /**
@@ -193,7 +192,7 @@ ok(const rclcpp::Context::SharedPtr & context = rclcpp::contexts::get_global_def
 RCLCPP_PUBLIC
 bool
 shutdown(
-  const rclcpp::Context::SharedPtr & context = rclcpp::contexts::get_global_default_context(),
+  rclcpp::Context::SharedPtr context = nullptr,
  const std::string & reason = "user called rclcpp::shutdown()");

 /// Register a function to be called when shutdown is called on the context.
@@ -213,9 +212,7 @@ shutdown(
 */
 RCLCPP_PUBLIC
 void
-on_shutdown(
-  const std::function<void()> & callback,
-  const rclcpp::Context::SharedPtr & context = rclcpp::contexts::get_global_default_context());
+on_shutdown(std::function<void()> callback, rclcpp::Context::SharedPtr context = nullptr);

 /// Use the global condition variable to block for the specified amount of time.
 /**
@@ -234,7 +231,7 @@ RCLCPP_PUBLIC
 bool
 sleep_for(
  const std::chrono::nanoseconds & nanoseconds,
-  const rclcpp::Context::SharedPtr & context = rclcpp::contexts::get_global_default_context());
+  rclcpp::Context::SharedPtr context = nullptr);

 /// Safely check if addition will overflow.
 /**
--- a/rclcpp/include/rclcpp/wait_for_message.hpp
+++ b/rclcpp/include/rclcpp/wait_for_message.hpp
@@ -15,7 +15,6 @@
 #ifndef RCLCPP__WAIT_FOR_MESSAGE_HPP_
 #define RCLCPP__WAIT_FOR_MESSAGE_HPP_

-#include <future>
 #include <memory>
 #include <string>

@@ -24,7 +23,6 @@
 #include "rclcpp/node.hpp"
 #include "rclcpp/visibility_control.hpp"
 #include "rclcpp/wait_set.hpp"
-#include "rclcpp/qos.hpp"

 namespace rclcpp
 {
@@ -56,7 +54,7 @@ bool wait_for_message(
      }
    });

-  rclcpp::WaitSet wait_set({}, {}, {}, {}, {}, {}, context);
+  rclcpp::WaitSet wait_set;
  wait_set.add_subscription(subscription);
  RCPPUTILS_SCOPE_EXIT(wait_set.remove_subscription(subscription); );
  wait_set.add_guard_condition(gc);
@@ -81,11 +79,10 @@ bool wait_for_message(
 /**
 * Wait for the next incoming message to arrive on a specified topic before the specified timeout.
 *
- * \param[out] out is the message to be filled when a new message is arriving
+ * \param[out] out is the message to be filled when a new message is arriving.
 * \param[in] node the node pointer to initialize the subscription on.
 * \param[in] topic the topic to wait for messages.
 * \param[in] time_to_wait parameter specifying the timeout before returning.
- * \param[in] qos parameter specifying QoS settings for the subscription.
 * \return true if a message was successfully received, false if message could not
 * be obtained or shutdown was triggered asynchronously on the context.
 */
@@ -94,10 +91,9 @@ bool wait_for_message(
  MsgT & out,
  rclcpp::Node::SharedPtr node,
  const std::string & topic,
-  std::chrono::duration<Rep, Period> time_to_wait = std::chrono::duration<Rep, Period>(-1),
-  const rclcpp::QoS & qos = rclcpp::SystemDefaultsQoS())
+  std::chrono::duration<Rep, Period> time_to_wait = std::chrono::duration<Rep, Period>(-1))
 {
-  auto sub = node->create_subscription<MsgT>(topic, qos, [](const std::shared_ptr<const MsgT>) {});
+  auto sub = node->create_subscription<MsgT>(topic, 1, [](const std::shared_ptr<const MsgT>) {});
  return wait_for_message<MsgT, Rep, Period>(
    out, sub, node->get_node_options().context(), time_to_wait);
 }
--- a/rclcpp/include/rclcpp/wait_result.hpp
+++ b/rclcpp/include/rclcpp/wait_result.hpp
@@ -176,9 +176,7 @@ public:
      for (; ii < wait_set.size_of_timers(); ++ii) {
        if (rcl_wait_set.timers[ii] != nullptr) {
          ret = wait_set.timers(ii);
-          if (ret) {
-            break;
-          }
+          break;
        }
      }
    }
@@ -219,9 +217,7 @@ public:
        if (rcl_wait_set.subscriptions[ii] != nullptr) {
          ret = wait_set.subscriptions(ii);
          rcl_wait_set.subscriptions[ii] = nullptr;
-          if (ret) {
-            break;
-          }
+          break;
        }
      }
    }
@@ -241,9 +237,7 @@ public:
        if (rcl_wait_set.services[ii] != nullptr) {
          ret = wait_set.services(ii);
          rcl_wait_set.services[ii] = nullptr;
-          if (ret) {
-            break;
-          }
+          break;
        }
      }
    }
@@ -263,9 +257,7 @@ public:
        if (rcl_wait_set.clients[ii] != nullptr) {
          ret = wait_set.clients(ii);
          rcl_wait_set.clients[ii] = nullptr;
-          if (ret) {
-            break;
-          }
+          break;
        }
      }
    }
--- a/rclcpp/include/rclcpp/wait_set_policies/dynamic_storage.hpp
+++ b/rclcpp/include/rclcpp/wait_set_policies/dynamic_storage.hpp
@@ -216,11 +216,6 @@ public:
      shared_waitables_
    );

-    if (this->needs_pruning_) {
-      this->storage_prune_deleted_entities();
-      this->needs_pruning_ = false;
-    }
-
    this->storage_release_ownerships();
  }

@@ -460,60 +455,59 @@ public:

  size_t size_of_subscriptions() const
  {
-    return subscriptions_.size();
+    return shared_subscriptions_.size();
  }

  size_t size_of_timers() const
  {
-    return timers_.size();
+    return shared_timers_.size();
  }

  size_t size_of_clients() const
  {
-    return clients_.size();
+    return shared_clients_.size();
  }

  size_t size_of_services() const
  {
-    return services_.size();
+    return shared_services_.size();
  }

  size_t size_of_waitables() const
  {
-    return waitables_.size();
+    return shared_waitables_.size();
  }

  std::shared_ptr<rclcpp::SubscriptionBase>
  subscriptions(size_t ii) const
  {
-    return subscriptions_[ii].lock();
+    return shared_subscriptions_[ii].subscription;
  }

  std::shared_ptr<rclcpp::TimerBase>
  timers(size_t ii) const
  {
-    return timers_[ii].lock();
+    return shared_timers_[ii];
  }

  std::shared_ptr<rclcpp::ClientBase>
  clients(size_t ii) const
  {
-    return clients_[ii].lock();
+    return shared_clients_[ii];
  }

  std::shared_ptr<rclcpp::ServiceBase>
  services(size_t ii) const
  {
-    return services_[ii].lock();
+    return shared_services_[ii];
  }

  std::shared_ptr<rclcpp::Waitable>
  waitables(size_t ii) const
  {
-    return waitables_[ii].lock();
+    return shared_waitables_[ii].waitable;
  }

-private:
  size_t ownership_reference_counter_ = 0;

  SequenceOfWeakSubscriptions subscriptions_;
--- a/rclcpp/include/rclcpp/wait_set_policies/static_storage.hpp
+++ b/rclcpp/include/rclcpp/wait_set_policies/static_storage.hpp
@@ -160,15 +160,6 @@ 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
--- a/rclcpp/include/rclcpp/wait_set_template.hpp
+++ b/rclcpp/include/rclcpp/wait_set_template.hpp
@@ -704,12 +704,10 @@ public:
            return WaitResult<WaitSetTemplate>::from_timeout_wait_result_kind();
          case WaitResultKind::Empty:
            return WaitResult<WaitSetTemplate>::from_empty_wait_result_kind();
-          case WaitResultKind::Invalid:
-            auto msg = "invalid WaitResultKind with value: " + std::to_string(wait_result_kind);
+          default:
+            auto msg = "unknown WaitResultKind with value: " + std::to_string(wait_result_kind);
            throw std::runtime_error(msg);
        }
-        // This should never be reached, but is needed to satisfy the compiler
-        throw std::runtime_error("unreachable code in wait result kind switch");
      }
    );
  }
@@ -736,6 +734,8 @@ 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,6 +752,8 @@ 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();
  }
--- a/rclcpp/include/rclcpp/waitable.hpp
+++ b/rclcpp/include/rclcpp/waitable.hpp
@@ -18,7 +18,6 @@
 #include <atomic>
 #include <functional>
 #include <memory>
-#include <vector>

 #include "rclcpp/macros.hpp"
 #include "rclcpp/visibility_control.hpp"
@@ -28,8 +27,6 @@
 namespace rclcpp
 {

-class TimerBase;
-
 class Waitable
 {
 public:
@@ -261,17 +258,6 @@ 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
--- a/rclcpp/package.xml
+++ b/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>30.1.5</version>
+  <version>29.3.0</version>
  <description>The ROS client library in C++.</description>

  <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
@@ -17,7 +17,6 @@
  <buildtool_depend>ament_cmake_ros</buildtool_depend>
  <buildtool_depend>ament_cmake_gen_version_h</buildtool_depend>
  <buildtool_depend>python3</buildtool_depend>
-  <buildtool_depend>python3-empy</buildtool_depend>

  <build_depend>ament_index_cpp</build_depend>
  <build_depend>builtin_interfaces</build_depend>
@@ -47,9 +46,9 @@
  <depend>statistics_msgs</depend>
  <depend>tracetools</depend>

+  <test_depend>ament_cmake_gmock</test_depend>
  <test_depend>ament_cmake_google_benchmark</test_depend>
  <test_depend>ament_cmake_gtest</test_depend>
-  <test_depend>ament_cmake_ros</test_depend>
  <test_depend>ament_lint_auto</test_depend>
  <test_depend>ament_lint_common</test_depend>
  <test_depend>mimick_vendor</test_depend>
--- a/rclcpp/resource/logging.hpp.em
+++ b/rclcpp/resource/logging.hpp.em
@@ -0,0 +1,165 @@
+// generated from rclcpp/resource/logging.hpp.em
+
+// Copyright 2017 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__LOGGING_HPP_
+#define RCLCPP__LOGGING_HPP_
+
+#include <sstream>
+#include <type_traits>
+
+#include "rclcpp/logger.hpp"
+#include "rcutils/logging_macros.h"
+#include "rclcpp/utilities.hpp"
+
+// These are used for compiling out logging macros lower than a minimum severity.
+#define RCLCPP_LOG_MIN_SEVERITY_DEBUG 0
+#define RCLCPP_LOG_MIN_SEVERITY_INFO 1
+#define RCLCPP_LOG_MIN_SEVERITY_WARN 2
+#define RCLCPP_LOG_MIN_SEVERITY_ERROR 3
+#define RCLCPP_LOG_MIN_SEVERITY_FATAL 4
+#define RCLCPP_LOG_MIN_SEVERITY_NONE 5
+
+#define RCLCPP_FIRST_ARG(N, ...) N
+#define RCLCPP_ALL_BUT_FIRST_ARGS(N, ...) __VA_ARGS__
+
+/**
+ * \def RCLCPP_LOG_MIN_SEVERITY
+ * Define RCLCPP_LOG_MIN_SEVERITY=RCLCPP_LOG_MIN_SEVERITY_[DEBUG|INFO|WARN|ERROR|FATAL]
+ * in your build options to compile out anything below that severity.
+ * Use RCLCPP_LOG_MIN_SEVERITY_NONE to compile out all macros.
+ */
+#ifndef RCLCPP_LOG_MIN_SEVERITY
+#define RCLCPP_LOG_MIN_SEVERITY RCLCPP_LOG_MIN_SEVERITY_DEBUG
+#endif
+
+@{
+from collections import OrderedDict
+from copy import deepcopy
+from rcutils.logging import feature_combinations
+from rcutils.logging import get_suffix_from_features
+from rcutils.logging import severities
+from rcutils.logging import throttle_args
+from rcutils.logging import throttle_params
+
+throttle_args['condition_before'] = 'RCUTILS_LOG_CONDITION_THROTTLE_BEFORE(clock, duration)'
+del throttle_params['get_time_point_value']
+throttle_params['clock'] = 'rclcpp::Clock that will be used to get the time point.'
+throttle_params.move_to_end('clock', last=False)
+
+rclcpp_feature_combinations = OrderedDict()
+for combinations, feature in feature_combinations.items():
+    # skip feature combinations using 'named'
+    if 'named' in combinations:
+        continue
+    rclcpp_feature_combinations[combinations] = feature
+# add a stream variant for each available feature combination
+stream_arg = 'stream_arg'
+for combinations, feature in list(rclcpp_feature_combinations.items()):
+    combinations = ('stream', ) + combinations
+    feature = deepcopy(feature)
+    feature.params[stream_arg] = 'The argument << into a stringstream'
+    rclcpp_feature_combinations[combinations] = feature
+
+def get_rclcpp_suffix_from_features(features):
+    suffix = get_suffix_from_features(features)
+    if 'stream' in features:
+        suffix = '_STREAM' + suffix
+    return suffix
+}@
+@[for severity in severities]@
+/** @@name Logging macros for severity @(severity).
+ */
+///@@{
+#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_@(severity))
+// empty logging macros for severity @(severity) when being disabled at compile time
+@[ for feature_combination in rclcpp_feature_combinations.keys()]@
+@{suffix = get_rclcpp_suffix_from_features(feature_combination)}@
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_@(severity)@(suffix)(...)
+@[ end for]@
+
+#else
+@[ for feature_combination in rclcpp_feature_combinations.keys()]@
+@{suffix = get_rclcpp_suffix_from_features(feature_combination)}@
+// The RCLCPP_@(severity)@(suffix) macro is surrounded by do { .. } while (0)
+// to implement the standard C macro idiom to make the macro safe in all
+// contexts; see http://c-faq.com/cpp/multistmt.html for more information.
+/**
+ * \def RCLCPP_@(severity)@(suffix)
+ * Log a message with severity @(severity)@
+@[ if rclcpp_feature_combinations[feature_combination].doc_lines]@
+ with the following conditions:
+@[ else]@
+.
+@[ end if]@
+@[ for doc_line in rclcpp_feature_combinations[feature_combination].doc_lines]@
+ * @(doc_line)
+@[ end for]@
+ * \param logger The `rclcpp::Logger` to use
+@[ for param_name, doc_line in rclcpp_feature_combinations[feature_combination].params.items()]@
+ * \param @(param_name) @(doc_line)
+@[ end for]@
+@[ if 'stream' not in feature_combination]@
+ * \param ... The format string, followed by the variable arguments for the format string.
+@[ end if]@
+ */
+@{params = rclcpp_feature_combinations[feature_combination].params.keys()}@
+#define RCLCPP_@(severity)@(suffix)(logger@(''.join([', ' + p for p in params]))@
+@[ if 'stream' not in feature_combination]@
+, ...@
+@[ end if]@
+) \
+  do { \
+    static_assert( \
+      ::std::is_same<typename std::remove_cv_t<typename std::remove_reference_t<decltype(logger)>>, \
+      typename ::rclcpp::Logger>::value, \
+      "First argument to logging macros must be an rclcpp::Logger"); \
+@[ if 'throttle' in feature_combination]@ \
+    auto get_time_point = [&c=clock](rcutils_time_point_value_t * time_point) -> rcutils_ret_t { \
+      try { \
+        *time_point = c.now().nanoseconds(); \
+      } catch (...) { \
+        RCUTILS_SAFE_FWRITE_TO_STDERR( \
+        "[rclcpp|logging.hpp] RCLCPP_@(severity)@(suffix) could not get current time stamp\n"); \
+        return RCUTILS_RET_ERROR; \
+      } \
+        return RCUTILS_RET_OK; \
+    }; \
+@[ end if] \
+@[ if 'stream' in feature_combination]@
+    std::stringstream rclcpp_stream_ss_; \
+    rclcpp_stream_ss_ << @(stream_arg); \
+@[ end if]@
+    RCUTILS_LOG_@(severity)@(get_suffix_from_features(feature_combination))_NAMED( \
+@{params = ['get_time_point' if p == 'clock' and 'throttle' in feature_combination else p for p in params]}@
+@[ if params]@
+@(''.join(['      ' + p + ', \\\n' for p in params if p != stream_arg]))@
+@[ end if]@
+      (logger).get_name(), \
+@[ if 'stream' not in feature_combination]@
+      __VA_ARGS__); \
+@[ else]@
+      "%s", rclcpp_stream_ss_.str().c_str()); \
+@[ end if]@
+  } while (0)
+
+@[ end for]@
+#endif
+///@@}
+
+@[end for]@
+
+#endif  // RCLCPP__LOGGING_HPP_
--- a/rclcpp/src/rclcpp/callback_group.cpp
+++ b/rclcpp/src/rclcpp/callback_group.cpp
@@ -31,7 +31,7 @@ using rclcpp::CallbackGroupType;

 CallbackGroup::CallbackGroup(
  CallbackGroupType group_type,
-  const rclcpp::Context::WeakPtr & context,
+  rclcpp::Context::WeakPtr context,
  bool automatically_add_to_executor_with_node)
 : type_(group_type), associated_with_executor_(false),
  can_be_taken_from_(true),
@@ -59,7 +59,6 @@ CallbackGroup::type() const
 size_t
 CallbackGroup::size() const
 {
-  std::lock_guard<std::mutex> lock(mutex_);
  return
    subscription_ptrs_.size() +
    service_ptrs_.size() +
@@ -69,11 +68,11 @@ CallbackGroup::size() const
 }

 void CallbackGroup::collect_all_ptrs(
-  const std::function<void(const rclcpp::SubscriptionBase::SharedPtr &)> & sub_func,
-  const std::function<void(const rclcpp::ServiceBase::SharedPtr &)> & service_func,
-  const std::function<void(const rclcpp::ClientBase::SharedPtr &)> & client_func,
-  const std::function<void(const rclcpp::TimerBase::SharedPtr &)> & timer_func,
-  const std::function<void(const rclcpp::Waitable::SharedPtr &)> & waitable_func) const
+  std::function<void(const rclcpp::SubscriptionBase::SharedPtr &)> sub_func,
+  std::function<void(const rclcpp::ServiceBase::SharedPtr &)> service_func,
+  std::function<void(const rclcpp::ClientBase::SharedPtr &)> client_func,
+  std::function<void(const rclcpp::TimerBase::SharedPtr &)> timer_func,
+  std::function<void(const rclcpp::Waitable::SharedPtr &)> waitable_func) const
 {
  std::lock_guard<std::mutex> lock(mutex_);

@@ -150,7 +149,7 @@ CallbackGroup::trigger_notify_guard_condition()

 void
 CallbackGroup::add_subscription(
-  const rclcpp::SubscriptionBase::SharedPtr & subscription_ptr)
+  const rclcpp::SubscriptionBase::SharedPtr subscription_ptr)
 {
  std::lock_guard<std::mutex> lock(mutex_);
  subscription_ptrs_.push_back(subscription_ptr);
@@ -158,12 +157,12 @@ CallbackGroup::add_subscription(
    std::remove_if(
      subscription_ptrs_.begin(),
      subscription_ptrs_.end(),
-      [](const rclcpp::SubscriptionBase::WeakPtr & x) {return x.expired();}),
+      [](rclcpp::SubscriptionBase::WeakPtr x) {return x.expired();}),
    subscription_ptrs_.end());
 }

 void
-CallbackGroup::add_timer(const rclcpp::TimerBase::SharedPtr & timer_ptr)
+CallbackGroup::add_timer(const rclcpp::TimerBase::SharedPtr timer_ptr)
 {
  std::lock_guard<std::mutex> lock(mutex_);
  timer_ptrs_.push_back(timer_ptr);
@@ -171,12 +170,12 @@ CallbackGroup::add_timer(const rclcpp::TimerBase::SharedPtr & timer_ptr)
    std::remove_if(
      timer_ptrs_.begin(),
      timer_ptrs_.end(),
-      [](const rclcpp::TimerBase::WeakPtr & x) {return x.expired();}),
+      [](rclcpp::TimerBase::WeakPtr x) {return x.expired();}),
    timer_ptrs_.end());
 }

 void
-CallbackGroup::add_service(const rclcpp::ServiceBase::SharedPtr & service_ptr)
+CallbackGroup::add_service(const rclcpp::ServiceBase::SharedPtr service_ptr)
 {
  std::lock_guard<std::mutex> lock(mutex_);
  service_ptrs_.push_back(service_ptr);
@@ -184,12 +183,12 @@ CallbackGroup::add_service(const rclcpp::ServiceBase::SharedPtr & service_ptr)
    std::remove_if(
      service_ptrs_.begin(),
      service_ptrs_.end(),
-      [](const rclcpp::ServiceBase::WeakPtr & x) {return x.expired();}),
+      [](rclcpp::ServiceBase::WeakPtr x) {return x.expired();}),
    service_ptrs_.end());
 }

 void
-CallbackGroup::add_client(const rclcpp::ClientBase::SharedPtr & client_ptr)
+CallbackGroup::add_client(const rclcpp::ClientBase::SharedPtr client_ptr)
 {
  std::lock_guard<std::mutex> lock(mutex_);
  client_ptrs_.push_back(client_ptr);
@@ -197,12 +196,12 @@ CallbackGroup::add_client(const rclcpp::ClientBase::SharedPtr & client_ptr)
    std::remove_if(
      client_ptrs_.begin(),
      client_ptrs_.end(),
-      [](const rclcpp::ClientBase::WeakPtr & x) {return x.expired();}),
+      [](rclcpp::ClientBase::WeakPtr x) {return x.expired();}),
    client_ptrs_.end());
 }

 void
-CallbackGroup::add_waitable(const rclcpp::Waitable::SharedPtr & waitable_ptr)
+CallbackGroup::add_waitable(const rclcpp::Waitable::SharedPtr waitable_ptr)
 {
  std::lock_guard<std::mutex> lock(mutex_);
  waitable_ptrs_.push_back(waitable_ptr);
@@ -210,12 +209,12 @@ CallbackGroup::add_waitable(const rclcpp::Waitable::SharedPtr & waitable_ptr)
    std::remove_if(
      waitable_ptrs_.begin(),
      waitable_ptrs_.end(),
-      [](const rclcpp::Waitable::WeakPtr & x) {return x.expired();}),
+      [](rclcpp::Waitable::WeakPtr x) {return x.expired();}),
    waitable_ptrs_.end());
 }

 void
-CallbackGroup::remove_waitable(const rclcpp::Waitable::SharedPtr & waitable_ptr) noexcept
+CallbackGroup::remove_waitable(const rclcpp::Waitable::SharedPtr waitable_ptr) noexcept
 {
  std::lock_guard<std::mutex> lock(mutex_);
  for (auto iter = waitable_ptrs_.begin(); iter != waitable_ptrs_.end(); ++iter) {
--- a/rclcpp/src/rclcpp/client.cpp
+++ b/rclcpp/src/rclcpp/client.cpp
@@ -37,7 +37,7 @@ using rclcpp::exceptions::throw_from_rcl_error;

 ClientBase::ClientBase(
  rclcpp::node_interfaces::NodeBaseInterface * node_base,
-  const rclcpp::node_interfaces::NodeGraphInterface::SharedPtr & node_graph)
+  rclcpp::node_interfaces::NodeGraphInterface::SharedPtr node_graph)
 : node_graph_(node_graph),
  node_handle_(node_base->get_shared_rcl_node_handle()),
  context_(node_base->get_context()),
--- a/rclcpp/src/rclcpp/clock.cpp
+++ b/rclcpp/src/rclcpp/clock.cpp
@@ -60,8 +60,8 @@ JumpHandler::JumpHandler(
  pre_callback_t pre_callback,
  post_callback_t post_callback,
  const rcl_jump_threshold_t & threshold)
-: pre_callback(std::move(pre_callback)),
-  post_callback(std::move(post_callback)),
+: pre_callback(pre_callback),
+  post_callback(post_callback),
  notice_threshold(threshold)
 {}

@@ -83,10 +83,20 @@ 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(
-  const Time & until,
-  const Context::SharedPtr & context)
+  Time until,
+  Context::SharedPtr context)
 {
  if (!context || !context->is_valid()) {
    throw std::runtime_error("context cannot be slept with because it's invalid");
@@ -194,7 +204,7 @@ Clock::sleep_until(
 }

 bool
-Clock::sleep_for(const Duration & rel_time, const Context::SharedPtr & context)
+Clock::sleep_for(Duration rel_time, Context::SharedPtr context)
 {
  return sleep_until(now() + rel_time, context);
 }
@@ -209,7 +219,7 @@ Clock::started()
 }

 bool
-Clock::wait_until_started(const Context::SharedPtr & context)
+Clock::wait_until_started(Context::SharedPtr context)
 {
  if (!context || !context->is_valid()) {
    throw std::runtime_error("context cannot be slept with because it's invalid");
@@ -229,7 +239,7 @@ Clock::wait_until_started(const Context::SharedPtr & context)
 bool
 Clock::wait_until_started(
  const Duration & timeout,
-  const Context::SharedPtr & context,
+  Context::SharedPtr context,
  const Duration & wait_tick_ns)
 {
  if (!context || !context->is_valid()) {
@@ -318,8 +328,8 @@ Clock::on_time_jump(

 JumpHandler::SharedPtr
 Clock::create_jump_callback(
-  const JumpHandler::pre_callback_t & pre_callback,
-  const JumpHandler::post_callback_t & post_callback,
+  JumpHandler::pre_callback_t pre_callback,
+  JumpHandler::post_callback_t post_callback,
  const rcl_jump_threshold_t & threshold)
 {
  // Allocate a new jump handler
@@ -357,245 +367,4 @@ 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, const 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, const 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,
-  const 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, const rclcpp::Time & until,
-  const std::function<bool ()> & pred)
-{
-  return impl_->wait_until(lock, until, pred);
-}
-
-std::mutex &
-ClockConditionalVariable::mutex()
-{
-  return impl_->mutex();
-}
-
 }  // namespace rclcpp
--- a/rclcpp/src/rclcpp/context.cpp
+++ b/rclcpp/src/rclcpp/context.cpp
@@ -28,7 +28,7 @@
 #include "rclcpp/detail/utilities.hpp"
 #include "rclcpp/exceptions.hpp"
 #include "rclcpp/logging.hpp"
-#include "rclcpp/graph_listener.hpp"
+
 #include "rcutils/error_handling.h"
 #include "rcutils/macros.h"

@@ -59,7 +59,7 @@ public:
      std::remove_if(
        weak_contexts_.begin(),
        weak_contexts_.end(),
-        [context](const Context::WeakPtr & weak_context) {
+        [context](const Context::WeakPtr weak_context) {
          auto locked_context = weak_context.lock();
          if (!locked_context) {
            // take advantage and removed expired contexts
@@ -145,8 +145,7 @@ rclcpp_logging_output_handler(
 Context::Context()
 : rcl_context_(nullptr),
  shutdown_reason_(""),
-  logging_mutex_(nullptr),
-  graph_listener_(nullptr)
+  logging_mutex_(nullptr)
 {}

 Context::~Context()
@@ -244,24 +243,6 @@ Context::init(

    weak_contexts_ = get_weak_contexts();
    weak_contexts_->add_context(this->shared_from_this());
-
-
-    std::lock_guard<std::recursive_mutex> lock (on_shutdown_callbacks_mutex_);
-
-    graph_listener_ = std::make_shared<graph_listener::GraphListener>(shared_from_this());
-
-    if (!graph_listener_->is_started()) {
-    // Register an on_shutdown hook to shutdown the graph listener.
-    // This is important to ensure that the wait set is finalized before
-    // destruction of static objects occurs.
-      std::weak_ptr<rclcpp::graph_listener::GraphListener> weak_graph_listener = graph_listener_;
-      on_shutdown ([weak_graph_listener]() {
-          auto shared_graph_listener = weak_graph_listener.lock();
-          if(shared_graph_listener) {
-            shared_graph_listener->shutdown(std::nothrow);
-          }
-    });
-    }
  } catch (const std::exception & e) {
    ret = rcl_shutdown(rcl_context_.get());
    rcl_context_.reset();
@@ -329,16 +310,9 @@ Context::shutdown(const std::string & reason)

  // call each pre-shutdown callback
  {
-    std::lock_guard<std::recursive_mutex> lock{pre_shutdown_callbacks_mutex_};
-    // callbacks may delete other callbacks during the execution,
-    // therefore we need to save a copy and check before execution
-    // if the next callback is still present
-    auto cpy = pre_shutdown_callbacks_;
-    for (const auto & callback : cpy) {
-      auto it = std::find(pre_shutdown_callbacks_.begin(), pre_shutdown_callbacks_.end(), callback);
-      if(it != pre_shutdown_callbacks_.end()) {
-        (*callback)();
-      }
+    std::lock_guard<std::mutex> lock{pre_shutdown_callbacks_mutex_};
+    for (const auto & callback : pre_shutdown_callbacks_) {
+      (*callback)();
    }
  }

@@ -351,16 +325,9 @@ Context::shutdown(const std::string & reason)
  shutdown_reason_ = reason;
  // call each shutdown callback
  {
-    std::lock_guard<std::recursive_mutex> lock(on_shutdown_callbacks_mutex_);
-    // callbacks may delete other callbacks during the execution,
-    // therefore we need to save a copy and check before execution
-    // if the next callback is still present
-    auto cpy = on_shutdown_callbacks_;
-    for (const auto & callback : cpy) {
-      auto it = std::find(on_shutdown_callbacks_.begin(), on_shutdown_callbacks_.end(), callback);
-      if(it != on_shutdown_callbacks_.end()) {
-        (*callback)();
-      }
+    std::lock_guard<std::mutex> lock(on_shutdown_callbacks_mutex_);
+    for (const auto & callback : on_shutdown_callbacks_) {
+      (*callback)();
    }
  }

@@ -388,14 +355,14 @@ Context::shutdown(const std::string & reason)
 }

 rclcpp::Context::OnShutdownCallback
-Context::on_shutdown(const OnShutdownCallback & callback)
+Context::on_shutdown(OnShutdownCallback callback)
 {
  add_on_shutdown_callback(callback);
  return callback;
 }

 rclcpp::OnShutdownCallbackHandle
-Context::add_on_shutdown_callback(const OnShutdownCallback & callback)
+Context::add_on_shutdown_callback(OnShutdownCallback callback)
 {
  return add_shutdown_callback<ShutdownType::on_shutdown>(callback);
 }
@@ -407,7 +374,7 @@ Context::remove_on_shutdown_callback(const OnShutdownCallbackHandle & callback_h
 }

 rclcpp::PreShutdownCallbackHandle
-Context::add_pre_shutdown_callback(const PreShutdownCallback & callback)
+Context::add_pre_shutdown_callback(PreShutdownCallback callback)
 {
  return add_shutdown_callback<ShutdownType::pre_shutdown>(callback);
 }
@@ -422,7 +389,7 @@ Context::remove_pre_shutdown_callback(
 template<Context::ShutdownType shutdown_type>
 rclcpp::ShutdownCallbackHandle
 Context::add_shutdown_callback(
-  const ShutdownCallback & callback)
+  ShutdownCallback callback)
 {
  auto callback_shared_ptr =
    std::make_shared<ShutdownCallbackHandle::ShutdownCallbackType>(callback);
@@ -431,10 +398,10 @@ Context::add_shutdown_callback(
    shutdown_type == ShutdownType::pre_shutdown || shutdown_type == ShutdownType::on_shutdown);

  if constexpr (shutdown_type == ShutdownType::pre_shutdown) {
-    std::lock_guard<std::recursive_mutex> lock(pre_shutdown_callbacks_mutex_);
+    std::lock_guard<std::mutex> lock(pre_shutdown_callbacks_mutex_);
    pre_shutdown_callbacks_.emplace_back(callback_shared_ptr);
  } else {
-    std::lock_guard<std::recursive_mutex> lock(on_shutdown_callbacks_mutex_);
+    std::lock_guard<std::mutex> lock(on_shutdown_callbacks_mutex_);
    on_shutdown_callbacks_.emplace_back(callback_shared_ptr);
  }

@@ -454,7 +421,7 @@ Context::remove_shutdown_callback(
  }

  const auto remove_callback = [&callback_shared_ptr](auto & mutex, auto & callback_vector) {
-      const std::lock_guard<std::recursive_mutex> lock(mutex);
+      const std::lock_guard<std::mutex> lock(mutex);
      auto iter = callback_vector.begin();
      for (; iter != callback_vector.end(); iter++) {
        if ((*iter).get() == callback_shared_ptr.get()) {
@@ -495,11 +462,10 @@ std::vector<rclcpp::Context::ShutdownCallback>
 Context::get_shutdown_callback() const
 {
  const auto get_callback_vector = [](auto & mutex, auto & callback_set) {
-      const std::lock_guard<std::recursive_mutex> lock(mutex);
+      const std::lock_guard<std::mutex> lock(mutex);
      std::vector<rclcpp::Context::ShutdownCallback> callbacks;
-      callbacks.reserve(callback_set.size());
      for (auto & callback : callback_set) {
-        callbacks.emplace_back(*callback);
+        callbacks.push_back(*callback);
      }
      return callbacks;
    };
@@ -520,12 +486,6 @@ Context::get_rcl_context()
  return rcl_context_;
 }

-std::shared_ptr<rclcpp::graph_listener::GraphListener>
-Context::get_graph_listener()
-{
-  return graph_listener_;
-}
-
 bool
 Context::sleep_for(const std::chrono::nanoseconds & nanoseconds)
 {
--- a/rclcpp/src/rclcpp/create_generic_client.cpp
+++ b/rclcpp/src/rclcpp/create_generic_client.cpp
@@ -19,13 +19,13 @@ namespace rclcpp
 {
 rclcpp::GenericClient::SharedPtr
 create_generic_client(
-  const std::shared_ptr<node_interfaces::NodeBaseInterface> & node_base,
-  const std::shared_ptr<node_interfaces::NodeGraphInterface> & node_graph,
-  const std::shared_ptr<node_interfaces::NodeServicesInterface> & node_services,
+  std::shared_ptr<node_interfaces::NodeBaseInterface> node_base,
+  std::shared_ptr<node_interfaces::NodeGraphInterface> node_graph,
+  std::shared_ptr<node_interfaces::NodeServicesInterface> node_services,
  const std::string & service_name,
  const std::string & service_type,
  const rclcpp::QoS & qos,
-  const rclcpp::CallbackGroup::SharedPtr & group)
+  rclcpp::CallbackGroup::SharedPtr group)
 {
  rcl_client_options_t options = rcl_client_get_default_options();
  options.qos = qos.get_rmw_qos_profile();
--- a/rclcpp/src/rclcpp/detail/rmw_implementation_specific_publisher_payload.cpp
+++ b/rclcpp/src/rclcpp/detail/rmw_implementation_specific_publisher_payload.cpp
@@ -23,9 +23,10 @@ namespace detail

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

 }  // namespace detail
--- a/rclcpp/src/rclcpp/detail/rmw_implementation_specific_subscription_payload.cpp
+++ b/rclcpp/src/rclcpp/detail/rmw_implementation_specific_subscription_payload.cpp
@@ -23,9 +23,10 @@ namespace detail

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

 }  // namespace detail
--- a/Show More
+++ b/Show More