28.1.1

Signed-off-by: Chris Lalancette <clalancette@gmail.com>

.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 -->

.github/workflows/mirror-rolling-to-master.yaml

@@ -0,0 +1,13 @@
+name: Mirror rolling to master
+
+on:
+  push:
+    branches: [ rolling ]
+
+jobs:
+  mirror-to-master:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: zofrex/mirror-branch@v1
+      with:
+        target-branch: master

CODEOWNERS

@@ -0,0 +1,2 @@
+# This file was generated by https://github.com/audrow/update-ros2-repos
+* @ivanpauno @hidmic @wjwwood

rclcpp/CHANGELOG.rst

@@ -2,206 +2,10 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-29.5.4 (2025-10-21)
+28.1.1 (2024-04-24)
 -------------------
-
-29.5.3 (2025-09-11)
--------------------
-* Fix: improve exception context for parameter_value_from (`#2917 <https://github.com/ros2/rclcpp/issues/2917>`_) (`#2919 <https://github.com/ros2/rclcpp/issues/2919>`_)
-* Allow for implicitly convertable loggers as well (`#2922 <https://github.com/ros2/rclcpp/issues/2922>`_) (`#2936 <https://github.com/ros2/rclcpp/issues/2936>`_)
-* Fix `start_type_description_service` param handling (`#2897 <https://github.com/ros2/rclcpp/issues/2897>`_) (`#2908 <https://github.com/ros2/rclcpp/issues/2908>`_)
-* Add qos parameter for wait_for_message function (`#2903 <https://github.com/ros2/rclcpp/issues/2903>`_) (`#2905 <https://github.com/ros2/rclcpp/issues/2905>`_)
-* Expose `typesupport_helpers` API needed for the Rosbag2 (`#2858 <https://github.com/ros2/rclcpp/issues/2858>`_) (`#2901 <https://github.com/ros2/rclcpp/issues/2901>`_)
-* Fujitatomoya/test append parameter override (`#2896 <https://github.com/ros2/rclcpp/issues/2896>`_) (`#2899 <https://github.com/ros2/rclcpp/issues/2899>`_)
-* Add overload of `append_parameter_override` (`#2891 <https://github.com/ros2/rclcpp/issues/2891>`_) (`#2894 <https://github.com/ros2/rclcpp/issues/2894>`_)
-* Contributors: Tim Clephas, mergify[bot]
-
-29.5.2 (2025-07-07)
--------------------
-* Shutdown deadlock fix jazzy (`#2887 <https://github.com/ros2/rclcpp/issues/2887>`_) (`#2888 <https://github.com/ros2/rclcpp/issues/2888>`_)
-* Fix test_publisher_with_system_default_qos (`#2881 <https://github.com/ros2/rclcpp/issues/2881>`_) (`#2884 <https://github.com/ros2/rclcpp/issues/2884>`_)
-* Contributors: Tomoya Fujita, Janosch Machowinski
-
-29.5.1 (2025-06-23)
--------------------
-* Removed warning test_qos (`#2859 <https://github.com/ros2/rclcpp/issues/2859>`_) (`#2873 <https://github.com/ros2/rclcpp/issues/2873>`_)
-* Fix for memory leaks in rclcpp::SerializedMessage (`#2861 <https://github.com/ros2/rclcpp/issues/2861>`_) (`#2863 <https://github.com/ros2/rclcpp/issues/2863>`_)
-* get_all_data_impl() does not handle null pointers properly, causing segmentation fault (backport `#2840 <https://github.com/ros2/rclcpp/issues/2840>`_) (`#2850 <https://github.com/ros2/rclcpp/issues/2850>`_)
-* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_) (`#2855 <https://github.com/ros2/rclcpp/issues/2855>`_)
-* QoSInitialization::from_rmw does not validate invalid history policy values, leading to silent failures (`#2841 <https://github.com/ros2/rclcpp/issues/2841>`_) (`#2846 <https://github.com/ros2/rclcpp/issues/2846>`_)
-* Add missing 's' to 'NodeParametersInterface' in doc/comment (`#2831 <https://github.com/ros2/rclcpp/issues/2831>`_) (`#2833 <https://github.com/ros2/rclcpp/issues/2833>`_)
-* subordinate node consistent behavior and update docstring. (`#2822 <https://github.com/ros2/rclcpp/issues/2822>`_) (`#2830 <https://github.com/ros2/rclcpp/issues/2830>`_)
-* 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, mergify[bot]
-
-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>`_)
-* apply actual QoS from rmw to the IPC publisher. (`#2707 <https://github.com/ros2/rclcpp/issues/2707>`_)
-* Adding in topic name to logging on IPC issues (`#2706 <https://github.com/ros2/rclcpp/issues/2706>`_)
-* fix TestTimeSource.ROS_time_valid_attach_detach. (`#2700 <https://github.com/ros2/rclcpp/issues/2700>`_)
-* Update docstring for `rclcpp::Node::now()` (`#2696 <https://github.com/ros2/rclcpp/issues/2696>`_)
-* Re-enable executor test on rmw_connextdds. (`#2693 <https://github.com/ros2/rclcpp/issues/2693>`_)
-* Fix warnings on Windows. (`#2692 <https://github.com/ros2/rclcpp/issues/2692>`_)
-* Omnibus fixes for running tests with Connext. (`#2684 <https://github.com/ros2/rclcpp/issues/2684>`_)
-* fix(Executor): Fix segfault if callback group is deleted during rmw_wait (`#2683 <https://github.com/ros2/rclcpp/issues/2683>`_)
-* Contributors: Chris Lalancette, Jeffery Hsu, Patrick Roncagliolo, Steve Macenski, Tomoya Fujita, jmachowinski
-
-29.2.0 (2024-11-25)
--------------------
-* accept custom allocator for LoanedMessage. (`#2672 <https://github.com/ros2/rclcpp/issues/2672>`_)
-* Contributors: Tomoya Fujita
-
-29.1.0 (2024-11-20)
--------------------
-* a couple of typo fixes in doc section for LoanedMessage. (`#2676 <https://github.com/ros2/rclcpp/issues/2676>`_)
-* Make sure callback_end tracepoint is triggered in AnyServiceCallback (`#2670 <https://github.com/ros2/rclcpp/issues/2670>`_)
-* Correct the incorrect comments in generic_client.hpp (`#2662 <https://github.com/ros2/rclcpp/issues/2662>`_)
-* Fix NodeOptions assignment operator (`#2656 <https://github.com/ros2/rclcpp/issues/2656>`_)
-* set QoS History KEEP_ALL explicitly for statistics publisher. (`#2650 <https://github.com/ros2/rclcpp/issues/2650>`_)
-* Fix test_intra_process_manager.cpp with rmw_zenoh_cpp (`#2653 <https://github.com/ros2/rclcpp/issues/2653>`_)
-* Fixed test_events_executors in zenoh (`#2643 <https://github.com/ros2/rclcpp/issues/2643>`_)
-* rmw_fastrtps supports service event gid uniqueness test. (`#2638 <https://github.com/ros2/rclcpp/issues/2638>`_)
-* print warning if event callback is not supported instead of passing exception. (`#2648 <https://github.com/ros2/rclcpp/issues/2648>`_)
-* Implement callback support of async_send_request for service generic client (`#2614 <https://github.com/ros2/rclcpp/issues/2614>`_)
-* Contributors: Alejandro Hernández Cordero, Barry Xu, Chris Lalancette, Christophe Bedard, Romain DESILLE, Tomoya Fujita
-
-29.0.0 (2024-10-03)
--------------------
-* Fixed test qos rmw zenoh (`#2639 <https://github.com/ros2/rclcpp/issues/2639>`_)
-* verify client gid uniqueness for a single service event. (`#2636 <https://github.com/ros2/rclcpp/issues/2636>`_)
-* Skip some tests in test_qos_event and run others with event types supported by rmw_zenoh (`#2626 <https://github.com/ros2/rclcpp/issues/2626>`_)
-* Shutdown the context before context's destructor is invoked in tests (`#2633 <https://github.com/ros2/rclcpp/issues/2633>`_)
-* Skip rmw zenoh content filtering tests (`#2627 <https://github.com/ros2/rclcpp/issues/2627>`_)
-* Use InvalidServiceTypeError for unavailable service type in GenericClient (`#2629 <https://github.com/ros2/rclcpp/issues/2629>`_)
-* Implement generic service (`#2617 <https://github.com/ros2/rclcpp/issues/2617>`_)
-* fix events-executor warm-up bug and add unit-tests (`#2591 <https://github.com/ros2/rclcpp/issues/2591>`_)
-* remove unnecessary gtest-skip in test_executors (`#2600 <https://github.com/ros2/rclcpp/issues/2600>`_)
-* Correct node name in service test code (`#2615 <https://github.com/ros2/rclcpp/issues/2615>`_)
-* Minor naming fixes for ParameterValue to_string() function (`#2609 <https://github.com/ros2/rclcpp/issues/2609>`_)
-* Removed clang warnings (`#2605 <https://github.com/ros2/rclcpp/issues/2605>`_)
-* Fix a couple of issues in the documentation. (`#2608 <https://github.com/ros2/rclcpp/issues/2608>`_)
-* deprecate the static single threaded executor (`#2598 <https://github.com/ros2/rclcpp/issues/2598>`_)
-* Fix name of ParameterEventHandler class in doc (`#2604 <https://github.com/ros2/rclcpp/issues/2604>`_)
-* subscriber_statistics_collectors\_ should be protected by mutex. (`#2592 <https://github.com/ros2/rclcpp/issues/2592>`_)
-* Fix bug in timers lifecycle for events executor (`#2586 <https://github.com/ros2/rclcpp/issues/2586>`_)
-* fix rclcpp/test/rclcpp/CMakeLists.txt to check for the correct targets existance (`#2596 <https://github.com/ros2/rclcpp/issues/2596>`_)
-* Shut down context during init if logging config fails (`#2594 <https://github.com/ros2/rclcpp/issues/2594>`_)
-* Make more of the Waitable API abstract (`#2593 <https://github.com/ros2/rclcpp/issues/2593>`_)
-* Contributors: Alberto Soragna, Alejandro Hernández Cordero, Alexis Pojomovsky, Barry Xu, Chris Lalancette, Christophe Bedard, Kang, Hsin-Yi, Tomoya Fujita
-
-28.3.3 (2024-07-29)
--------------------
-* Only compile the tests once. (`#2590 <https://github.com/ros2/rclcpp/issues/2590>`_)
-* Contributors: Chris Lalancette
-
-28.3.2 (2024-07-24)
--------------------
-* Updated rcpputils path API (`#2579 <https://github.com/ros2/rclcpp/issues/2579>`_)
-* Make the subscriber_triggered_to_receive_message test more reliable. (`#2584 <https://github.com/ros2/rclcpp/issues/2584>`_)
-  * Make the subscriber_triggered_to_receive_message test more reliable.
-  In the current code, inside of the timer we create the subscription
-  and the publisher, publish immediately, and expect the subscription
-  to get it immediately.  But it may be the case that discovery
-  hasn't even happened between the publisher and the subscription
-  by the time the publish call happens.
-  To make this more reliable, create the subscription and publish *before*
-  we ever create and spin on the timer.  This at least gives 100
-  milliseconds for discovery to happen.  That may not be quite enough
-  to make this reliable on all platforms, but in my local testing this
-  helps a lot.  Prior to this change I can make this fail one out of 10
-  times, and after the change I've run 100 times with no failures.
-* Have the EventsExecutor use more common code  (`#2570 <https://github.com/ros2/rclcpp/issues/2570>`_)
-  * move notify waitable setup to its own function
-  * move mutex lock to retrieve_entity utility
-  * use entities_need_rebuild\_ atomic bool in events-executors
-  * remove duplicated set_on_ready_callback for notify_waitable
-  * use mutex from base class rather than a new recursive mutex
-  * use current_collection\_ member in events-executor
-  * delay adding notify waitable to collection
-  * postpone clearing the current collection
-  * commonize notify waitable and collection
-  * commonize add/remove node/cbg methods
-  * fix linter errors
-  ---------
-* Removed deprecated methods and classes (`#2575 <https://github.com/ros2/rclcpp/issues/2575>`_)
-* Release ownership of entities after spinning cancelled (`#2556 <https://github.com/ros2/rclcpp/issues/2556>`_)
-  * Release ownership of entities after spinning cancelled
-  * Move release action to every exit point in different spin functions
-  * Move wait_result\_.reset() before setting spinning to false
-  * Update test code
-  * Move test code to test_executors.cpp
-  ---------
-* Split test_executors.cpp even further. (`#2572 <https://github.com/ros2/rclcpp/issues/2572>`_)
-  That's because it is too large for Windows Debug to compile,
-  so split into smaller bits.
-  Even with this split, the file is too big; that's likely
-  because we are using TYPED_TEST here, which generates multiple
-  symbols per test case.  To deal with this, without further
-  breaking up the file, also add in the /bigobj flag when
-  compiling on Windows Debug.
-* avoid adding notify waitable twice to events-executor collection (`#2564 <https://github.com/ros2/rclcpp/issues/2564>`_)
-  * avoid adding notify waitable twice to events-executor entities collection
-  * remove redundant mutex lock
-  ---------
-* Contributors: Alberto Soragna, Alejandro Hernández Cordero, Barry Xu, Chris Lalancette
-
-28.3.1 (2024-06-25)
--------------------
-* Remove unnecessary msg includes in tests (`#2566 <https://github.com/ros2/rclcpp/issues/2566>`_)
-* Fix copy-paste errors in function docs (`#2565 <https://github.com/ros2/rclcpp/issues/2565>`_)
-* Fix typo in function doc (`#2563 <https://github.com/ros2/rclcpp/issues/2563>`_)
-* Contributors: Christophe Bedard
-
-28.3.0 (2024-06-17)
--------------------
-* Add test creating two content filter topics with the same topic name (`#2546 <https://github.com/ros2/rclcpp/issues/2546>`_) (`#2549 <https://github.com/ros2/rclcpp/issues/2549>`_)
-* add impl pointer for ExecutorOptions (`#2523 <https://github.com/ros2/rclcpp/issues/2523>`_)
-* Fixup Executor::spin_all() regression fix (`#2517 <https://github.com/ros2/rclcpp/issues/2517>`_)
-* Add 'mimick' label to tests which use Mimick (`#2516 <https://github.com/ros2/rclcpp/issues/2516>`_)
-* Contributors: Alejandro Hernández Cordero, Scott K Logan, William Woodall
-
-28.2.0 (2024-04-26)
--------------------
-* Check for negative time in rclcpp::Time(int64_t nanoseconds, ...) constructor (`#2510 <https://github.com/ros2/rclcpp/issues/2510>`_)
-* Revise the description of service configure_introspection() (`#2511 <https://github.com/ros2/rclcpp/issues/2511>`_)
-* Contributors: Barry Xu, Sharmin Ramli
+* Revise the description of service configure_introspection() (`#2511 <https://github.com/ros2/rclcpp/issues/2511>`_) (`#2513 <https://github.com/ros2/rclcpp/issues/2513>`_)
+* Contributors: mergify[bot]
 
 28.1.0 (2024-04-16)
 -------------------

rclcpp/CMakeLists.txt

@@ -63,7 +63,6 @@ set(${PROJECT_NAME}_SRCS
   src/rclcpp/exceptions/exceptions.cpp
   src/rclcpp/executable_list.cpp
   src/rclcpp/executor.cpp
-  src/rclcpp/executor_options.cpp
   src/rclcpp/executors.cpp
   src/rclcpp/executors/executor_entities_collection.cpp
   src/rclcpp/executors/executor_entities_collector.cpp
@@ -77,7 +76,6 @@ set(${PROJECT_NAME}_SRCS
   src/rclcpp/future_return_code.cpp
   src/rclcpp/generic_client.cpp
   src/rclcpp/generic_publisher.cpp
-  src/rclcpp/generic_service.cpp
   src/rclcpp/generic_subscription.cpp
   src/rclcpp/graph_listener.cpp
   src/rclcpp/guard_condition.cpp

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.
+

rclcpp/doc/proposed_node_parameter_callbacks.md

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

rclcpp/include/rclcpp/allocator/allocator_deleter.hpp

@@ -69,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>

rclcpp/include/rclcpp/any_service_callback.hpp

@@ -165,13 +165,11 @@ public:
     if (std::holds_alternative<SharedPtrDeferResponseCallback>(callback_)) {
       const auto & cb = std::get<SharedPtrDeferResponseCallback>(callback_);
       cb(request_header, std::move(request));
-      TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
       return nullptr;
     }
     if (std::holds_alternative<SharedPtrDeferResponseCallbackWithServiceHandle>(callback_)) {
       const auto & cb = std::get<SharedPtrDeferResponseCallbackWithServiceHandle>(callback_);
       cb(service_handle, request_header, std::move(request));
-      TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
       return nullptr;
     }
     // auto response = allocate_shared<typename ServiceT::Response, Allocator>();

rclcpp/include/rclcpp/callback_group.hpp

@@ -59,6 +59,46 @@ class CallbackGroup
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(CallbackGroup)
 
+  /// Constructor for CallbackGroup.
+  /**
+   * Callback Groups have a type, either 'Mutually Exclusive' or 'Reentrant'
+   * and when creating one the type must be specified.
+   *
+   * Callbacks in Reentrant Callback Groups must be able to:
+   *   - run at the same time as themselves (reentrant)
+   *   - run at the same time as other callbacks in their group
+   *   - run at the same time as other callbacks in other groups
+   *
+   * Callbacks in Mutually Exclusive Callback Groups:
+   *   - will not be run multiple times simultaneously (non-reentrant)
+   *   - will not be run at the same time as other callbacks in their group
+   *   - but must run at the same time as callbacks in other groups
+   *
+   * Additionally, callback groups have a property which determines whether or
+   * not they are added to an executor with their associated node automatically.
+   * When creating a callback group the automatically_add_to_executor_with_node
+   * argument determines this behavior, and if true it will cause the newly
+   * created callback group to be added to an executor with the node when the
+   * Executor::add_node method is used.
+   * If false, this callback group will not be added automatically and would
+   * have to be added to an executor manually using the
+   * Executor::add_callback_group method.
+   *
+   * Whether the node was added to the executor before creating the callback
+   * group, or after, is irrelevant; the callback group will be automatically
+   * added to the executor in either case.
+   *
+   * \param[in] group_type The type of the callback group.
+   * \param[in] automatically_add_to_executor_with_node A boolean that
+   *   determines whether a callback group is automatically added to an executor
+   *   with the node with which it is associated.
+   */
+  [[deprecated("Use CallbackGroup constructor with context function argument")]]
+  RCLCPP_PUBLIC
+  explicit CallbackGroup(
+    CallbackGroupType group_type,
+    bool automatically_add_to_executor_with_node = true);
+
   /// Constructor for CallbackGroup.
   /**
    * Callback Groups have a type, either 'Mutually Exclusive' or 'Reentrant'

rclcpp/include/rclcpp/client.hpp

@@ -70,6 +70,14 @@ struct FutureAndRequestId
   /// Allow implicit conversions to `std::future` by reference.
   operator FutureT &() {return this->future;}
 
+  /// Deprecated, use the `future` member variable instead.
+  /**
+   * Allow implicit conversions to `std::future` by value.
+   * \deprecated
+   */
+  [[deprecated("FutureAndRequestId: use .future instead of an implicit conversion")]]
+  operator FutureT() {return this->future;}
+
   // delegate future like methods in the std::future impl_
 
   /// See std::future::get().
@@ -428,6 +436,15 @@ public:
   {
     using detail::FutureAndRequestId<std::future<SharedResponse>>::FutureAndRequestId;
 
+    /// Deprecated, use `.future.share()` instead.
+    /**
+     * Allow implicit conversions to `std::shared_future` by value.
+     * \deprecated
+     */
+    [[deprecated(
+      "FutureAndRequestId: use .future.share() instead of an implicit conversion")]]
+    operator SharedFuture() {return this->future.share();}
+
     // delegate future like methods in the std::future impl_
 
     /// See std::future::share().
@@ -473,7 +490,7 @@ public:
    * \param[in] node_base NodeBaseInterface pointer that is used in part of the setup.
    * \param[in] node_graph The node graph interface of the corresponding node.
    * \param[in] service_name Name of the topic to publish to.
-   * \param[in] client_options options for the client.
+   * \param[in] client_options options for the subscription.
    */
   Client(
     rclcpp::node_interfaces::NodeBaseInterface * node_base,
@@ -789,9 +806,6 @@ public:
    * \param[in] clock clock to use to generate introspection timestamps
    * \param[in] qos_service_event_pub QoS settings to use when creating the introspection publisher
    * \param[in] introspection_state the state to set introspection to
-   *
-   * \throws anything rclcpp::exceptions::throw_from_rcl_error can throw if
-   *   it failed to configure introspection.
    */
   void
   configure_introspection(

rclcpp/include/rclcpp/clock.hpp

@@ -60,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.
    */
@@ -201,16 +194,11 @@ public:
   ros_time_is_active();
 
   /**
-   * Deprecated. This API is broken, as there is no way to get a deep
-   * copy of a clock. Therefore one can experience spurious wakeups triggered
-   * by some other instance of a clock.
-   *
    * 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.
    */
-  [[deprecated("Use ClockConditionalVariable")]]
   RCLCPP_PUBLIC
   void
   cancel_sleep_or_wait();
@@ -229,13 +217,13 @@ public:
   std::mutex &
   get_clock_mutex() noexcept;
 
-  /// Add a callback to invoke if the jump threshold is exceeded.
+  // Add a callback to invoke if the jump threshold is exceeded.
   /**
    * These callback functions must remain valid as long as the
    * returned shared pointer is valid.
    *
    * Function will register callbacks to the callback queue. On time jump all
-   * callbacks will be executed whose threshold is greater than the time jump;
+   * callbacks will be executed whose threshold is greater then the time jump;
    * The logic will first call selected pre_callbacks and then all selected
    * post_callbacks.
    *
@@ -244,7 +232,7 @@ public:
    * \param pre_callback Must be non-throwing
    * \param post_callback Must be non-throwing.
    * \param threshold Callbacks will be triggered if the time jump is greater
-   * than the threshold.
+   * then the threshold.
    * \throws anything rclcpp::exceptions::throw_from_rcl_error can throw.
    * \throws std::bad_alloc if the allocation of the JumpHandler fails.
    * \warning the instance of the clock must remain valid as long as any created
@@ -272,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,
-    rclcpp::Context::SharedPtr context = rclcpp::contexts::get_global_default_context());
-  RCLCPP_PUBLIC
-  ~ClockConditionalVariable();
-
-  /**
-   * Calling this function will block the current thread, until abs_time is reached,
-   * or pred returns true.
-   * @param lock A locked lock. The lock must be locked at call time, or this method will throw.
-   *             The lock will be atomically released and this thread will blocked.
-   *             The given lock must be created using the mutex returned my mutex().
-   * @param abs_time The time until which this thread shall be blocked.
-   * @param pred may be called in cased of spurious wakeups, but must be called every time
-   *             notify_one() was called. During the call to pred, the given lock will be locked.
-   *             This method will return, if pred returns true.
-   *
-   * @return true if until was reached.
-   */
-  RCLCPP_PUBLIC
-  bool
-  wait_until(
-    std::unique_lock<std::mutex> & lock, rclcpp::Time until,
-    const std::function<bool ()> & pred);
-
-  /**
-   * Notify the blocked thread, that is should reevaluate the wakeup condition.
-   * E.g. the given pred function in wait_until shall be reevaluated.
-   */
-  RCLCPP_PUBLIC
-  void
-  notify_one();
-
-  /**
-   * Returns the internal mutex. In order to be race free with the context shutdown,
-   * this mutex must be used for the wait_until call.
-   */
-  RCLCPP_PUBLIC
-  std::mutex &
-  mutex();
-};
-
-
 }  // namespace rclcpp
 
 #endif  // RCLCPP__CLOCK_HPP_

rclcpp/include/rclcpp/create_client.hpp

@@ -47,9 +47,28 @@ create_client(
   const std::string & service_name,
   const rclcpp::QoS & qos = rclcpp::ServicesQoS(),
   rclcpp::CallbackGroup::SharedPtr group = nullptr)
+{
+  return create_client<ServiceT>(
+    node_base, node_graph, node_services,
+    service_name,
+    qos.get_rmw_qos_profile(),
+    group);
+}
+
+/// Create a service client with a given type.
+/// \internal
+template<typename ServiceT>
+typename rclcpp::Client<ServiceT>::SharedPtr
+create_client(
+  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 rmw_qos_profile_t & qos_profile,
+  rclcpp::CallbackGroup::SharedPtr group)
 {
   rcl_client_options_t options = rcl_client_get_default_options();
-  options.qos = qos.get_rmw_qos_profile();
+  options.qos = qos_profile;
 
   auto cli = rclcpp::Client<ServiceT>::make_shared(
     node_base.get(),
@@ -61,6 +80,7 @@ create_client(
   node_services->add_client(cli_base_ptr, group);
   return cli;
 }
+
 }  // namespace rclcpp
 
 #endif  // RCLCPP__CREATE_CLIENT_HPP_

rclcpp/include/rclcpp/create_generic_service.hpp

@@ -1,102 +0,0 @@
-// Copyright 2024 Sony Group Corporation.
-//
-// 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__CREATE_GENERIC_SERVICE_HPP_
-#define RCLCPP__CREATE_GENERIC_SERVICE_HPP_
-
-#include <memory>
-#include <string>
-#include <utility>
-
-#include "rclcpp/generic_service.hpp"
-#include "rclcpp/node_interfaces/get_node_base_interface.hpp"
-#include "rclcpp/node_interfaces/node_base_interface.hpp"
-#include "rclcpp/node_interfaces/get_node_services_interface.hpp"
-#include "rclcpp/node_interfaces/node_services_interface.hpp"
-#include "rclcpp/visibility_control.hpp"
-#include "rmw/rmw.h"
-
-namespace rclcpp
-{
-/// Create a generic service with a given type.
-/**
- * \param[in] node_base NodeBaseInterface implementation of the node on which
- *  to create the generic service.
- * \param[in] node_services NodeServicesInterface implementation of the node on
- *  which to create the service.
- * \param[in] service_name The name on which the service is accessible.
- * \param[in] service_type The name of service type, e.g. "std_srvs/srv/SetBool".
- * \param[in] callback The callback to call when the service gets a request.
- * \param[in] qos Quality of service profile for the service.
- * \param[in] group Callback group to handle the reply to service calls.
- * \return Shared pointer to the created service.
- */
-template<typename CallbackT>
-typename rclcpp::GenericService::SharedPtr
-create_generic_service(
-  std::shared_ptr<node_interfaces::NodeBaseInterface> node_base,
-  std::shared_ptr<node_interfaces::NodeServicesInterface> node_services,
-  const std::string & service_name,
-  const std::string & service_type,
-  CallbackT && callback,
-  const rclcpp::QoS & qos,
-  rclcpp::CallbackGroup::SharedPtr group)
-{
-  rclcpp::GenericServiceCallback any_service_callback;
-  any_service_callback.set(std::forward<CallbackT>(callback));
-
-  rcl_service_options_t service_options = rcl_service_get_default_options();
-  service_options.qos = qos.get_rmw_qos_profile();
-
-  auto serv = GenericService::make_shared(
-    node_base->get_shared_rcl_node_handle(),
-    service_name, service_type, any_service_callback, service_options);
-  auto serv_base_ptr = std::dynamic_pointer_cast<ServiceBase>(serv);
-  node_services->add_service(serv_base_ptr, group);
-  return serv;
-}
-
-/// Create a generic service with a given type.
-/**
- * The NodeT type needs to have NodeBaseInterface implementation and NodeServicesInterface
- * implementation of the node which to create the generic service.
- *
- * \param[in] node The node on which to create the generic service.
- * \param[in] service_name The name on which the service is accessible.
- * \param[in] service_type The name of service type, e.g. "std_srvs/srv/SetBool".
- * \param[in] callback The callback to call when the service gets a request.
- * \param[in] qos Quality of service profile for the service.
- * \param[in] group Callback group to handle the reply to service calls.
- * \return Shared pointer to the created service.
- */
-template<typename NodeT, typename CallbackT>
-typename rclcpp::GenericService::SharedPtr
-create_generic_service(
-  NodeT node,
-  const std::string & service_name,
-  const std::string & service_type,
-  CallbackT && callback,
-  const rclcpp::QoS & qos,
-  rclcpp::CallbackGroup::SharedPtr group)
-{
-  return create_generic_service<CallbackT>(
-    rclcpp::node_interfaces::get_node_base_interface(node),
-    rclcpp::node_interfaces::get_node_services_interface(node),
-    service_name,
-    service_type,
-    std::forward<CallbackT>(callback), qos.get_rmw_qos_profile(), group);
-}
-}  // namespace rclcpp
-
-#endif  // RCLCPP__CREATE_GENERIC_SERVICE_HPP_

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 &) {

rclcpp/include/rclcpp/event_handler.hpp

@@ -20,7 +20,6 @@
 #include <mutex>
 #include <stdexcept>
 #include <string>
-#include <vector>
 
 #include "rcl/error_handling.h"
 #include "rcl/event_callback.h"
@@ -222,13 +221,6 @@ public:
     }
   }
 
-  RCLCPP_PUBLIC
-  std::vector<std::shared_ptr<rclcpp::TimerBase>>
-  get_timers() const override
-  {
-    return {};
-  }
-
 protected:
   RCLCPP_PUBLIC
   void
@@ -241,6 +233,8 @@ protected:
   size_t wait_set_event_index_;
 };
 
+using QOSEventHandlerBase [[deprecated("Use rclcpp::EventHandlerBase")]] = EventHandlerBase;
+
 template<typename EventCallbackT, typename ParentHandleT>
 class EventHandler : public EventHandlerBase
 {
@@ -286,15 +280,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();
   }
 
@@ -317,6 +311,11 @@ private:
   ParentHandleT parent_handle_;
   EventCallbackT event_callback_;
 };
+
+template<typename EventCallbackT, typename ParentHandleT>
+using QOSEventHandler [[deprecated("Use rclcpp::EventHandler")]] = EventHandler<EventCallbackT,
+    ParentHandleT>;
+
 }  // namespace rclcpp
 
 #endif  // RCLCPP__EVENT_HANDLER_HPP_

rclcpp/include/rclcpp/exceptions/exceptions.hpp

@@ -100,15 +100,6 @@ public:
   {}
 };
 
-class InvalidServiceTypeError : public std::runtime_error
-{
-public:
-  InvalidServiceTypeError()
-  : std::runtime_error("Service type is invalid.") {}
-  explicit InvalidServiceTypeError(const std::string & msg)
-  : std::runtime_error(msg) {}
-};
-
 class UnimplementedError : public std::runtime_error
 {
 public:

rclcpp/include/rclcpp/executor.hpp

@@ -287,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
@@ -553,9 +541,8 @@ protected:
    *
    * \param[in] notify if true will execute a trigger that will wake up a waiting executor
    */
-  RCLCPP_PUBLIC
-  virtual void
-  handle_updated_entities(bool notify);
+  void
+  trigger_entity_recollect(bool notify);
 
   /// Spinning state, used to prevent multi threaded calls to spin and to cancel blocking spins.
   std::atomic_bool spinning;

rclcpp/include/rclcpp/executor_options.hpp

@@ -15,8 +15,6 @@
 #ifndef RCLCPP__EXECUTOR_OPTIONS_HPP_
 #define RCLCPP__EXECUTOR_OPTIONS_HPP_
 
-#include <memory>
-
 #include "rclcpp/context.hpp"
 #include "rclcpp/contexts/default_context.hpp"
 #include "rclcpp/memory_strategies.hpp"
@@ -26,30 +24,18 @@
 namespace rclcpp
 {
 
-class ExecutorOptionsImplementation;
-
 /// Options to be passed to the executor constructor.
 struct ExecutorOptions
 {
-  RCLCPP_PUBLIC
-  ExecutorOptions();
-
-  RCLCPP_PUBLIC
-  virtual ~ExecutorOptions();
-
-  RCLCPP_PUBLIC
-  ExecutorOptions(const ExecutorOptions &);
-
-  RCLCPP_PUBLIC
-  ExecutorOptions & operator=(const ExecutorOptions &);
+  ExecutorOptions()
+  : memory_strategy(rclcpp::memory_strategies::create_default_strategy()),
+    context(rclcpp::contexts::get_global_default_context()),
+    max_conditions(0)
+  {}
 
   rclcpp::memory_strategy::MemoryStrategy::SharedPtr memory_strategy;
   rclcpp::Context::SharedPtr context;
   size_t max_conditions;
-
-private:
-  /// Pointer to implementation
-  std::unique_ptr<ExecutorOptionsImplementation> impl_;
 };
 
 }  // namespace rclcpp

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,9 +41,7 @@ public:
    *   of this waitable has signaled the wait_set.
    */
   RCLCPP_PUBLIC
-  explicit ExecutorNotifyWaitable(
-    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
@@ -125,14 +122,6 @@ public:
   void
   clear_on_ready_callback() override;
 
-  /// Set a new callback to be called whenever this waitable is executed.
-  /**
-   * \param[in] on_execute_callback The new callback
-   */
-  RCLCPP_PUBLIC
-  void
-  set_execute_callback(std::function<void(void)> on_execute_callback);
-
   /// Remove a guard condition from being waited on.
   /**
    * \param[in] weak_guard_condition The guard condition to remove.
@@ -149,37 +138,17 @@ 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_;
 
-  /// Mutex to procetect the guard conditions
   std::mutex guard_condition_mutex_;
-  /// Mutex to protect the execute callback
-  std::mutex execute_mutex_;
 
   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

rclcpp/include/rclcpp/executors/static_single_threaded_executor.hpp

@@ -31,15 +31,9 @@ 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.
+ * It's static because it doesn't reconstruct 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;
@@ -50,8 +44,7 @@ namespace executors
  * exec.spin();
  * exec.remove_node(node);
  */
-class [[deprecated("Use rclcpp::executors::SingleThreadedExecutor")]] StaticSingleThreadedExecutor
-  : public rclcpp::Executor
+class StaticSingleThreadedExecutor : public rclcpp::Executor
 {
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(StaticSingleThreadedExecutor)

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

@@ -255,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;
   }

rclcpp/include/rclcpp/experimental/executors/events_executor/events_executor.hpp

@@ -59,6 +59,8 @@ namespace executors
  */
 class EventsExecutor : public rclcpp::Executor
 {
+  friend class EventsExecutorEntitiesCollector;
+
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(EventsExecutor)
 
@@ -70,7 +72,7 @@ public:
    * \param[in] options Options used to configure the executor.
    */
   RCLCPP_PUBLIC
-  EventsExecutor(
+  explicit EventsExecutor(
     rclcpp::experimental::executors::EventsQueue::UniquePtr events_queue = std::make_unique<
       rclcpp::experimental::executors::SimpleEventsQueue>(),
     bool execute_timers_separate_thread = false,
@@ -126,6 +128,87 @@ public:
   void
   spin_all(std::chrono::nanoseconds max_duration) override;
 
+  /// Add a node to the executor.
+  /**
+   * \sa rclcpp::Executor::add_node
+   */
+  RCLCPP_PUBLIC
+  void
+  add_node(
+    rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
+    bool notify = true) override;
+
+  /// Convenience function which takes Node and forwards NodeBaseInterface.
+  /**
+   * \sa rclcpp::EventsExecutor::add_node
+   */
+  RCLCPP_PUBLIC
+  void
+  add_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify = true) override;
+
+  /// Remove a node from the executor.
+  /**
+   * \sa rclcpp::Executor::remove_node
+   */
+  RCLCPP_PUBLIC
+  void
+  remove_node(
+    rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
+    bool notify = true) override;
+
+  /// Convenience function which takes Node and forwards NodeBaseInterface.
+  /**
+   * \sa rclcpp::Executor::remove_node
+   */
+  RCLCPP_PUBLIC
+  void
+  remove_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify = true) override;
+
+  /// Add a callback group to an executor.
+  /**
+   * \sa rclcpp::Executor::add_callback_group
+   */
+  RCLCPP_PUBLIC
+  void
+  add_callback_group(
+    rclcpp::CallbackGroup::SharedPtr group_ptr,
+    rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
+    bool notify = true) override;
+
+  /// Remove callback group from the executor
+  /**
+   * \sa rclcpp::Executor::remove_callback_group
+   */
+  RCLCPP_PUBLIC
+  void
+  remove_callback_group(
+    rclcpp::CallbackGroup::SharedPtr group_ptr,
+    bool notify = true) override;
+
+  /// Get callback groups that belong to executor.
+  /**
+   * \sa rclcpp::Executor::get_all_callback_groups()
+   */
+  RCLCPP_PUBLIC
+  std::vector<rclcpp::CallbackGroup::WeakPtr>
+  get_all_callback_groups() override;
+
+  /// Get callback groups that belong to executor.
+  /**
+   * \sa rclcpp::Executor::get_manually_added_callback_groups()
+   */
+  RCLCPP_PUBLIC
+  std::vector<rclcpp::CallbackGroup::WeakPtr>
+  get_manually_added_callback_groups() override;
+
+  /// Get callback groups that belong to executor.
+  /**
+   * \sa rclcpp::Executor::get_automatically_added_callback_groups_from_nodes()
+   */
+  RCLCPP_PUBLIC
+  std::vector<rclcpp::CallbackGroup::WeakPtr>
+  get_automatically_added_callback_groups_from_nodes() override;
+
 protected:
   /// Internal implementation of spin_once
   RCLCPP_PUBLIC
@@ -137,11 +220,6 @@ protected:
   void
   spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive);
 
-  /// Collect entities from callback groups and refresh the current collection with them
-  RCLCPP_PUBLIC
-  void
-  handle_updated_entities(bool notify) override;
-
 private:
   RCLCPP_DISABLE_COPY(EventsExecutor)
 
@@ -149,9 +227,9 @@ private:
   void
   execute_event(const ExecutorEvent & event);
 
-  /// Rebuilds the executor's notify waitable, as we can't use the one built in the base class
+  /// Collect entities from callback groups and refresh the current collection with them
   void
-  setup_notify_waitable();
+  refresh_current_collection_from_callback_groups();
 
   /// Refresh the current collection using the provided new_collection
   void
@@ -175,11 +253,6 @@ private:
   typename CollectionType::EntitySharedPtr
   retrieve_entity(typename CollectionType::Key entity_id, CollectionType & collection)
   {
-    // Note: we lock the mutex because we assume that you are trying to get an element from the
-    // current collection... If there will be a use-case to retrieve elements also from other
-    // collections, we can move the mutex back to the calling codes.
-    std::lock_guard<std::mutex> guard(mutex_);
-
     // Check if the entity_id is in the collection
     auto it = collection.find(entity_id);
     if (it == collection.end()) {
@@ -200,6 +273,16 @@ private:
   /// Queue where entities can push events
   rclcpp::experimental::executors::EventsQueue::UniquePtr events_queue_;
 
+  std::shared_ptr<rclcpp::executors::ExecutorEntitiesCollector> entities_collector_;
+  std::shared_ptr<rclcpp::executors::ExecutorNotifyWaitable> notify_waitable_;
+
+  /// Mutex to protect the current_entities_collection_
+  std::recursive_mutex collection_mutex_;
+  std::shared_ptr<rclcpp::executors::ExecutorEntitiesCollection> current_entities_collection_;
+
+  /// Flag used to reduce the number of unnecessary waitable events
+  std::atomic<bool> notify_waitable_event_pushed_ {false};
+
   /// Timers manager used to track and/or execute associated timers
   std::shared_ptr<rclcpp::experimental::TimersManager> timers_manager_;
 };

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,8 +78,9 @@ 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();
   }
 
@@ -180,13 +180,6 @@ public:
     on_new_message_callback_ = nullptr;
   }
 
-  RCLCPP_PUBLIC
-  std::vector<std::shared_ptr<rclcpp::TimerBase>>
-  get_timers() const override
-  {
-    return {};
-  }
-
 protected:
   std::recursive_mutex callback_mutex_;
   std::function<void(size_t)> on_new_message_callback_ {nullptr};

rclcpp/include/rclcpp/experimental/subscription_intra_process_buffer.hpp

@@ -110,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();
   }
 

rclcpp/include/rclcpp/generic_client.hpp

@@ -19,7 +19,6 @@
 #include <memory>
 #include <future>
 #include <string>
-#include <tuple>
 #include <vector>
 #include <utility>
 
@@ -36,8 +35,8 @@ namespace rclcpp
 class GenericClient : public ClientBase
 {
 public:
-  using Request = void *;   // Deserialized data pointer of request message
-  using Response = void *;  // Deserialized data pointer of response message
+  using Request = void *;   // Serialized data pointer of request message
+  using Response = void *;  // Serialized data pointer of response message
 
   using SharedResponse = std::shared_ptr<void>;
 
@@ -47,8 +46,6 @@ public:
   using Future = std::future<SharedResponse>;
   using SharedFuture = std::shared_future<SharedResponse>;
 
-  using CallbackType = std::function<void (SharedFuture)>;
-
   RCLCPP_SMART_PTR_DEFINITIONS(GenericClient)
 
   /// A convenient GenericClient::Future and request id pair.
@@ -79,20 +76,6 @@ public:
     ~FutureAndRequestId() = default;
   };
 
-  /// A convenient GenericClient::SharedFuture and request id pair.
-  /**
-   * Public members:
-   * - future: a std::shared_future<SharedResponse>.
-   * - request_id: the request id associated with the future.
-   *
-   * All the other methods are equivalent to the ones std::shared_future provides.
-   */
-  struct SharedFutureAndRequestId
-    : detail::FutureAndRequestId<std::shared_future<SharedResponse>>
-  {
-    using detail::FutureAndRequestId<std::shared_future<SharedResponse>>::FutureAndRequestId;
-  };
-
   GenericClient(
     rclcpp::node_interfaces::NodeBaseInterface * node_base,
     rclcpp::node_interfaces::NodeGraphInterface::SharedPtr node_graph,
@@ -123,16 +106,16 @@ public:
    * If the future never completes,
    * e.g. the call to Executor::spin_until_future_complete() times out,
    * GenericClient::remove_pending_request() must be called to clean the client internal state.
-   * Not doing so will make the `GenericClient` instance to use more memory each time a response is
-   * not received from the service server.
+   * Not doing so will make the `Client` instance to use more memory each time a response is not
+   * received from the service server.
    *
    * ```cpp
-   * auto future = generic_client->async_send_request(my_request);
+   * auto future = client->async_send_request(my_request);
    * if (
    *   rclcpp::FutureReturnCode::TIMEOUT ==
    *   executor->spin_until_future_complete(future, timeout))
    * {
-   *   generic_client->remove_pending_request(future);
+   *   client->remove_pending_request(future);
    *   // handle timeout
    * } else {
    *   handle_response(future.get());
@@ -146,45 +129,6 @@ public:
   FutureAndRequestId
   async_send_request(const Request request);
 
-  /// Send a request to the service server and schedule a callback in the executor.
-  /**
-   * Similar to the previous overload, but a callback will automatically be called when a response
-   * is received.
-   *
-   * If the callback is never called, because we never got a reply for the service server,
-   * remove_pending_request() has to be called with the returned request id or
-   * prune_pending_requests().
-   * Not doing so will make the `GenericClient` instance use more memory each time a response is not
-   * received from the service server.
-   * In this case, it's convenient to setup a timer to cleanup the pending requests.
-   *
-   * \param[in] request request to be send.
-   * \param[in] cb callback that will be called when we get a response for this request.
-   * \return the request id representing the request just sent.
-   */
-  template<
-    typename CallbackT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        CallbackType
-      >::value
-    >::type * = nullptr
-  >
-  SharedFutureAndRequestId
-  async_send_request(const Request request, CallbackT && cb)
-  {
-    Promise promise;
-    auto shared_future = promise.get_future().share();
-    auto req_id = async_send_request_impl(
-      request,
-      std::make_tuple(
-        CallbackType{std::forward<CallbackT>(cb)},
-        shared_future,
-        std::move(promise)));
-    return SharedFutureAndRequestId{std::move(shared_future), req_id};
-  }
-
   /// Clean all pending requests older than a time_point.
   /**
    * \param[in] time_point Requests that were sent before this point are going to be removed.
@@ -205,52 +149,15 @@ public:
       pruned_requests);
   }
 
-  /// Clean all pending requests.
-  /**
-   * \return number of pending requests that were removed.
-   */
   RCLCPP_PUBLIC
   size_t
   prune_pending_requests();
 
-  /// Cleanup a pending request.
-  /**
-   * This notifies the client that we have waited long enough for a response from the server
-   * to come, we have given up and we are not waiting for a response anymore.
-   *
-   * Not calling this will make the client start using more memory for each request
-   * that never got a reply from the server.
-   *
-   * \param[in] request_id request id returned by async_send_request().
-   * \return true when a pending request was removed, false if not (e.g. a response was received).
-   */
   RCLCPP_PUBLIC
   bool
   remove_pending_request(
     int64_t request_id);
 
-  /// Cleanup a pending request.
-  /**
-   * Convenient overload, same as:
-   *
-   * `GenericClient::remove_pending_request(this, future.request_id)`.
-   */
-  RCLCPP_PUBLIC
-  bool
-  remove_pending_request(
-    const FutureAndRequestId & future);
-
-  /// Cleanup a pending request.
-  /**
-   * Convenient overload, same as:
-   *
-   * `GenericClient::remove_pending_request(this, future.request_id)`.
-   */
-  RCLCPP_PUBLIC
-  bool
-  remove_pending_request(
-    const SharedFutureAndRequestId & future);
-
   /// Take the next response for this client.
   /**
    * \sa ClientBase::take_type_erased_response().
@@ -272,12 +179,9 @@ public:
   }
 
 protected:
-  using CallbackTypeValueVariant = std::tuple<CallbackType, SharedFuture, Promise>;
   using CallbackInfoVariant = std::variant<
-    std::promise<SharedResponse>,
-    CallbackTypeValueVariant>;  // Use variant for extension
+    std::promise<SharedResponse>>;  // Use variant for extension
 
-  RCLCPP_PUBLIC
   int64_t
   async_send_request_impl(
     const Request request,

rclcpp/include/rclcpp/generic_service.hpp

@@ -1,308 +0,0 @@
-// Copyright 2024 Sony Group Corporation.
-//
-// 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__GENERIC_SERVICE_HPP_
-#define RCLCPP__GENERIC_SERVICE_HPP_
-
-#include <cstdlib>
-#include <functional>
-#include <memory>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <variant>
-
-#include "rclcpp/typesupport_helpers.hpp"
-
-#include "rosidl_runtime_c/service_type_support_struct.h"
-#include "rosidl_typesupport_introspection_cpp/identifier.hpp"
-#include "rosidl_typesupport_introspection_cpp/service_introspection.hpp"
-
-#include "service.hpp"
-
-namespace rclcpp
-{
-class GenericService;
-
-class GenericServiceCallback
-{
-public:
-  using SharedRequest = std::shared_ptr<void>;
-  using SharedResponse = std::shared_ptr<void>;
-
-  GenericServiceCallback()
-  : callback_(std::monostate{})
-  {}
-
-  template<
-    typename CallbackT,
-    typename std::enable_if_t<!detail::can_be_nullptr<CallbackT>::value, int> = 0>
-  void
-  set(CallbackT && callback)
-  {
-    // Workaround Windows issue with std::bind
-    if constexpr (
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        SharedPtrCallback
-      >::value)
-    {
-      callback_.template emplace<SharedPtrCallback>(callback);
-    } else if constexpr (  // NOLINT, can't satisfy both cpplint and uncrustify
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        SharedPtrWithRequestHeaderCallback
-      >::value)
-    {
-      callback_.template emplace<SharedPtrWithRequestHeaderCallback>(callback);
-    } else if constexpr (  // NOLINT
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        SharedPtrDeferResponseCallback
-      >::value)
-    {
-      callback_.template emplace<SharedPtrDeferResponseCallback>(callback);
-    } else if constexpr (  // NOLINT
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        SharedPtrDeferResponseCallbackWithServiceHandle
-      >::value)
-    {
-      callback_.template emplace<SharedPtrDeferResponseCallbackWithServiceHandle>(callback);
-    } else {
-      // the else clause is not needed, but anyways we should only be doing this instead
-      // of all the above workaround ...
-      callback_ = std::forward<CallbackT>(callback);
-    }
-  }
-
-  template<
-    typename CallbackT,
-    typename std::enable_if_t<detail::can_be_nullptr<CallbackT>::value, int> = 0>
-  void
-  set(CallbackT && callback)
-  {
-    if (!callback) {
-      throw std::invalid_argument("AnyServiceCallback::set(): callback cannot be nullptr");
-    }
-    // Workaround Windows issue with std::bind
-    if constexpr (
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        SharedPtrCallback
-      >::value)
-    {
-      callback_.template emplace<SharedPtrCallback>(callback);
-    } else if constexpr (  // NOLINT
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        SharedPtrWithRequestHeaderCallback
-      >::value)
-    {
-      callback_.template emplace<SharedPtrWithRequestHeaderCallback>(callback);
-    } else if constexpr (  // NOLINT
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        SharedPtrDeferResponseCallback
-      >::value)
-    {
-      callback_.template emplace<SharedPtrDeferResponseCallback>(callback);
-    } else if constexpr (  // NOLINT
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        SharedPtrDeferResponseCallbackWithServiceHandle
-      >::value)
-    {
-      callback_.template emplace<SharedPtrDeferResponseCallbackWithServiceHandle>(callback);
-    } else {
-      // the else clause is not needed, but anyways we should only be doing this instead
-      // of all the above workaround ...
-      callback_ = std::forward<CallbackT>(callback);
-    }
-  }
-
-  SharedResponse
-  dispatch(
-    const std::shared_ptr<rclcpp::GenericService> & service_handle,
-    const std::shared_ptr<rmw_request_id_t> & request_header,
-    SharedRequest request,
-    SharedRequest response)
-  {
-    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), false);
-    if (std::holds_alternative<std::monostate>(callback_)) {
-      // TODO(ivanpauno): Remove the set method, and force the users of this class
-      // to pass a callback at construnciton.
-      throw std::runtime_error{"unexpected request without any callback set"};
-    }
-    if (std::holds_alternative<SharedPtrDeferResponseCallback>(callback_)) {
-      const auto & cb = std::get<SharedPtrDeferResponseCallback>(callback_);
-      cb(request_header, std::move(request));
-      return nullptr;
-    }
-    if (std::holds_alternative<SharedPtrDeferResponseCallbackWithServiceHandle>(callback_)) {
-      const auto & cb = std::get<SharedPtrDeferResponseCallbackWithServiceHandle>(callback_);
-      cb(service_handle, request_header, std::move(request));
-      return nullptr;
-    }
-
-    if (std::holds_alternative<SharedPtrCallback>(callback_)) {
-      (void)request_header;
-      const auto & cb = std::get<SharedPtrCallback>(callback_);
-      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), std::move(response));
-    }
-    TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
-    return response;
-  }
-
-  void register_callback_for_tracing()
-  {
-#ifndef TRACETOOLS_DISABLED
-    std::visit(
-      [this](auto && arg) {
-        if (TRACETOOLS_TRACEPOINT_ENABLED(rclcpp_callback_register)) {
-          char * symbol = tracetools::get_symbol(arg);
-          TRACETOOLS_DO_TRACEPOINT(
-            rclcpp_callback_register,
-            static_cast<const void *>(this),
-            symbol);
-          std::free(symbol);
-        }
-      }, callback_);
-#endif  // TRACETOOLS_DISABLED
-  }
-
-private:
-  using SharedPtrCallback = std::function<void (SharedRequest, SharedResponse)>;
-  using SharedPtrWithRequestHeaderCallback = std::function<
-    void (
-      std::shared_ptr<rmw_request_id_t>,
-      SharedRequest,
-      SharedResponse
-    )>;
-  using SharedPtrDeferResponseCallback = std::function<
-    void (
-      std::shared_ptr<rmw_request_id_t>,
-      SharedRequest
-    )>;
-  using SharedPtrDeferResponseCallbackWithServiceHandle = std::function<
-    void (
-      std::shared_ptr<rclcpp::GenericService>,
-      std::shared_ptr<rmw_request_id_t>,
-      SharedRequest
-    )>;
-
-  std::variant<
-    std::monostate,
-    SharedPtrCallback,
-    SharedPtrWithRequestHeaderCallback,
-    SharedPtrDeferResponseCallback,
-    SharedPtrDeferResponseCallbackWithServiceHandle> callback_;
-};
-
-class GenericService
-  : public ServiceBase,
-  public std::enable_shared_from_this<GenericService>
-{
-public:
-  using Request = void *;  // Serialized/Deserialized data pointer of request message
-  using Response = void *;  // Serialized/Deserialized data pointer of response message
-  using SharedRequest = std::shared_ptr<void>;
-  using SharedResponse = std::shared_ptr<void>;
-  using CallbackType = std::function<void (const SharedRequest, SharedResponse)>;
-
-  using CallbackWithHeaderType =
-    std::function<void (const std::shared_ptr<rmw_request_id_t>,
-      const SharedRequest,
-      SharedResponse)>;
-
-  RCLCPP_SMART_PTR_DEFINITIONS(GenericService)
-
-  /// Default constructor.
-  /**
-   * The constructor for a Service is almost never called directly.
-   * Instead, services should be instantiated through the function
-   * rclcpp::create_service().
-   *
-   * \param[in] node_handle NodeBaseInterface pointer that is used in part of the setup.
-   * \param[in] service_name Name of the topic to publish to.
-   * \param[in] service_type The name of service type, e.g. "std_srvs/srv/SetBool".
-   * \param[in] any_callback User defined callback to call when a client request is received.
-   * \param[in] service_options options for the service.
-   */
-  RCLCPP_PUBLIC
-  GenericService(
-    std::shared_ptr<rcl_node_t> node_handle,
-    const std::string & service_name,
-    const std::string & service_type,
-    GenericServiceCallback any_callback,
-    rcl_service_options_t & service_options);
-
-  GenericService() = delete;
-
-  RCLCPP_PUBLIC
-  virtual ~GenericService() {}
-
-  /// Take the next request from the service.
-  /**
-   * \sa ServiceBase::take_type_erased_request().
-   *
-   * \param[out] request_out The reference to a service deserialized request object
-   *   into which the middleware will copy the taken request.
-   * \param[out] request_id_out The output id for the request which can be used
-   *   to associate response with this request in the future.
-   * \returns true if the request was taken, otherwise false.
-   * \throws rclcpp::exceptions::RCLError based exceptions if the underlying
-   *   rcl calls fail.
-   */
-  RCLCPP_PUBLIC
-  bool
-  take_request(SharedRequest request_out, rmw_request_id_t & request_id_out);
-
-  RCLCPP_PUBLIC
-  std::shared_ptr<void>
-  create_request() override;
-
-  RCLCPP_PUBLIC
-  std::shared_ptr<void>
-  create_response();
-
-  RCLCPP_PUBLIC
-  std::shared_ptr<rmw_request_id_t>
-  create_request_header() override;
-
-  RCLCPP_PUBLIC
-  void
-  handle_request(
-    std::shared_ptr<rmw_request_id_t> request_header,
-    std::shared_ptr<void> request) override;
-
-  RCLCPP_PUBLIC
-  void
-  send_response(rmw_request_id_t & req_id, SharedResponse & response);
-
-private:
-  RCLCPP_DISABLE_COPY(GenericService)
-
-  GenericServiceCallback any_callback_;
-
-  std::shared_ptr<rcpputils::SharedLibrary> ts_lib_;
-  const rosidl_typesupport_introspection_cpp::MessageMembers * request_members_;
-  const rosidl_typesupport_introspection_cpp::MessageMembers * response_members_;
-};
-
-}  // namespace rclcpp
-#endif  // RCLCPP__GENERIC_SERVICE_HPP_

rclcpp/include/rclcpp/loaned_message.hpp

@@ -31,20 +31,21 @@ namespace rclcpp
 template<typename MessageT, typename AllocatorT = std::allocator<void>>
 class LoanedMessage
 {
-public:
   using MessageAllocatorTraits = rclcpp::allocator::AllocRebind<MessageT, AllocatorT>;
   using MessageAllocator = typename MessageAllocatorTraits::allocator_type;
 
+public:
   /// Constructor of the LoanedMessage class.
   /**
    * The constructor of this class allocates memory for a given message type
    * and associates this with a given publisher.
    *
-   * The underlying middleware is queried to determine whether it is able to allocate the
-   * appropriate memory for this message type or not.
-   * In the case that the middleware cannot loan messages, the passed in allocator instance
-   * is used to allocate the message within the scope of this class.
-   * Otherwise, the allocator is ignored and the allocation is solely performed
+   * Given the publisher instance, a case differentiation is being performaned
+   * which decides whether the underlying middleware is able to allocate the appropriate
+   * memory for this message type or not.
+   * In the case that the middleware can not loan messages, the passed in allocator instance
+   * is being used to allocate the message within the scope of this class.
+   * Otherwise, the allocator is being ignored and the allocation is solely performaned
    * in the underlying middleware with its appropriate allocation strategy.
    * The need for this arises as the user code can be written explicitly targeting a middleware
    * capable of loaning messages.
@@ -52,12 +53,12 @@ public:
    * a middleware which doesn't support message loaning in which case the allocator will be used.
    *
    * \param[in] pub rclcpp::Publisher instance to which the memory belongs
-   * \param[in] allocator Allocator instance in case middleware cannot allocate messages
+   * \param[in] allocator Allocator instance in case middleware can not allocate messages
    * \throws anything rclcpp::exceptions::throw_from_rcl_error can throw.
    */
   LoanedMessage(
     const rclcpp::PublisherBase & pub,
-    MessageAllocator allocator)
+    std::allocator<MessageT> allocator)
   : pub_(pub),
     message_(nullptr),
     message_allocator_(std::move(allocator))
@@ -81,6 +82,36 @@ public:
     }
   }
 
+  /// Constructor of the LoanedMessage class.
+  /**
+   * The constructor of this class allocates memory for a given message type
+   * and associates this with a given publisher.
+   *
+   * Given the publisher instance, a case differentiation is being performaned
+   * which decides whether the underlying middleware is able to allocate the appropriate
+   * memory for this message type or not.
+   * In the case that the middleware can not loan messages, the passed in allocator instance
+   * is being used to allocate the message within the scope of this class.
+   * Otherwise, the allocator is being ignored and the allocation is solely performaned
+   * in the underlying middleware with its appropriate allocation strategy.
+   * The need for this arises as the user code can be written explicitly targeting a middleware
+   * capable of loaning messages.
+   * However, this user code is ought to be usable even when dynamically linked against
+   * a middleware which doesn't support message loaning in which case the allocator will be used.
+   *
+   * \param[in] pub rclcpp::Publisher instance to which the memory belongs
+   * \param[in] allocator Allocator instance in case middleware can not allocate messages
+   * \throws anything rclcpp::exceptions::throw_from_rcl_error can throw.
+   */
+  [[
+    deprecated("used the LoanedMessage constructor that does not use a shared_ptr to the allocator")
+  ]]
+  LoanedMessage(
+    const rclcpp::PublisherBase * pub,
+    std::shared_ptr<std::allocator<MessageT>> allocator)
+  : LoanedMessage(*pub, *allocator)
+  {}
+
   /// Move semantic for RVO
   LoanedMessage(LoanedMessage<MessageT> && other)
   : pub_(std::move(other.pub_)),

rclcpp/include/rclcpp/logger.hpp

@@ -15,7 +15,6 @@
 #ifndef RCLCPP__LOGGER_HPP_
 #define RCLCPP__LOGGER_HPP_
 
-#include <filesystem>
 #include <memory>
 #include <string>
 #include <utility>
@@ -78,14 +77,6 @@ RCLCPP_PUBLIC
 Logger
 get_node_logger(const rcl_node_t * node);
 
-// TODO(ahcorde): Remove deprecated class on the next release (in Rolling after Kilted).
-#if !defined(_WIN32)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#else  // !defined(_WIN32)
-# pragma warning(push)
-# pragma warning(disable: 4996)
-#endif
 /// Get the current logging directory.
 /**
  * For more details of how the logging directory is determined,
@@ -94,30 +85,10 @@ get_node_logger(const rcl_node_t * node);
  * \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,
- * see rcl_logging_get_logging_directory().
- *
- * \returns the logging directory being used.
- * \throws rclcpp::exceptions::RCLError if an unexpected error occurs.
- */
-RCLCPP_PUBLIC
-std::filesystem::path
-get_log_directory();
-
 class Logger
 {
 public:

rclcpp/include/rclcpp/node.hpp

@@ -44,7 +44,6 @@
 #include "rclcpp/event.hpp"
 #include "rclcpp/generic_client.hpp"
 #include "rclcpp/generic_publisher.hpp"
-#include "rclcpp/generic_service.hpp"
 #include "rclcpp/generic_subscription.hpp"
 #include "rclcpp/logger.hpp"
 #include "rclcpp/macros.hpp"
@@ -258,6 +257,22 @@ public:
     CallbackT callback,
     rclcpp::CallbackGroup::SharedPtr group = nullptr);
 
+  /// Create and return a Client.
+  /**
+   * \param[in] service_name The topic to service on.
+   * \param[in] qos_profile rmw_qos_profile_t Quality of service profile for client.
+   * \param[in] group Callback group to call the service.
+   * \return Shared pointer to the created client.
+   * \deprecated use rclcpp::QoS instead of rmw_qos_profile_t
+   */
+  template<typename ServiceT>
+  [[deprecated("use rclcpp::QoS instead of rmw_qos_profile_t")]]
+  typename rclcpp::Client<ServiceT>::SharedPtr
+  create_client(
+    const std::string & service_name,
+    const rmw_qos_profile_t & qos_profile,
+    rclcpp::CallbackGroup::SharedPtr group = nullptr);
+
   /// Create and return a Client.
   /**
    * \param[in] service_name The name on which the service is accessible.
@@ -272,6 +287,24 @@ public:
     const rclcpp::QoS & qos = rclcpp::ServicesQoS(),
     rclcpp::CallbackGroup::SharedPtr group = nullptr);
 
+  /// Create and return a Service.
+  /**
+   * \param[in] service_name The topic to service on.
+   * \param[in] callback User-defined callback function.
+   * \param[in] qos_profile rmw_qos_profile_t Quality of service profile for client.
+   * \param[in] group Callback group to call the service.
+   * \return Shared pointer to the created service.
+   * \deprecated use rclcpp::QoS instead of rmw_qos_profile_t
+   */
+  template<typename ServiceT, typename CallbackT>
+  [[deprecated("use rclcpp::QoS instead of rmw_qos_profile_t")]]
+  typename rclcpp::Service<ServiceT>::SharedPtr
+  create_service(
+    const std::string & service_name,
+    CallbackT && callback,
+    const rmw_qos_profile_t & qos_profile,
+    rclcpp::CallbackGroup::SharedPtr group = nullptr);
+
   /// Create and return a Service.
   /**
    * \param[in] service_name The topic to service on.
@@ -304,24 +337,6 @@ public:
     const rclcpp::QoS & qos = rclcpp::ServicesQoS(),
     rclcpp::CallbackGroup::SharedPtr group = nullptr);
 
-  /// Create and return a GenericService.
-  /**
-   * \param[in] service_name The topic to service on.
-   * \param[in] service_type The name of service type, e.g. "std_srvs/srv/SetBool"
-   * \param[in] callback User-defined callback function.
-   * \param[in] qos Quality of service profile for the service.
-   * \param[in] group Callback group to call the service.
-   * \return Shared pointer to the created service.
-   */
-  template<typename CallbackT>
-  typename rclcpp::GenericService::SharedPtr
-  create_generic_service(
-    const std::string & service_name,
-    const std::string & service_type,
-    CallbackT && callback,
-    const rclcpp::QoS & qos = rclcpp::ServicesQoS(),
-    rclcpp::CallbackGroup::SharedPtr group = nullptr);
-
   /// Create and return a GenericPublisher.
   /**
    * The returned pointer will never be empty, but this function can throw various exceptions, for
@@ -1000,6 +1015,8 @@ public:
     rclcpp::node_interfaces::OnSetParametersCallbackHandle;
   using OnSetParametersCallbackType =
     rclcpp::node_interfaces::NodeParametersInterface::OnSetParametersCallbackType;
+  using OnParametersSetCallbackType [[deprecated("use OnSetParametersCallbackType instead")]] =
+    OnSetParametersCallbackType;
 
   using PostSetParametersCallbackHandle =
     rclcpp::node_interfaces::PostSetParametersCallbackHandle;
@@ -1430,7 +1447,7 @@ public:
   rclcpp::Clock::ConstSharedPtr
   get_clock() const;
 
-  /// Returns current time from the node clock.
+  /// Returns current time from the time source specified by clock_type.
   /**
    * \sa rclcpp::Clock::now
    */
@@ -1559,10 +1576,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.

rclcpp/include/rclcpp/node_impl.hpp

@@ -40,7 +40,6 @@
 #include "rclcpp/create_generic_subscription.hpp"
 #include "rclcpp/create_publisher.hpp"
 #include "rclcpp/create_service.hpp"
-#include "rclcpp/create_generic_service.hpp"
 #include "rclcpp/create_subscription.hpp"
 #include "rclcpp/create_timer.hpp"
 #include "rclcpp/detail/resolve_enable_topic_statistics.hpp"
@@ -155,6 +154,22 @@ Node::create_client(
     group);
 }
 
+template<typename ServiceT>
+typename Client<ServiceT>::SharedPtr
+Node::create_client(
+  const std::string & service_name,
+  const rmw_qos_profile_t & qos_profile,
+  rclcpp::CallbackGroup::SharedPtr group)
+{
+  return rclcpp::create_client<ServiceT>(
+    node_base_,
+    node_graph_,
+    node_services_,
+    extend_name_with_sub_namespace(service_name, this->get_sub_namespace()),
+    qos_profile,
+    group);
+}
+
 template<typename ServiceT, typename CallbackT>
 typename rclcpp::Service<ServiceT>::SharedPtr
 Node::create_service(
@@ -172,22 +187,20 @@ Node::create_service(
     group);
 }
 
-template<typename CallbackT>
-typename rclcpp::GenericService::SharedPtr
-Node::create_generic_service(
+template<typename ServiceT, typename CallbackT>
+typename rclcpp::Service<ServiceT>::SharedPtr
+Node::create_service(
   const std::string & service_name,
-  const std::string & service_type,
   CallbackT && callback,
-  const rclcpp::QoS & qos,
+  const rmw_qos_profile_t & qos_profile,
   rclcpp::CallbackGroup::SharedPtr group)
 {
-  return rclcpp::create_generic_service<CallbackT>(
+  return rclcpp::create_service<ServiceT, CallbackT>(
     node_base_,
     node_services_,
     extend_name_with_sub_namespace(service_name, this->get_sub_namespace()),
-    service_type,
     std::forward<CallbackT>(callback),
-    qos,
+    qos_profile,
     group);
 }
 
@@ -323,9 +336,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 +355,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;
   }

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>;

rclcpp/include/rclcpp/node_interfaces/node_parameters_interface.hpp

@@ -52,6 +52,8 @@ struct OnSetParametersCallbackHandle
     std::function<
     rcl_interfaces::msg::SetParametersResult(
       const std::vector<rclcpp::Parameter> &)>;
+  using OnParametersSetCallbackType [[deprecated("use OnSetParametersCallbackType instead")]] =
+    OnSetParametersCallbackType;
 
   OnSetParametersCallbackType callback;
 };
@@ -270,26 +272,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

rclcpp/include/rclcpp/node_options.hpp

@@ -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

rclcpp/include/rclcpp/parameter_client.hpp

@@ -52,6 +52,37 @@ class AsyncParametersClient
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(AsyncParametersClient)
 
+  /// Create an async parameters client.
+  /**
+   * \param[in] node_base_interface The node base interface of the corresponding node.
+   * \param[in] node_topics_interface Node topic base interface.
+   * \param[in] node_graph_interface The node graph interface of the corresponding node.
+   * \param[in] node_services_interface Node service interface.
+   * \param[in] remote_node_name Name of the remote node
+   * \param[in] qos_profile The rmw qos profile to use to subscribe
+   * \param[in] group (optional) The async parameter client will be added to this callback group.
+   * \deprecated use rclcpp::QoS instead of rmw_qos_profile_t
+   */
+  [[deprecated("use rclcpp::QoS instead of rmw_qos_profile_t")]]
+  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 std::string & remote_node_name,
+    const rmw_qos_profile_t & qos_profile,
+    rclcpp::CallbackGroup::SharedPtr group = nullptr)
+  : AsyncParametersClient(
+      node_base_interface,
+      node_topics_interface,
+      node_graph_interface,
+      node_services_interface,
+      remote_node_name,
+      rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(qos_profile)),
+      group)
+  {}
+
   /// Create an async parameters client.
   /**
    * \param[in] node_base_interface The node base interface of the corresponding node.
@@ -72,6 +103,31 @@ public:
     const rclcpp::QoS & qos_profile = rclcpp::ParametersQoS(),
     rclcpp::CallbackGroup::SharedPtr group = nullptr);
 
+  /// Constructor
+  /**
+   * \param[in] node The async parameters client will be added to this node.
+   * \param[in] remote_node_name name of the remote node
+   * \param[in] qos_profile The rmw qos profile to use to subscribe
+   * \param[in] group (optional) The async parameter client will be added to this callback group.
+   * \deprecated use rclcpp::QoS instead of rmw_qos_profile_t
+   */
+  template<typename NodeT>
+  [[deprecated("use rclcpp::QoS instead of rmw_qos_profile_t")]]
+  AsyncParametersClient(
+    const std::shared_ptr<NodeT> node,
+    const std::string & remote_node_name,
+    const rmw_qos_profile_t & qos_profile,
+    rclcpp::CallbackGroup::SharedPtr group = nullptr)
+  : AsyncParametersClient(
+      node->get_node_base_interface(),
+      node->get_node_topics_interface(),
+      node->get_node_graph_interface(),
+      node->get_node_services_interface(),
+      remote_node_name,
+      rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(qos_profile)),
+      group)
+  {}
+
   /**
    * \param[in] node The async parameters client will be added to this node.
    * \param[in] remote_node_name (optional) name of the remote node
@@ -94,6 +150,31 @@ public:
       group)
   {}
 
+  /// Constructor
+  /**
+   * \param[in] node The async parameters client will be added to this node.
+   * \param[in] remote_node_name Name of the remote node
+   * \param[in] qos_profile The rmw qos profile to use to subscribe
+   * \param[in] group (optional) The async parameter client will be added to this callback group.
+   * \deprecated use rclcpp::QoS instead of rmw_qos_profile_t
+   */
+  template<typename NodeT>
+  [[deprecated("use rclcpp::QoS instead of rmw_qos_profile_t")]]
+  AsyncParametersClient(
+    NodeT * node,
+    const std::string & remote_node_name,
+    const rmw_qos_profile_t & qos_profile,
+    rclcpp::CallbackGroup::SharedPtr group = nullptr)
+  : AsyncParametersClient(
+      node->get_node_base_interface(),
+      node->get_node_topics_interface(),
+      node->get_node_graph_interface(),
+      node->get_node_services_interface(),
+      remote_node_name,
+      rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(qos_profile)),
+      group)
+  {}
+
   /**
    * \param[in] node The async parameters client will be added to this node.
    * \param[in] remote_node_name (optional) name of the remote node
@@ -302,6 +383,19 @@ class SyncParametersClient
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(SyncParametersClient)
 
+  template<typename NodeT>
+  [[deprecated("use rclcpp::QoS instead of rmw_qos_profile_t")]]
+  SyncParametersClient(
+    std::shared_ptr<NodeT> node,
+    const std::string & remote_node_name,
+    const rmw_qos_profile_t & qos_profile)
+  : SyncParametersClient(
+      std::make_shared<rclcpp::executors::SingleThreadedExecutor>(),
+      node,
+      remote_node_name,
+      rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(qos_profile)))
+  {}
+
   template<typename NodeT>
   explicit SyncParametersClient(
     std::shared_ptr<NodeT> node,
@@ -314,6 +408,23 @@ public:
       qos_profile)
   {}
 
+  template<typename NodeT>
+  [[deprecated("use rclcpp::QoS instead of rmw_qos_profile_t")]]
+  SyncParametersClient(
+    rclcpp::Executor::SharedPtr executor,
+    std::shared_ptr<NodeT> node,
+    const std::string & remote_node_name,
+    const rmw_qos_profile_t & qos_profile)
+  : SyncParametersClient(
+      executor,
+      node->get_node_base_interface(),
+      node->get_node_topics_interface(),
+      node->get_node_graph_interface(),
+      node->get_node_services_interface(),
+      remote_node_name,
+      rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(qos_profile)))
+  {}
+
   template<typename NodeT>
   SyncParametersClient(
     rclcpp::Executor::SharedPtr executor,
@@ -330,6 +441,19 @@ public:
       qos_profile)
   {}
 
+  template<typename NodeT>
+  [[deprecated("use rclcpp::QoS instead of rmw_qos_profile_t")]]
+  SyncParametersClient(
+    NodeT * node,
+    const std::string & remote_node_name,
+    const rmw_qos_profile_t & qos_profile)
+  : SyncParametersClient(
+      std::make_shared<rclcpp::executors::SingleThreadedExecutor>(),
+      node,
+      remote_node_name,
+      rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(qos_profile)))
+  {}
+
   template<typename NodeT>
   explicit SyncParametersClient(
     NodeT * node,
@@ -342,6 +466,23 @@ public:
       qos_profile)
   {}
 
+  template<typename NodeT>
+  [[deprecated("use rclcpp::QoS instead of rmw_qos_profile_t")]]
+  SyncParametersClient(
+    rclcpp::Executor::SharedPtr executor,
+    NodeT * node,
+    const std::string & remote_node_name,
+    const rmw_qos_profile_t & qos_profile)
+  : SyncParametersClient(
+      executor,
+      node->get_node_base_interface(),
+      node->get_node_topics_interface(),
+      node->get_node_graph_interface(),
+      node->get_node_services_interface(),
+      remote_node_name,
+      rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(qos_profile)))
+  {}
+
   template<typename NodeT>
   SyncParametersClient(
     rclcpp::Executor::SharedPtr executor,
@@ -358,6 +499,28 @@ public:
       qos_profile)
   {}
 
+  [[deprecated("use rclcpp::QoS instead of rmw_qos_profile_t")]]
+  RCLCPP_PUBLIC
+  SyncParametersClient(
+    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 rmw_qos_profile_t & qos_profile)
+  : executor_(executor), node_base_interface_(node_base_interface)
+  {
+    async_parameters_client_ =
+      std::make_shared<AsyncParametersClient>(
+      node_base_interface,
+      node_topics_interface,
+      node_graph_interface,
+      node_services_interface,
+      remote_node_name,
+      rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(qos_profile)));
+  }
+
   RCLCPP_PUBLIC
   SyncParametersClient(
     rclcpp::Executor::SharedPtr executor,

rclcpp/include/rclcpp/parameter_event_handler.hpp

@@ -67,23 +67,19 @@ struct ParameterEventCallbackHandle
  * The first step is to instantiate a ParameterEventHandler, providing a ROS node to use
  * to create any required subscriptions:
  *
- * ```cpp
- * auto param_handler = std::make_shared<rclcpp::ParameterEventHandler>(node);
- * ```
+ *   auto param_handler = std::make_shared<rclcpp::ParameterEventHandler>(node);
  *
  * Next, you can supply a callback to the add_parameter_callback method, as follows:
  *
- * ```cpp
- * auto cb1 = [&node](const rclcpp::Parameter & p) {
- *    RCLCPP_INFO(
- *      node->get_logger(),
- *      "cb1: Received an update to parameter \"%s\" of type %s: \"%ld\"",
- *      p.get_name().c_str(),
- *      p.get_type_name().c_str(),
- *      p.as_int());
- * };
- * auto handle1 = param_handler->add_parameter_callback("an_int_param", cb1);
- * ```
+ *   auto cb1 = [&node](const rclcpp::Parameter & p) {
+ *      RCLCPP_INFO(
+ *        node->get_logger(),
+ *        "cb1: Received an update to parameter \"%s\" of type %s: \"%ld\"",
+ *        p.get_name().c_str(),
+ *        p.get_type_name().c_str(),
+ *        p.as_int());
+ *   };
+ *   auto handle1 = param_handler->add_parameter_callback("an_int_param", cb1);
  *
  * In this case, we didn't supply a node name (the third, optional, parameter) so the
  * default will be to monitor for changes to the "an_int_param" parameter associated with
@@ -96,18 +92,16 @@ struct ParameterEventCallbackHandle
  * You may also monitor for changes to parameters in other nodes by supplying the node
  * name to add_parameter_callback:
  *
- * ```cpp
- * auto cb2 = [&node](const rclcpp::Parameter & p) {
- *     RCLCPP_INFO(
- *       node->get_logger(),
- *       "cb2: Received an update to parameter \"%s\" of type: %s: \"%s\"",
- *       p.get_name().c_str(),
- *       p.get_type_name().c_str(),
- *       p.as_string().c_str());
- *   };
- * auto handle2 = param_handler->add_parameter_callback(
- *   "some_remote_param_name", cb2, "some_remote_node_name");
- * ```
+ *   auto cb2 = [&node](const rclcpp::Parameter & p) {
+ *       RCLCPP_INFO(
+ *         node->get_logger(),
+ *         "cb2: Received an update to parameter \"%s\" of type: %s: \"%s\"",
+ *         p.get_name().c_str(),
+ *         p.get_type_name().c_str(),
+ *         p.as_string().c_str());
+ *     };
+ *   auto handle2 = param_handler->add_parameter_callback(
+ *     "some_remote_param_name", cb2, "some_remote_node_name");
  *
  * In this case, the callback will be invoked whenever "some_remote_param_name" changes
  * on remote node "some_remote_node_name".
@@ -115,9 +109,7 @@ struct ParameterEventCallbackHandle
  * To remove a parameter callback, reset the callback handle smart pointer or call
  * remove_parameter_callback, passing the handle returned from add_parameter_callback:
  *
- * ```cpp
- * param_handler->remove_parameter_callback(handle2);
- * ```
+ *   param_handler->remove_parameter_callback(handle2);
  *
  * You can also monitor for *all* parameter changes, using add_parameter_event_callback.
  * In this case, the callback will be invoked whenever any parameter changes in the system.
@@ -125,42 +117,40 @@ struct ParameterEventCallbackHandle
  * is convenient to use a regular expression on the node names or namespaces of interest.
  * For example:
  *
- * ```cpp
- * auto cb3 =
- *   [fqn, remote_param_name, &node](const rcl_interfaces::msg::ParameterEvent & event) {
- *     // Look for any updates to parameters in "/a_namespace" as well as any parameter changes
- *     // to our own node ("this_node")
- *     std::regex re("(/a_namespace/.*)|(/this_node)");
- *     if (regex_match(event.node, re)) {
- *       // Now that we know the event matches the regular expression we scanned for, we can
- *       // use 'get_parameter_from_event' to get a specific parameter name that we're looking for
- *       rclcpp::Parameter p;
- *       if (rclcpp::ParameterEventHandler::get_parameter_from_event(
- *           event, p, remote_param_name, fqn))
- *       {
- *         RCLCPP_INFO(
- *           node->get_logger(),
- *           "cb3: Received an update to parameter \"%s\" of type: %s: \"%s\"",
- *           p.get_name().c_str(),
- *           p.get_type_name().c_str(),
- *           p.as_string().c_str());
- *       }
+ *   auto cb3 =
+ *     [fqn, remote_param_name, &node](const rcl_interfaces::msg::ParameterEvent & event) {
+ *       // Look for any updates to parameters in "/a_namespace" as well as any parameter changes
+ *       // to our own node ("this_node")
+ *       std::regex re("(/a_namespace/.*)|(/this_node)");
+ *       if (regex_match(event.node, re)) {
+ *         // Now that we know the event matches the regular expression we scanned for, we can
+ *         // use 'get_parameter_from_event' to get a specific parameter name that we're looking for
+ *         rclcpp::Parameter p;
+ *         if (rclcpp::ParameterEventsSubscriber::get_parameter_from_event(
+ *             event, p, remote_param_name, fqn))
+ *         {
+ *           RCLCPP_INFO(
+ *             node->get_logger(),
+ *             "cb3: Received an update to parameter \"%s\" of type: %s: \"%s\"",
+ *             p.get_name().c_str(),
+ *             p.get_type_name().c_str(),
+ *             p.as_string().c_str());
+ *         }
  *
- *       // You can also use 'get_parameter*s*_from_event' to enumerate all changes that came
- *       // in on this event
- *       auto params = rclcpp::ParameterEventHandler::get_parameters_from_event(event);
- *       for (auto & p : params) {
- *         RCLCPP_INFO(
- *           node->get_logger(),
- *           "cb3: Received an update to parameter \"%s\" of type: %s: \"%s\"",
- *           p.get_name().c_str(),
- *           p.get_type_name().c_str(),
- *           p.value_to_string().c_str());
+ *         // You can also use 'get_parameter*s*_from_event' to enumerate all changes that came
+ *         // in on this event
+ *         auto params = rclcpp::ParameterEventsSubscriber::get_parameters_from_event(event);
+ *         for (auto & p : params) {
+ *           RCLCPP_INFO(
+ *             node->get_logger(),
+ *             "cb3: Received an update to parameter \"%s\" of type: %s: \"%s\"",
+ *             p.get_name().c_str(),
+ *             p.get_type_name().c_str(),
+ *             p.value_to_string().c_str());
+ *         }
  *       }
- *     }
- *   };
- * auto handle3 = param_handler->add_parameter_event_callback(cb3);
- * ```
+ *     };
+ *   auto handle3 = param_handler->add_parameter_event_callback(cb3);
  *
  * For both parameter callbacks and parameter event callbacks, when multiple callbacks are added,
  * the callbacks are invoked last-in, first-called order (LIFO).
@@ -170,9 +160,7 @@ struct ParameterEventCallbackHandle
  *
  * To remove a parameter event callback, reset the callback smart pointer or use:
  *
- * ```cpp
- * param_handler->remove_event_parameter_callback(handle3);
- * ```
+ *   param_handler->remove_event_parameter_callback(handle3);
  */
 class ParameterEventHandler
 {

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:
    *

rclcpp/include/rclcpp/parameter_service.hpp

@@ -40,6 +40,20 @@ class ParameterService
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(ParameterService)
 
+  [[deprecated("use rclcpp::QoS instead of rmw_qos_profile_t")]]
+  RCLCPP_PUBLIC
+  ParameterService(
+    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 rmw_qos_profile_t & qos_profile)
+  : ParameterService(
+      node_base,
+      node_services,
+      node_params,
+      rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(qos_profile)))
+  {}
+
   RCLCPP_PUBLIC
   ParameterService(
     const std::shared_ptr<node_interfaces::NodeBaseInterface> node_base,

rclcpp/include/rclcpp/parameter_value.hpp

@@ -359,7 +359,7 @@ private:
 /// Return the value of a parameter as a string
 RCLCPP_PUBLIC
 std::string
-to_string(const ParameterValue & value);
+to_string(const ParameterValue & type);
 
 }  // namespace rclcpp
 

rclcpp/include/rclcpp/publisher.hpp

@@ -96,6 +96,22 @@ public:
   using ROSMessageTypeAllocator = typename ROSMessageTypeAllocatorTraits::allocator_type;
   using ROSMessageTypeDeleter = allocator::Deleter<ROSMessageTypeAllocator, ROSMessageType>;
 
+  using MessageAllocatorTraits
+  [[deprecated("use PublishedTypeAllocatorTraits")]] =
+    PublishedTypeAllocatorTraits;
+  using MessageAllocator
+  [[deprecated("use PublishedTypeAllocator")]] =
+    PublishedTypeAllocator;
+  using MessageDeleter
+  [[deprecated("use PublishedTypeDeleter")]] =
+    PublishedTypeDeleter;
+  using MessageUniquePtr
+  [[deprecated("use std::unique_ptr<PublishedType, PublishedTypeDeleter>")]] =
+    std::unique_ptr<PublishedType, PublishedTypeDeleter>;
+  using MessageSharedPtr
+  [[deprecated("use std::shared_ptr<const PublishedType>")]] =
+    std::shared_ptr<const PublishedType>;
+
   using BufferSharedPtr = typename rclcpp::experimental::buffers::IntraProcessBuffer<
     ROSMessageType,
     ROSMessageTypeAllocator,
@@ -112,8 +128,8 @@ public:
    *
    * \param[in] node_base NodeBaseInterface pointer that is used in part of the setup.
    * \param[in] topic Name of the topic to publish to.
-   * \param[in] qos QoS profile for the publisher.
-   * \param[in] options Options for the publisher.
+   * \param[in] qos QoS profile for Subcription.
+   * \param[in] options Options for the subscription.
    */
   Publisher(
     rclcpp::node_interfaces::NodeBaseInterface * node_base,
@@ -143,34 +159,34 @@ 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)
   {
+    // Topic is unused for now.
+    (void)topic;
+    (void)options;
+
     // If needed, setup intra process communication.
     if (rclcpp::detail::resolve_use_intra_process(options_, *node_base)) {
       auto context = node_base->get_context();
       // Get the intra process manager instance for this context.
       auto ipm = context->get_sub_context<rclcpp::experimental::IntraProcessManager>();
-      // Check if the QoS is compatible with intra-process.
-      auto qos_profile = get_actual_qos();
-      if (qos_profile.history() != rclcpp::HistoryPolicy::KeepLast) {
+      // Register the publisher with the intra process manager.
+      if (qos.history() != rclcpp::HistoryPolicy::KeepLast) {
         throw std::invalid_argument(
-                "intraprocess communication on topic '" + topic +
-                "' allowed only with keep last history qos policy");
+                "intraprocess communication allowed only with keep last history qos policy");
       }
-      if (qos_profile.depth() == 0) {
+      if (qos.depth() == 0) {
         throw std::invalid_argument(
-                "intraprocess communication on topic '" + topic +
-                "' is not allowed with a zero qos history depth value");
+                "intraprocess communication is not allowed with a zero qos history depth value");
       }
-      if (qos_profile.durability() == rclcpp::DurabilityPolicy::TransientLocal) {
+      if (qos.durability() == rclcpp::DurabilityPolicy::TransientLocal) {
         buffer_ = rclcpp::experimental::create_intra_process_buffer<
           ROSMessageType, ROSMessageTypeAllocator, ROSMessageTypeDeleter>(
           rclcpp::detail::resolve_intra_process_buffer_type(options_.intra_process_buffer_type),
-          qos_profile,
+          qos,
           std::make_shared<ROSMessageTypeAllocator>(ros_message_type_allocator_));
       }
-      // Register the publisher with the intra process manager.
       uint64_t intra_process_publisher_id = ipm->add_publisher(this->shared_from_this(), buffer_);
       this->setup_intra_process(
         intra_process_publisher_id,
@@ -187,7 +203,7 @@ public:
    * the loaned message will be directly allocated in the middleware.
    * If not, the message allocator of this rclcpp::Publisher instance is being used.
    *
-   * With a call to `publish` the LoanedMessage instance is being returned to the middleware
+   * With a call to \sa `publish` the LoanedMessage instance is being returned to the middleware
    * or free'd accordingly to the allocator.
    * If the message is not being published but processed differently, the destructor of this
    * class will either return the message to the middleware or deallocate it via the internal
@@ -232,12 +248,8 @@ public:
     // interprocess publish, resulting in lower publish-to-subscribe latency.
     // It's not possible to do that with an unique_ptr,
     // as do_intra_process_publish takes the ownership of the message.
-
-    // When durability is set to TransientLocal (i.e. there is a buffer),
-    // inter process publish should always take place to ensure
-    // late joiners receive past data.
     bool inter_process_publish_needed =
-      get_subscription_count() > get_intra_process_subscription_count() || buffer_;
+      get_subscription_count() > get_intra_process_subscription_count();
 
     if (inter_process_publish_needed) {
       auto shared_msg =
@@ -314,11 +326,8 @@ public:
       return;
     }
 
-    // When durability is set to TransientLocal (i.e. there is a buffer),
-    // inter process publish should always take place to ensure
-    // late joiners receive past data.
     bool inter_process_publish_needed =
-      get_subscription_count() > get_intra_process_subscription_count() || buffer_;
+      get_subscription_count() > get_intra_process_subscription_count();
 
     if (inter_process_publish_needed) {
       auto ros_msg_ptr = std::make_shared<ROSMessageType>();
@@ -414,6 +423,13 @@ public:
     }
   }
 
+  [[deprecated("use get_published_type_allocator() or get_ros_message_type_allocator() instead")]]
+  std::shared_ptr<PublishedTypeAllocator>
+  get_allocator() const
+  {
+    return std::make_shared<PublishedTypeAllocator>(published_type_allocator_);
+  }
+
   PublishedTypeAllocator
   get_published_type_allocator() const
   {

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)
   ));
 };
 

rclcpp/include/rclcpp/rate.hpp

@@ -39,6 +39,10 @@ public:
   RCLCPP_PUBLIC
   virtual bool sleep() = 0;
 
+  [[deprecated("use get_type() instead")]]
+  RCLCPP_PUBLIC
+  virtual bool is_steady() const = 0;
+
   RCLCPP_PUBLIC
   virtual rcl_clock_type_t get_type() const = 0;
 
@@ -50,6 +54,82 @@ using std::chrono::duration;
 using std::chrono::duration_cast;
 using std::chrono::nanoseconds;
 
+template<class Clock = std::chrono::high_resolution_clock>
+class [[deprecated("use rclcpp::Rate class instead of GenericRate")]] GenericRate : public RateBase
+{
+public:
+  RCLCPP_SMART_PTR_DEFINITIONS(GenericRate)
+
+  explicit GenericRate(double rate)
+  : period_(duration_cast<nanoseconds>(duration<double>(1.0 / rate))), last_interval_(Clock::now())
+  {}
+  explicit GenericRate(std::chrono::nanoseconds period)
+  : period_(period), last_interval_(Clock::now())
+  {}
+
+  virtual bool
+  sleep()
+  {
+    // Time coming into sleep
+    auto now = Clock::now();
+    // Time of next interval
+    auto next_interval = last_interval_ + period_;
+    // Detect backwards time flow
+    if (now < last_interval_) {
+      // Best thing to do is to set the next_interval to now + period
+      next_interval = now + period_;
+    }
+    // Calculate the time to sleep
+    auto time_to_sleep = next_interval - now;
+    // Update the interval
+    last_interval_ += period_;
+    // If the time_to_sleep is negative or zero, don't sleep
+    if (time_to_sleep <= std::chrono::seconds(0)) {
+      // If an entire cycle was missed then reset next interval.
+      // This might happen if the loop took more than a cycle.
+      // Or if time jumps forward.
+      if (now > next_interval + period_) {
+        last_interval_ = now + period_;
+      }
+      // Either way do not sleep and return false
+      return false;
+    }
+    // Sleep (will get interrupted by ctrl-c, may not sleep full time)
+    rclcpp::sleep_for(time_to_sleep);
+    return true;
+  }
+
+  [[deprecated("use get_type() instead")]]
+  virtual bool
+  is_steady() const
+  {
+    return Clock::is_steady;
+  }
+
+  virtual rcl_clock_type_t get_type() const
+  {
+    return Clock::is_steady ? RCL_STEADY_TIME : RCL_SYSTEM_TIME;
+  }
+
+  virtual void
+  reset()
+  {
+    last_interval_ = Clock::now();
+  }
+
+  std::chrono::nanoseconds period() const
+  {
+    return period_;
+  }
+
+private:
+  RCLCPP_DISABLE_COPY(GenericRate)
+
+  std::chrono::nanoseconds period_;
+  using ClockDurationNano = std::chrono::duration<typename Clock::rep, std::nano>;
+  std::chrono::time_point<Clock, ClockDurationNano> last_interval_;
+};
+
 class Rate : public RateBase
 {
 public:
@@ -69,6 +149,11 @@ public:
   virtual bool
   sleep();
 
+  [[deprecated("use get_type() instead")]]
+  RCLCPP_PUBLIC
+  virtual bool
+  is_steady() const;
+
   RCLCPP_PUBLIC
   virtual rcl_clock_type_t
   get_type() const;

rclcpp/include/rclcpp/service.hpp

@@ -307,7 +307,7 @@ public:
    * \param[in] node_handle NodeBaseInterface pointer that is used in part of the setup.
    * \param[in] service_name Name of the topic to publish to.
    * \param[in] any_callback User defined callback to call when a client request is received.
-   * \param[in] service_options options for the service.
+   * \param[in] service_options options for the subscription.
    */
   Service(
     std::shared_ptr<rcl_node_t> node_handle,
@@ -504,9 +504,6 @@ public:
    * \param[in] clock clock to use to generate introspection timestamps
    * \param[in] qos_service_event_pub QoS settings to use when creating the introspection publisher
    * \param[in] introspection_state the state to set introspection to
-   *
-   * \throws anything rclcpp::exceptions::throw_from_rcl_error can throw if
-   *   it failed to configure introspection.
    */
   void
   configure_introspection(

rclcpp/include/rclcpp/strategies/allocator_memory_strategy.hpp

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

rclcpp/include/rclcpp/strategies/message_pool_memory_strategy.hpp

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

rclcpp/include/rclcpp/subscription.hpp

@@ -90,6 +90,18 @@ public:
   using ROSMessageTypeAllocator = typename ROSMessageTypeAllocatorTraits::allocator_type;
   using ROSMessageTypeDeleter = allocator::Deleter<ROSMessageTypeAllocator, ROSMessageType>;
 
+  using MessageAllocatorTraits [[deprecated("use ROSMessageTypeAllocatorTraits")]] =
+    ROSMessageTypeAllocatorTraits;
+  using MessageAllocator [[deprecated("use ROSMessageTypeAllocator")]] =
+    ROSMessageTypeAllocator;
+  using MessageDeleter [[deprecated("use ROSMessageTypeDeleter")]] =
+    ROSMessageTypeDeleter;
+
+  using ConstMessageSharedPtr [[deprecated]] = std::shared_ptr<const ROSMessageType>;
+  using MessageUniquePtr
+  [[deprecated("use std::unique_ptr<ROSMessageType, ROSMessageTypeDeleter> instead")]] =
+    std::unique_ptr<ROSMessageType, ROSMessageTypeDeleter>;
+
 private:
   using SubscriptionTopicStatisticsSharedPtr =
     std::shared_ptr<rclcpp::topic_statistics::SubscriptionTopicStatistics>;
@@ -147,13 +159,11 @@ public:
       auto qos_profile = get_actual_qos();
       if (qos_profile.history() != rclcpp::HistoryPolicy::KeepLast) {
         throw std::invalid_argument(
-                "intraprocess communication on topic '" + topic_name +
-                "' allowed only with keep last history qos policy");
+                "intraprocess communication allowed only with keep last history qos policy");
       }
       if (qos_profile.depth() == 0) {
         throw std::invalid_argument(
-                "intraprocess communication on topic '" + topic_name +
-                "' is not allowed with 0 depth qos policy");
+                "intraprocess communication is not allowed with 0 depth qos policy");
       }
 
       using SubscriptionIntraProcessT = rclcpp::experimental::SubscriptionIntraProcess<
@@ -209,11 +219,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.
@@ -420,17 +432,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");
   }

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"

rclcpp/include/rclcpp/subscription_options.hpp

@@ -80,8 +80,7 @@ struct SubscriptionOptionsBase
 
     // An optional QoS which can provide topic_statistics with a stable QoS separate from
     // the subscription's current QoS settings which could be unstable.
-    // Explicitly set the enough depth to avoid missing the statistics messages.
-    rclcpp::QoS qos = SystemDefaultsQoS().keep_last(10);
+    rclcpp::QoS qos = SystemDefaultsQoS();
   };
 
   TopicStatisticsOptions topic_stats_options;

rclcpp/include/rclcpp/time.hpp

@@ -49,7 +49,6 @@ public:
   /**
    * \param nanoseconds since time epoch
    * \param clock_type clock type
-   * \throws std::runtime_error if nanoseconds are negative
    */
   RCLCPP_PUBLIC
   explicit Time(int64_t nanoseconds = 0, rcl_clock_type_t clock_type = RCL_SYSTEM_TIME);

rclcpp/include/rclcpp/topic_statistics/subscription_topic_statistics.hpp

@@ -172,11 +172,12 @@ private:
   {
     auto received_message_age = std::make_unique<ReceivedMessageAge>();
     received_message_age->Start();
+    subscriber_statistics_collectors_.emplace_back(std::move(received_message_age));
+
     auto received_message_period = std::make_unique<ReceivedMessagePeriod>();
     received_message_period->Start();
     {
       std::lock_guard<std::mutex> lock(mutex_);
-      subscriber_statistics_collectors_.emplace_back(std::move(received_message_age));
       subscriber_statistics_collectors_.emplace_back(std::move(received_message_period));
     }
 

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,45 @@
 
 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 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.
+ *
+ * \deprecated Use get_message_typesupport_handle() instead
+ *
+ * \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
+ * \return A type support handle
+ */
+[[deprecated("Use `get_message_typesupport_handle` instead")]]
+RCLCPP_PUBLIC
+const rosidl_message_type_support_t *
+get_typesupport_handle(
+  const std::string & type,
+  const std::string & typesupport_identifier,
+  rcpputils::SharedLibrary & library);
+
+/// 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 +74,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 +91,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_

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
 {
@@ -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);
 }

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;
         }
       }
     }

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_;

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

rclcpp/include/rclcpp/wait_set_template.hpp

@@ -734,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.
@@ -750,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();
   }

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:
@@ -104,6 +101,23 @@ public:
   size_t
   get_number_of_ready_guard_conditions();
 
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Woverloaded-virtual"
+#endif
+  /// Deprecated.
+  /**
+   * \sa add_to_wait_set(rcl_wait_set_t &)
+   */
+  [[deprecated("Use add_to_wait_set(rcl_wait_set_t & wait_set) signature")]]
+  RCLCPP_PUBLIC
+  virtual
+  void
+  add_to_wait_set(rcl_wait_set_t * wait_set);
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
   /// Add the Waitable to a wait set.
   /**
    * \param[in] wait_set A handle to the wait set to add the Waitable to.
@@ -112,7 +126,24 @@ public:
   RCLCPP_PUBLIC
   virtual
   void
-  add_to_wait_set(rcl_wait_set_t & wait_set) = 0;
+  add_to_wait_set(rcl_wait_set_t & wait_set);
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Woverloaded-virtual"
+#endif
+  /// Deprecated.
+  /**
+   * \sa is_ready(const rcl_wait_set_t &)
+   */
+  [[deprecated("Use is_ready(const rcl_wait_set_t & wait_set) signature")]]
+  RCLCPP_PUBLIC
+  virtual
+  bool
+  is_ready(rcl_wait_set_t * wait_set);
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 
   /// Check if the Waitable is ready.
   /**
@@ -127,7 +158,7 @@ public:
   RCLCPP_PUBLIC
   virtual
   bool
-  is_ready(const rcl_wait_set_t & wait_set) = 0;
+  is_ready(const rcl_wait_set_t & wait_set);
 
   /// Take the data so that it can be consumed with `execute`.
   /**
@@ -179,7 +210,24 @@ public:
   RCLCPP_PUBLIC
   virtual
   std::shared_ptr<void>
-  take_data_by_entity_id(size_t id) = 0;
+  take_data_by_entity_id(size_t id);
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Woverloaded-virtual"
+#endif
+  /// Deprecated.
+  /**
+   * \sa execute(const std::shared_ptr<void> &)
+   */
+  [[deprecated("Use execute(const std::shared_ptr<void> & data) signature")]]
+  RCLCPP_PUBLIC
+  virtual
+  void
+  execute(std::shared_ptr<void> & data);
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 
   /// Execute data that is passed in.
   /**
@@ -206,7 +254,7 @@ public:
   RCLCPP_PUBLIC
   virtual
   void
-  execute(const std::shared_ptr<void> & data) = 0;
+  execute(const std::shared_ptr<void> & data);
 
   /// Exchange the "in use by wait set" state for this timer.
   /**
@@ -249,7 +297,7 @@ public:
   RCLCPP_PUBLIC
   virtual
   void
-  set_on_ready_callback(std::function<void(size_t, int)> callback) = 0;
+  set_on_ready_callback(std::function<void(size_t, int)> callback);
 
   /// Unset any callback registered via set_on_ready_callback.
   /**
@@ -259,18 +307,7 @@ public:
   RCLCPP_PUBLIC
   virtual
   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;
+  clear_on_ready_callback();
 
 private:
   std::atomic<bool> in_use_by_wait_set_{false};

rclcpp/package.xml

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

rclcpp/resource/logging.hpp.em

@@ -124,7 +124,8 @@ def get_rclcpp_suffix_from_features(features):
 ) \
   do { \
     static_assert( \
-      ::std::is_convertible_v<decltype(logger), ::rclcpp::Logger>, \
+      ::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 { \

rclcpp/src/rclcpp/clock.cpp

@@ -367,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, rclcpp::Context::SharedPtr context)
-  :context_(context),
-    clock_(std::make_unique<ClockWaiter>(clock))
-  {
-    if (!context_ || !context_->is_valid()) {
-      throw std::runtime_error("context cannot be slept with because it's invalid");
-    }
-    // Wake this thread if the context is shutdown
-    shutdown_cb_handle_ = context_->add_on_shutdown_callback(
-      [this]() {
-        {
-          std::unique_lock lock(pred_mutex_);
-          shutdown_ = true;
-        }
-        clock_->notify_one();
-    });
-  }
-
-  ~Impl()
-  {
-    context_->remove_on_shutdown_callback(shutdown_cb_handle_);
-  }
-
-  bool
-  wait_until(
-    std::unique_lock<std::mutex> & lock, rclcpp::Time until,
-    const std::function<bool ()> & pred)
-  {
-    if(lock.mutex() != &pred_mutex_) {
-      throw std::runtime_error(
-          "ClockConditionalVariable::wait_until: Internal error, given lock does not use"
-          " mutex returned by this->mutex()");
-    }
-
-    clock_->wait_until(lock, until, [this, &pred] () -> bool {
-        return shutdown_ || pred();
-      });
-    return true;
-  }
-
-  void
-  notify_one()
-  {
-    clock_->notify_one();
-  }
-
-  std::mutex &
-  mutex()
-  {
-    return pred_mutex_;
-  }
-};
-
-ClockConditionalVariable::ClockConditionalVariable(
-  const rclcpp::Clock::SharedPtr & clock,
-  rclcpp::Context::SharedPtr context)
-:impl_(std::make_unique<Impl>(clock, context))
-{
-}
-
-ClockConditionalVariable::~ClockConditionalVariable() = default;
-
-void
-ClockConditionalVariable::notify_one()
-{
-  impl_->notify_one();
-}
-
-bool
-ClockConditionalVariable::wait_until(
-  std::unique_lock<std::mutex> & lock, rclcpp::Time until,
-  const std::function<bool ()> & pred)
-{
-  return impl_->wait_until(lock, until, pred);
-}
-
-std::mutex &
-ClockConditionalVariable::mutex()
-{
-  return impl_->mutex();
-}
-
 }  // namespace rclcpp

rclcpp/src/rclcpp/context.cpp

@@ -14,7 +14,6 @@
 
 #include "rclcpp/context.hpp"
 
-#include <map>
 #include <memory>
 #include <mutex>
 #include <sstream>
@@ -143,52 +142,11 @@ rclcpp_logging_output_handler(
 }
 }  // extern "C"
 
-/**
- * Global storage for pre and post shutdown recursive mutexes.
- * Note, this is a ABI compatibility hack.
- */
-class MutexLookup
-{
-  std::mutex m;
-
-  struct MutexHolder
-  {
-    std::recursive_mutex on_shutdown_callbacks_mutex_;
-    std::recursive_mutex pre_shutdown_callbacks_mutex_;
-  };
-
-  std::map<const Context *, std::unique_ptr<MutexHolder>> mutexMap;
-
-public:
-  MutexHolder & getMutexes(const Context *forContext)
-  {
-    auto it = mutexMap.find(forContext);
-    if(it == mutexMap.end()) {
-      it = mutexMap.emplace(forContext, std::make_unique<MutexHolder>()).first;
-    }
-
-    return *(it->second);
-  }
-
-  /**
-   * Only supposed to be called on deletion of context
-   */
-  void removeMutexes(const Context *forContext)
-  {
-    mutexMap.erase(forContext);
-  }
-};
-
-MutexLookup mutexStorage;
-
 Context::Context()
 : rcl_context_(nullptr),
   shutdown_reason_(""),
   logging_mutex_(nullptr)
-{
-  // allocate mutexes
-  mutexStorage.getMutexes(this);
-}
+{}
 
 Context::~Context()
 {
@@ -207,9 +165,6 @@ Context::~Context()
   } catch (...) {
     RCLCPP_ERROR(rclcpp::get_logger("rclcpp"), "unhandled exception in ~Context()");
   }
-
-  // delete mutexes
-  mutexStorage.removeMutexes(this);
 }
 
 RCLCPP_LOCAL
@@ -257,27 +212,28 @@ Context::init(
   }
   rcl_context_.reset(context, __delete_context);
 
-  try {
-    if (init_options.auto_initialize_logging()) {
-      logging_mutex_ = get_global_logging_mutex();
-      std::lock_guard<std::recursive_mutex> guard(*logging_mutex_);
-      size_t & count = get_logging_reference_count();
-      if (0u == count) {
-        ret = rcl_logging_configure_with_output_handler(
-          &rcl_context_->global_arguments,
-          rcl_init_options_get_allocator(init_options.get_rcl_init_options()),
-          rclcpp_logging_output_handler);
-        if (RCL_RET_OK != ret) {
-          rclcpp::exceptions::throw_from_rcl_error(ret, "failed to configure logging");
-        }
-      } else {
-        RCLCPP_WARN(
-          rclcpp::get_logger("rclcpp"),
-          "logging was initialized more than once");
+  if (init_options.auto_initialize_logging()) {
+    logging_mutex_ = get_global_logging_mutex();
+    std::lock_guard<std::recursive_mutex> guard(*logging_mutex_);
+    size_t & count = get_logging_reference_count();
+    if (0u == count) {
+      ret = rcl_logging_configure_with_output_handler(
+        &rcl_context_->global_arguments,
+        rcl_init_options_get_allocator(init_options.get_rcl_init_options()),
+        rclcpp_logging_output_handler);
+      if (RCL_RET_OK != ret) {
+        rcl_context_.reset();
+        rclcpp::exceptions::throw_from_rcl_error(ret, "failed to configure logging");
       }
-      ++count;
+    } else {
+      RCLCPP_WARN(
+        rclcpp::get_logger("rclcpp"),
+        "logging was initialized more than once");
     }
+    ++count;
+  }
 
+  try {
     std::vector<std::string> unparsed_ros_arguments = detail::get_unparsed_ros_arguments(
       argc, argv, &(rcl_context_->global_arguments), rcl_get_default_allocator());
     if (!unparsed_ros_arguments.empty()) {
@@ -355,17 +311,9 @@ Context::shutdown(const std::string & reason)
 
   // call each pre-shutdown callback
   {
-    std::lock_guard<std::recursive_mutex> lock{mutexStorage.getMutexes(
-        this).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)();
     }
   }
 
@@ -378,17 +326,9 @@ Context::shutdown(const std::string & reason)
   shutdown_reason_ = reason;
   // call each shutdown callback
   {
-    std::lock_guard<std::recursive_mutex> lock(mutexStorage.getMutexes(
-      this).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)();
     }
   }
 
@@ -459,12 +399,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(mutexStorage.getMutexes(
-      this).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(mutexStorage.getMutexes(
-      this).on_shutdown_callbacks_mutex_);
+    std::lock_guard<std::mutex> lock(on_shutdown_callbacks_mutex_);
     on_shutdown_callbacks_.emplace_back(callback_shared_ptr);
   }
 
@@ -484,7 +422,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,7 +433,6 @@ Context::remove_shutdown_callback(
         return false;
       }
       callback_vector.erase(iter);
-
       return true;
     };
 
@@ -503,11 +440,9 @@ Context::remove_shutdown_callback(
     shutdown_type == ShutdownType::pre_shutdown || shutdown_type == ShutdownType::on_shutdown);
 
   if constexpr (shutdown_type == ShutdownType::pre_shutdown) {
-    return remove_callback(mutexStorage.getMutexes(this).pre_shutdown_callbacks_mutex_,
-      pre_shutdown_callbacks_);
+    return remove_callback(pre_shutdown_callbacks_mutex_, pre_shutdown_callbacks_);
   } else {
-    return remove_callback(mutexStorage.getMutexes(this).on_shutdown_callbacks_mutex_,
-      on_shutdown_callbacks_);
+    return remove_callback(on_shutdown_callbacks_mutex_, on_shutdown_callbacks_);
   }
 }
 
@@ -528,7 +463,7 @@ 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;
       for (auto & callback : callback_set) {
         callbacks.push_back(*callback);
@@ -540,11 +475,9 @@ Context::get_shutdown_callback() const
     shutdown_type == ShutdownType::pre_shutdown || shutdown_type == ShutdownType::on_shutdown);
 
   if constexpr (shutdown_type == ShutdownType::pre_shutdown) {
-    return get_callback_vector(mutexStorage.getMutexes(this).pre_shutdown_callbacks_mutex_,
-      pre_shutdown_callbacks_);
+    return get_callback_vector(pre_shutdown_callbacks_mutex_, pre_shutdown_callbacks_);
   } else {
-    return get_callback_vector(mutexStorage.getMutexes(this).on_shutdown_callbacks_mutex_,
-      on_shutdown_callbacks_);
+    return get_callback_vector(on_shutdown_callbacks_mutex_, on_shutdown_callbacks_);
   }
 }
 

rclcpp/src/rclcpp/create_generic_service.cpp

@@ -1,49 +0,0 @@
-// Copyright 2024 Sony Group Corporation.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <string>
-#include <memory>
-
-#include "rclcpp/create_generic_service.hpp"
-#include "rclcpp/generic_service.hpp"
-
-namespace rclcpp
-{
-rclcpp::GenericService::SharedPtr
-create_generic_service(
-  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,
-  GenericServiceCallback any_callback,
-  const rclcpp::QoS & qos,
-  rclcpp::CallbackGroup::SharedPtr group)
-{
-  rcl_service_options_t options = rcl_service_get_default_options();
-  options.qos = qos.get_rmw_qos_profile();
-
-  auto srv = rclcpp::GenericService::make_shared(
-    node_base.get(),
-    node_graph,
-    service_name,
-    service_type,
-    any_callback,
-    options);
-
-  auto srv_base_ptr = std::dynamic_pointer_cast<rclcpp::ServiceBase>(srv);
-  node_services->add_service(srv_base_ptr, group);
-  return srv;
-}
-}  // namespace rclcpp

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

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

rclcpp/src/rclcpp/detail/utilities.cpp

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

rclcpp/src/rclcpp/exceptions/exceptions.cpp

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

rclcpp/src/rclcpp/executor.cpp

@@ -66,7 +66,7 @@ Executor::Executor(const rclcpp::ExecutorOptions & options)
   notify_waitable_(std::make_shared<rclcpp::executors::ExecutorNotifyWaitable>(
       [this]() {
         this->entities_need_rebuild_.store(true);
-      }, options.context)),
+      })),
   entities_need_rebuild_(true),
   collector_(notify_waitable_),
   wait_set_({}, {}, {}, {}, {}, {}, options.context),
@@ -84,9 +84,7 @@ Executor::Executor(const rclcpp::ExecutorOptions & options)
   notify_waitable_->add_guard_condition(interrupt_guard_condition_);
   notify_waitable_->add_guard_condition(shutdown_guard_condition_);
 
-  // we need to initially rebuild the collection,
-  // so that the notify_waitable_ is added
-  collect_entities();
+  wait_set_.add_waitable(notify_waitable_);
 }
 
 Executor::~Executor()
@@ -131,7 +129,7 @@ Executor::~Executor()
 }
 
 void
-Executor::handle_updated_entities(bool notify)
+Executor::trigger_entity_recollect(bool notify)
 {
   this->entities_need_rebuild_.store(true);
 
@@ -169,17 +167,18 @@ Executor::get_automatically_added_callback_groups_from_nodes()
 void
 Executor::add_callback_group(
   rclcpp::CallbackGroup::SharedPtr group_ptr,
-  [[maybe_unused]] rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
   bool notify)
 {
+  (void) node_ptr;
   this->collector_.add_callback_group(group_ptr);
 
   try {
-    this->handle_updated_entities(notify);
+    this->trigger_entity_recollect(notify);
   } catch (const rclcpp::exceptions::RCLError & ex) {
     throw std::runtime_error(
             std::string(
-              "Failed to handle entities update on callback group add: ") + ex.what());
+              "Failed to trigger guard condition on callback group add: ") + ex.what());
   }
 }
 
@@ -189,11 +188,11 @@ Executor::add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_pt
   this->collector_.add_node(node_ptr);
 
   try {
-    this->handle_updated_entities(notify);
+    this->trigger_entity_recollect(notify);
   } catch (const rclcpp::exceptions::RCLError & ex) {
     throw std::runtime_error(
             std::string(
-              "Failed to handle entities update on node add: ") + ex.what());
+              "Failed to trigger guard condition on node add: ") + ex.what());
   }
 }
 
@@ -205,11 +204,11 @@ Executor::remove_callback_group(
   this->collector_.remove_callback_group(group_ptr);
 
   try {
-    this->handle_updated_entities(notify);
+    this->trigger_entity_recollect(notify);
   } catch (const rclcpp::exceptions::RCLError & ex) {
     throw std::runtime_error(
             std::string(
-              "Failed to handle entities update on callback group remove: ") + ex.what());
+              "Failed to trigger guard condition on callback group remove: ") + ex.what());
   }
 }
 
@@ -225,11 +224,11 @@ Executor::remove_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node
   this->collector_.remove_node(node_ptr);
 
   try {
-    this->handle_updated_entities(notify);
+    this->trigger_entity_recollect(notify);
   } catch (const rclcpp::exceptions::RCLError & ex) {
     throw std::runtime_error(
             std::string(
-              "Failed to handle entities update on node remove: ") + ex.what());
+              "Failed to trigger guard condition on node remove: ") + ex.what());
   }
 }
 
@@ -276,7 +275,7 @@ Executor::spin_until_future_complete_impl(
   if (spinning.exchange(true)) {
     throw std::runtime_error("spin_until_future_complete() called while already spinning");
   }
-  RCPPUTILS_SCOPE_EXIT(wait_result_.reset();this->spinning.store(false););
+  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false); );
   while (rclcpp::ok(this->context_) && spinning.load()) {
     // Do one item of work.
     spin_once_impl(timeout_left);
@@ -365,69 +364,26 @@ Executor::spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive)
   if (spinning.exchange(true)) {
     throw std::runtime_error("spin_some() called while already spinning");
   }
-  RCPPUTILS_SCOPE_EXIT(wait_result_.reset();this->spinning.store(false););
+  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false); );
 
-  // clear the wait result and wait for work without blocking to collect the work
-  // for the first time
-  // both spin_some and spin_all wait for work at the beginning
-  wait_result_.reset();
-  wait_for_work(std::chrono::milliseconds(0));
-  bool entity_states_fully_polled = true;
-
-  if (entities_need_rebuild_) {
-    // if the last wait triggered a collection rebuild, we need to call
-    // wait_for_work once more, in order to do a collection rebuild and collect
-    // events from the just added entities
-    entity_states_fully_polled = false;
-  }
-
-  // The logic of this while loop is as follows:
-  //
-  // - while not shutdown, and spinning (not canceled), and not max duration reached...
-  // - try to get an executable item to execute, and execute it if available
-  // - otherwise, reset the wait result, and ...
-  // - if there was no work available just after waiting, break the loop unconditionally
-  //   - this is appropriate for both spin_some and spin_all which use this function
-  // - else if exhaustive = true, then wait for work again
-  //   - this is only used for spin_all and not spin_some
-  // - else break
-  //   - this only occurs with spin_some
-  //
-  // The logic of this loop is subtle and should be carefully changed if at all.
-  // See also:
-  //   https://github.com/ros2/rclcpp/issues/2508
-  //   https://github.com/ros2/rclcpp/pull/2517
   while (rclcpp::ok(context_) && spinning.load() && max_duration_not_elapsed()) {
+    if (!wait_result_.has_value()) {
+      wait_for_work(std::chrono::milliseconds(0));
+    }
+
     AnyExecutable any_exec;
     if (get_next_ready_executable(any_exec)) {
       execute_any_executable(any_exec);
-      // during the execution some entity might got ready therefore we need
-      // to repoll the states of all entities
-      entity_states_fully_polled = false;
     } else {
-      // if nothing is ready, reset the result to clear it
+      // If nothing is ready, reset the result to signal we are
+      // ready to wait again
       wait_result_.reset();
+    }
 
-      if (entity_states_fully_polled) {
-        // there was no work after just waiting, always exit in this case
-        // before the exhaustive condition can be checked
-        break;
-      }
-
-      if (exhaustive) {
-        // if exhaustive, wait for work again
-        // this only happens for spin_all; spin_some only waits at the start
-        wait_for_work(std::chrono::milliseconds(0));
-        entity_states_fully_polled = true;
-        if (entities_need_rebuild_) {
-          // if the last wait triggered a collection rebuild, we need to call
-          // wait_for_work once more, in order to do a collection rebuild and
-          // collect events from the just added entities
-          entity_states_fully_polled = false;
-        }
-      } else {
-        break;
-      }
+    if (!wait_result_.has_value() && !exhaustive) {
+      // In the case of spin some, then we can exit
+      // In the case of spin all, then we will allow ourselves to wait again.
+      break;
     }
   }
 }
@@ -447,7 +403,7 @@ Executor::spin_once(std::chrono::nanoseconds timeout)
   if (spinning.exchange(true)) {
     throw std::runtime_error("spin_once() called while already spinning");
   }
-  RCPPUTILS_SCOPE_EXIT(wait_result_.reset();this->spinning.store(false););
+  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false); );
   spin_once_impl(timeout);
 }
 
@@ -584,7 +540,6 @@ Executor::execute_subscription(rclcpp::SubscriptionBase::SharedPtr subscription)
                 "rcl_return_loaned_message_from_subscription() failed for subscription on topic "
                 "'%s': %s",
                 subscription->get_topic_name(), rcl_get_error_string().str);
-              rcl_reset_error();
             }
             loaned_msg = nullptr;
           }
@@ -748,14 +703,11 @@ Executor::wait_for_work(std::chrono::nanoseconds timeout)
 
   {
     std::lock_guard<std::mutex> guard(mutex_);
-
     if (this->entities_need_rebuild_.exchange(false) || current_collection_.empty()) {
       this->collect_entities();
     }
   }
-
   this->wait_result_.emplace(wait_set_.wait(timeout));
-
   if (!this->wait_result_ || this->wait_result_->kind() == WaitResultKind::Empty) {
     RCUTILS_LOG_WARN_NAMED(
       "rclcpp",

rclcpp/src/rclcpp/executor_options.cpp

@@ -1,55 +0,0 @@
-// Copyright 2024 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "rclcpp/executor_options.hpp"
-
-using rclcpp::ExecutorOptions;
-
-namespace rclcpp
-{
-
-class ExecutorOptionsImplementation {};
-
-}  // namespace rclcpp
-
-ExecutorOptions::ExecutorOptions()
-: memory_strategy(rclcpp::memory_strategies::create_default_strategy()),
-  context(rclcpp::contexts::get_global_default_context()),
-  max_conditions(0),
-  impl_(nullptr)
-{}
-
-ExecutorOptions::~ExecutorOptions()
-{}
-
-ExecutorOptions::ExecutorOptions(const ExecutorOptions & other)
-{
-  *this = other;
-}
-
-ExecutorOptions & ExecutorOptions::operator=(const ExecutorOptions & other)
-{
-  if (this == &other) {
-    return *this;
-  }
-
-  this->memory_strategy = other.memory_strategy;
-  this->context = other.context;
-  this->max_conditions = other.max_conditions;
-  if (nullptr != other.impl_) {
-    this->impl_ = std::make_unique<ExecutorOptionsImplementation>(*other.impl_);
-  }
-
-  return *this;
-}

rclcpp/src/rclcpp/executors/executor_notify_waitable.cpp

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

rclcpp/src/rclcpp/executors/multi_threaded_executor.cpp

@@ -55,7 +55,7 @@ MultiThreadedExecutor::spin()
   if (spinning.exchange(true)) {
     throw std::runtime_error("spin() called while already spinning");
   }
-  RCPPUTILS_SCOPE_EXIT(wait_result_.reset();this->spinning.store(false););
+  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false););
   std::vector<std::thread> threads;
   size_t thread_id = 0;
   {
@@ -79,8 +79,9 @@ MultiThreadedExecutor::get_number_of_threads()
 }
 
 void
-MultiThreadedExecutor::run([[maybe_unused]] size_t this_thread_number)
+MultiThreadedExecutor::run(size_t this_thread_number)
 {
+  (void)this_thread_number;
   while (rclcpp::ok(this->context_) && spinning.load()) {
     rclcpp::AnyExecutable any_exec;
     {

rclcpp/src/rclcpp/executors/single_threaded_executor.cpp

@@ -30,7 +30,7 @@ SingleThreadedExecutor::spin()
   if (spinning.exchange(true)) {
     throw std::runtime_error("spin() called while already spinning");
   }
-  RCPPUTILS_SCOPE_EXIT(wait_result_.reset();this->spinning.store(false););
+  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false); );
 
   // Clear any previous result and rebuild the waitset
   this->wait_result_.reset();

rclcpp/src/rclcpp/executors/static_single_threaded_executor.cpp

@@ -110,29 +110,10 @@ StaticSingleThreadedExecutor::spin_once_impl(std::chrono::nanoseconds timeout)
 std::optional<rclcpp::WaitResult<rclcpp::WaitSet>>
 StaticSingleThreadedExecutor::collect_and_wait(std::chrono::nanoseconds timeout)
 {
-  // we need to make sure that callback groups don't get out of scope
-  // during the wait. As in jazzy, they are not covered by the DynamicStorage,
-  // we explicitly hold them here as a bugfix
-  std::vector<rclcpp::CallbackGroup::SharedPtr> cbgs;
-
   if (this->entities_need_rebuild_.exchange(false) || current_collection_.empty()) {
     this->collect_entities();
   }
-
-  auto callback_groups = this->collector_.get_all_callback_groups();
-  cbgs.resize(callback_groups.size());
-  for(const auto & w_ptr : callback_groups) {
-    auto shr_ptr = w_ptr.lock();
-    if(shr_ptr) {
-      cbgs.push_back(std::move(shr_ptr));
-    }
-  }
-
   auto wait_result = wait_set_.wait(std::chrono::nanoseconds(timeout));
-
-  // drop references to the callback groups, before trying to execute anything
-  cbgs.clear();
-
   if (wait_result.kind() == WaitResultKind::Empty) {
     RCUTILS_LOG_WARN_NAMED(
       "rclcpp",

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

@@ -52,36 +52,30 @@ EventsExecutor::EventsExecutor(
   timers_manager_ =
     std::make_shared<rclcpp::experimental::TimersManager>(context_, timer_on_ready_cb);
 
-  entities_need_rebuild_ = false;
+  this->current_entities_collection_ =
+    std::make_shared<rclcpp::executors::ExecutorEntitiesCollection>();
 
-  this->setup_notify_waitable();
-
-  // Ensure that the entities collection is empty (the base class may have added elements
-  // that we are not interested in)
-  this->current_collection_.clear();
-
-  // Make sure that the notify waitable is immediately added to the collection
-  // to avoid missing events
-  this->add_notify_waitable_to_collection(current_collection_.waitables);
-}
-
-void
-EventsExecutor::setup_notify_waitable()
-{
-  // The base class already created this object but the events-executor
-  // needs different callbacks.
-  assert(notify_waitable_ && "The notify waitable should have already been constructed");
-
-  notify_waitable_->set_execute_callback(
+  notify_waitable_ = std::make_shared<rclcpp::executors::ExecutorNotifyWaitable>(
     [this]() {
       // This callback is invoked when:
       // - the interrupt or shutdown guard condition is triggered:
       //    ---> we need to wake up the executor so that it can terminate
       // - a node or callback group guard condition is triggered:
       //    ---> the entities collection is changed, we need to update callbacks
-      this->handle_updated_entities(false);
+      notify_waitable_event_pushed_ = false;
+      this->refresh_current_collection_from_callback_groups();
     });
 
+  // Make sure that the notify waitable is immediately added to the collection
+  // to avoid missing events
+  this->add_notify_waitable_to_collection(current_entities_collection_->waitables);
+
+  notify_waitable_->add_guard_condition(interrupt_guard_condition_);
+  notify_waitable_->add_guard_condition(shutdown_guard_condition_);
+
+  notify_waitable_->set_on_ready_callback(
+    this->create_waitable_callback(notify_waitable_.get()));
+
   auto notify_waitable_entity_id = notify_waitable_.get();
   notify_waitable_->set_on_ready_callback(
     [this, notify_waitable_entity_id](size_t num_events, int waitable_data) {
@@ -91,7 +85,7 @@ EventsExecutor::setup_notify_waitable()
       // For the same reason, if an event of this type has already been pushed but it has not been
       // processed yet, we avoid pushing additional events.
       (void)num_events;
-      if (entities_need_rebuild_.exchange(true)) {
+      if (notify_waitable_event_pushed_.exchange(true)) {
         return;
       }
 
@@ -99,6 +93,9 @@ EventsExecutor::setup_notify_waitable()
       {notify_waitable_entity_id, nullptr, waitable_data, ExecutorEventType::WAITABLE_EVENT, 1};
       this->events_queue_->enqueue(event);
     });
+
+  this->entities_collector_ =
+    std::make_shared<rclcpp::executors::ExecutorEntitiesCollector>(notify_waitable_);
 }
 
 EventsExecutor::~EventsExecutor()
@@ -167,14 +164,6 @@ EventsExecutor::spin_some_impl(std::chrono::nanoseconds max_duration, bool exhau
       return false;
     };
 
-  // If this spin is not exhaustive (e.g. spin_some), we need to explicitly check
-  // if entities need to be rebuilt here rather than letting the notify waitable event do it.
-  // A non-exhaustive spin would not check for work a second time, thus delaying the execution
-  // of some entities to the next invocation of spin.
-  if (!exhaustive) {
-    this->handle_updated_entities(false);
-  }
-
   // Get the number of events and timers ready at start
   const size_t ready_events_at_start = events_queue_->size();
   size_t executed_events = 0;
@@ -240,6 +229,46 @@ EventsExecutor::spin_once_impl(std::chrono::nanoseconds timeout)
   }
 }
 
+void
+EventsExecutor::add_node(
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify)
+{
+  // This field is unused because we don't have to wake up the executor when a node is added.
+  (void) notify;
+
+  // Add node to entities collector
+  this->entities_collector_->add_node(node_ptr);
+
+  this->refresh_current_collection_from_callback_groups();
+}
+
+void
+EventsExecutor::add_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify)
+{
+  this->add_node(node_ptr->get_node_base_interface(), notify);
+}
+
+void
+EventsExecutor::remove_node(
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify)
+{
+  // This field is unused because we don't have to wake up the executor when a node is removed.
+  (void)notify;
+
+  // Remove node from entities collector.
+  // This will result in un-setting all the event callbacks from its entities.
+  // After this function returns, this executor will not receive any more events associated
+  // to these entities.
+  this->entities_collector_->remove_node(node_ptr);
+
+  this->refresh_current_collection_from_callback_groups();
+}
+
+void
+EventsExecutor::remove_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify)
+{
+  this->remove_node(node_ptr->get_node_base_interface(), notify);
+}
 
 void
 EventsExecutor::execute_event(const ExecutorEvent & event)
@@ -249,9 +278,10 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
       {
         rclcpp::ClientBase::SharedPtr client;
         {
+          std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
           client = this->retrieve_entity(
             static_cast<const rcl_client_t *>(event.entity_key),
-            current_collection_.clients);
+            current_entities_collection_->clients);
         }
         if (client) {
           for (size_t i = 0; i < event.num_events; i++) {
@@ -265,9 +295,10 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
       {
         rclcpp::SubscriptionBase::SharedPtr subscription;
         {
+          std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
           subscription = this->retrieve_entity(
             static_cast<const rcl_subscription_t *>(event.entity_key),
-            current_collection_.subscriptions);
+            current_entities_collection_->subscriptions);
         }
         if (subscription) {
           for (size_t i = 0; i < event.num_events; i++) {
@@ -280,9 +311,10 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
       {
         rclcpp::ServiceBase::SharedPtr service;
         {
+          std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
           service = this->retrieve_entity(
             static_cast<const rcl_service_t *>(event.entity_key),
-            current_collection_.services);
+            current_entities_collection_->services);
         }
         if (service) {
           for (size_t i = 0; i < event.num_events; i++) {
@@ -302,9 +334,10 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
       {
         rclcpp::Waitable::SharedPtr waitable;
         {
+          std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
           waitable = this->retrieve_entity(
             static_cast<const rclcpp::Waitable *>(event.entity_key),
-            current_collection_.waitables);
+            current_entities_collection_->waitables);
         }
         if (waitable) {
           for (size_t i = 0; i < event.num_events; i++) {
@@ -318,21 +351,61 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
 }
 
 void
-EventsExecutor::handle_updated_entities([[maybe_unused]] bool notify)
+EventsExecutor::add_callback_group(
+  rclcpp::CallbackGroup::SharedPtr group_ptr,
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
+  bool notify)
 {
-  // Do not rebuild if we don't need to.
-  // A rebuild event could be generated, but then
-  // this function could end up being called from somewhere else
-  // before that event gets processed, for example if
-  // a node or callback group is manually added to the executor.
-  const bool notify_waitable_triggered = entities_need_rebuild_.exchange(false);
-  if (!notify_waitable_triggered && !this->collector_.has_pending()) {
-    return;
-  }
+  // This field is unused because we don't have to wake up
+  // the executor when a callback group is added.
+  (void)notify;
+  (void)node_ptr;
 
+  this->entities_collector_->add_callback_group(group_ptr);
+
+  this->refresh_current_collection_from_callback_groups();
+}
+
+void
+EventsExecutor::remove_callback_group(
+  rclcpp::CallbackGroup::SharedPtr group_ptr, bool notify)
+{
+  // This field is unused because we don't have to wake up
+  // the executor when a callback group is removed.
+  (void)notify;
+
+  this->entities_collector_->remove_callback_group(group_ptr);
+
+  this->refresh_current_collection_from_callback_groups();
+}
+
+std::vector<rclcpp::CallbackGroup::WeakPtr>
+EventsExecutor::get_all_callback_groups()
+{
+  this->entities_collector_->update_collections();
+  return this->entities_collector_->get_all_callback_groups();
+}
+
+std::vector<rclcpp::CallbackGroup::WeakPtr>
+EventsExecutor::get_manually_added_callback_groups()
+{
+  this->entities_collector_->update_collections();
+  return this->entities_collector_->get_manually_added_callback_groups();
+}
+
+std::vector<rclcpp::CallbackGroup::WeakPtr>
+EventsExecutor::get_automatically_added_callback_groups_from_nodes()
+{
+  this->entities_collector_->update_collections();
+  return this->entities_collector_->get_automatically_added_callback_groups();
+}
+
+void
+EventsExecutor::refresh_current_collection_from_callback_groups()
+{
   // Build the new collection
-  this->collector_.update_collections();
-  auto callback_groups = this->collector_.get_all_callback_groups();
+  this->entities_collector_->update_collections();
+  auto callback_groups = this->entities_collector_->get_all_callback_groups();
   rclcpp::executors::ExecutorEntitiesCollection new_collection;
   rclcpp::executors::build_entities_collection(callback_groups, new_collection);
 
@@ -342,11 +415,14 @@ EventsExecutor::handle_updated_entities([[maybe_unused]] bool notify)
   // We could explicitly check for the notify waitable ID when we receive a waitable event
   // but I think that it's better if the waitable was in the collection and it could be
   // retrieved in the "standard" way.
-  // To do it, we need to add the notify waitable as an entry in the new collection
-  // such that it's neither added or removed (it should have already been added
-  // to the current collection in the constructor)
+  // To do it, we need to add the notify waitable as an entry in both the new and
+  // current collections such that it's neither added or removed.
   this->add_notify_waitable_to_collection(new_collection.waitables);
 
+  // Acquire lock before modifying the current collection
+  std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
+  this->add_notify_waitable_to_collection(current_entities_collection_->waitables);
+
   this->refresh_current_collection(new_collection);
 }
 
@@ -355,19 +431,14 @@ EventsExecutor::refresh_current_collection(
   const rclcpp::executors::ExecutorEntitiesCollection & new_collection)
 {
   // Acquire lock before modifying the current collection
-  std::lock_guard<std::mutex> guard(mutex_);
+  std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
 
-  // Remove expired entities to ensure re-initialized objects
-  // are updated. This fixes issues with stale state entities.
-  // See: https://github.com/ros2/rclcpp/pull/2586
-  current_collection_.remove_expired_entities();
-
-  current_collection_.timers.update(
+  current_entities_collection_->timers.update(
     new_collection.timers,
     [this](rclcpp::TimerBase::SharedPtr timer) {timers_manager_->add_timer(timer);},
     [this](rclcpp::TimerBase::SharedPtr timer) {timers_manager_->remove_timer(timer);});
 
-  current_collection_.subscriptions.update(
+  current_entities_collection_->subscriptions.update(
     new_collection.subscriptions,
     [this](auto subscription) {
       subscription->set_on_new_message_callback(
@@ -376,7 +447,7 @@ EventsExecutor::refresh_current_collection(
     },
     [](auto subscription) {subscription->clear_on_new_message_callback();});
 
-  current_collection_.clients.update(
+  current_entities_collection_->clients.update(
     new_collection.clients,
     [this](auto client) {
       client->set_on_new_response_callback(
@@ -385,7 +456,7 @@ EventsExecutor::refresh_current_collection(
     },
     [](auto client) {client->clear_on_new_response_callback();});
 
-  current_collection_.services.update(
+  current_entities_collection_->services.update(
     new_collection.services,
     [this](auto service) {
       service->set_on_new_request_callback(
@@ -396,26 +467,18 @@ EventsExecutor::refresh_current_collection(
 
   // DO WE NEED THIS? WE ARE NOT DOING ANYTHING WITH GUARD CONDITIONS
   /*
-  current_collection_.guard_conditions.update(new_collection.guard_conditions,
+  current_entities_collection_->guard_conditions.update(new_collection.guard_conditions,
     [](auto guard_condition) {(void)guard_condition;},
     [](auto guard_condition) {guard_condition->set_on_trigger_callback(nullptr);});
   */
 
-  current_collection_.waitables.update(
+  current_entities_collection_->waitables.update(
     new_collection.waitables,
     [this](auto waitable) {
       waitable->set_on_ready_callback(
         this->create_waitable_callback(waitable.get()));
-      for (const auto & t : waitable->get_timers()) {
-        timers_manager_->add_timer(t);
-      }
     },
-    [this](auto waitable) {
-      waitable->clear_on_ready_callback();
-      for (const auto & t : waitable->get_timers()) {
-        timers_manager_->remove_timer(t);
-      }
-    });
+    [](auto waitable) {waitable->clear_on_ready_callback();});
 }
 
 std::function<void(size_t)>

rclcpp/src/rclcpp/generic_client.cpp

@@ -31,31 +31,22 @@ GenericClient::GenericClient(
   rcl_client_options_t & client_options)
 : ClientBase(node_base, node_graph)
 {
-  const rosidl_service_type_support_t * service_ts;
-  try {
-    ts_lib_ = get_typesupport_library(
-      service_type, "rosidl_typesupport_cpp");
+  ts_lib_ = get_typesupport_library(
+    service_type, "rosidl_typesupport_cpp");
 
-    service_ts = get_service_typesupport_handle(
-      service_type, "rosidl_typesupport_cpp", *ts_lib_);
+  auto service_ts_ = get_service_typesupport_handle(
+    service_type, "rosidl_typesupport_cpp", *ts_lib_);
 
-    auto response_type_support_intro = get_message_typesupport_handle(
-      service_ts->response_typesupport,
-      rosidl_typesupport_introspection_cpp::typesupport_identifier);
-    response_members_ = static_cast<const rosidl_typesupport_introspection_cpp::MessageMembers *>(
-      response_type_support_intro->data);
-  } catch (std::runtime_error & err) {
-    RCLCPP_ERROR(
-      rclcpp::get_node_logger(node_handle_.get()).get_child("rclcpp"),
-      "Invalid service type: %s",
-      err.what());
-    throw rclcpp::exceptions::InvalidServiceTypeError(err.what());
-  }
+  auto response_type_support_intro = get_message_typesupport_handle(
+    service_ts_->response_typesupport,
+    rosidl_typesupport_introspection_cpp::typesupport_identifier);
+  response_members_ = static_cast<const rosidl_typesupport_introspection_cpp::MessageMembers *>(
+    response_type_support_intro->data);
 
   rcl_ret_t ret = rcl_client_init(
     this->get_client_handle().get(),
     this->get_rcl_node_handle(),
-    service_ts,
+    service_ts_,
     service_name.c_str(),
     &client_options);
   if (ret != RCL_RET_OK) {
@@ -109,13 +100,6 @@ GenericClient::handle_response(
   if (std::holds_alternative<Promise>(value)) {
     auto & promise = std::get<Promise>(value);
     promise.set_value(std::move(response));
-  } else if (std::holds_alternative<CallbackTypeValueVariant>(value)) {
-    auto & inner = std::get<CallbackTypeValueVariant>(value);
-    const auto & callback = std::get<CallbackType>(inner);
-    auto & promise = std::get<Promise>(inner);
-    auto & future = std::get<SharedFuture>(inner);
-    promise.set_value(std::move(response));
-    callback(std::move(future));
   }
 }
 
@@ -135,18 +119,6 @@ GenericClient::remove_pending_request(int64_t request_id)
   return pending_requests_.erase(request_id) != 0u;
 }
 
-bool
-GenericClient::remove_pending_request(const FutureAndRequestId & future)
-{
-  return this->remove_pending_request(future.request_id);
-}
-
-bool
-GenericClient::remove_pending_request(const SharedFutureAndRequestId & future)
-{
-  return this->remove_pending_request(future.request_id);
-}
-
 std::optional<GenericClient::CallbackInfoVariant>
 GenericClient::get_and_erase_pending_request(int64_t request_number)
 {

rclcpp/src/rclcpp/generic_service.cpp

@@ -1,172 +0,0 @@
-// Copyright 2024 Sony Group Corporation.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "rclcpp/generic_service.hpp"
-
-namespace rclcpp
-{
-GenericService::GenericService(
-  std::shared_ptr<rcl_node_t> node_handle,
-  const std::string & service_name,
-  const std::string & service_type,
-  GenericServiceCallback any_callback,
-  rcl_service_options_t & service_options)
-: ServiceBase(node_handle),
-  any_callback_(any_callback)
-{
-  const rosidl_service_type_support_t * service_ts;
-  try {
-    ts_lib_ = get_typesupport_library(
-      service_type, "rosidl_typesupport_cpp");
-
-    service_ts = get_service_typesupport_handle(
-      service_type, "rosidl_typesupport_cpp", *ts_lib_);
-
-    auto request_type_support_intro = get_message_typesupport_handle(
-      service_ts->request_typesupport,
-      rosidl_typesupport_introspection_cpp::typesupport_identifier);
-    request_members_ = static_cast<const rosidl_typesupport_introspection_cpp::MessageMembers *>(
-      request_type_support_intro->data);
-
-    auto response_type_support_intro = get_message_typesupport_handle(
-      service_ts->response_typesupport,
-      rosidl_typesupport_introspection_cpp::typesupport_identifier);
-    response_members_ = static_cast<const rosidl_typesupport_introspection_cpp::MessageMembers *>(
-      response_type_support_intro->data);
-  } catch (std::runtime_error & err) {
-    RCLCPP_ERROR(
-      rclcpp::get_node_logger(node_handle_.get()).get_child("rclcpp"),
-      "Invalid service type: %s",
-      err.what());
-    throw rclcpp::exceptions::InvalidServiceTypeError(err.what());
-  }
-
-  // rcl does the static memory allocation here
-  service_handle_ = std::shared_ptr<rcl_service_t>(
-    new rcl_service_t, [handle = node_handle_, service_name](rcl_service_t * service)
-    {
-      if (rcl_service_fini(service, handle.get()) != RCL_RET_OK) {
-        RCLCPP_ERROR(
-          rclcpp::get_node_logger(handle.get()).get_child("rclcpp"),
-          "Error in destruction of rcl service handle: %s",
-          rcl_get_error_string().str);
-        rcl_reset_error();
-      }
-      delete service;
-    });
-  *service_handle_.get() = rcl_get_zero_initialized_service();
-
-  rcl_ret_t ret = rcl_service_init(
-    service_handle_.get(),
-    node_handle.get(),
-    service_ts,
-    service_name.c_str(),
-    &service_options);
-  if (ret != RCL_RET_OK) {
-    if (ret == RCL_RET_SERVICE_NAME_INVALID) {
-      auto rcl_node_handle = get_rcl_node_handle();
-      // this will throw on any validation problem
-      rcl_reset_error();
-      expand_topic_or_service_name(
-        service_name,
-        rcl_node_get_name(rcl_node_handle),
-        rcl_node_get_namespace(rcl_node_handle),
-        true);
-    }
-
-    rclcpp::exceptions::throw_from_rcl_error(ret, "could not create service");
-  }
-  TRACETOOLS_TRACEPOINT(
-    rclcpp_service_callback_added,
-    static_cast<const void *>(get_service_handle().get()),
-    static_cast<const void *>(&any_callback_));
-#ifndef TRACETOOLS_DISABLED
-  any_callback_.register_callback_for_tracing();
-#endif
-}
-
-bool
-GenericService::take_request(
-  SharedRequest request_out,
-  rmw_request_id_t & request_id_out)
-{
-  request_out = create_request();
-  return this->take_type_erased_request(request_out.get(), request_id_out);
-}
-
-std::shared_ptr<void>
-GenericService::create_request()
-{
-  Request request = new uint8_t[request_members_->size_of_];
-  request_members_->init_function(request, rosidl_runtime_cpp::MessageInitialization::ZERO);
-  return std::shared_ptr<void>(
-    request,
-    [this](void * p)
-    {
-      request_members_->fini_function(p);
-      delete[] reinterpret_cast<uint8_t *>(p);
-    });
-}
-
-std::shared_ptr<void>
-GenericService::create_response()
-{
-  Response response = new uint8_t[response_members_->size_of_];
-  response_members_->init_function(response, rosidl_runtime_cpp::MessageInitialization::ZERO);
-  return std::shared_ptr<void>(
-    response,
-    [this](void * p)
-    {
-      response_members_->fini_function(p);
-      delete[] reinterpret_cast<uint8_t *>(p);
-    });
-}
-
-std::shared_ptr<rmw_request_id_t>
-GenericService::create_request_header()
-{
-  return std::make_shared<rmw_request_id_t>();
-}
-
-void
-GenericService::handle_request(
-  std::shared_ptr<rmw_request_id_t> request_header,
-  std::shared_ptr<void> request)
-{
-  auto response = any_callback_.dispatch(
-    this->shared_from_this(), request_header, request, create_response());
-  if (response) {
-    send_response(*request_header, response);
-  }
-}
-
-void
-GenericService::send_response(rmw_request_id_t & req_id, SharedResponse & response)
-{
-  rcl_ret_t ret = rcl_send_response(get_service_handle().get(), &req_id, response.get());
-
-  if (ret == RCL_RET_TIMEOUT) {
-    RCLCPP_WARN(
-      node_logger_.get_child("rclcpp"),
-      "failed to send response to %s (timeout): %s",
-      this->get_service_name(), rcl_get_error_string().str);
-    rcl_reset_error();
-    return;
-  }
-  if (ret != RCL_RET_OK) {
-    rclcpp::exceptions::throw_from_rcl_error(ret, "failed to send response");
-  }
-}
-
-}  //  namespace rclcpp

rclcpp/src/rclcpp/generic_subscription.cpp

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

rclcpp/src/rclcpp/logger.cpp

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <filesystem>
 #include <memory>
 #include <string>
 #include <utility>
@@ -55,14 +54,6 @@ get_node_logger(const rcl_node_t * node)
   return rclcpp::get_logger(logger_name);
 }
 
-// TODO(ahcorde): Remove deprecated class on the next release (in Rolling after Kilted).
-#if !defined(_WIN32)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#else  // !defined(_WIN32)
-# pragma warning(push)
-# pragma warning(disable: 4996)
-#endif
 rcpputils::fs::path
 get_logging_directory()
 {
@@ -76,26 +67,6 @@ get_logging_directory()
   allocator.deallocate(log_dir, allocator.state);
   return path;
 }
-// remove warning suppression
-#if !defined(_WIN32)
-# pragma GCC diagnostic pop
-#else  // !defined(_WIN32)
-# pragma warning(pop)
-#endif
-
-std::filesystem::path
-get_log_directory()
-{
-  char * log_dir = NULL;
-  auto allocator = rcutils_get_default_allocator();
-  rcl_logging_ret_t ret = rcl_logging_get_logging_directory(allocator, &log_dir);
-  if (RCL_LOGGING_RET_OK != ret) {
-    rclcpp::exceptions::throw_from_rcl_error(ret);
-  }
-  std::string path{log_dir};
-  allocator.deallocate(log_dir, allocator.state);
-  return path;
-}
 
 Logger
 Logger::get_child(const std::string & suffix)

rclcpp/src/rclcpp/node.cpp

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

rclcpp/src/rclcpp/node_interfaces/node_base.cpp

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

rclcpp/src/rclcpp/node_interfaces/node_parameters.cpp

@@ -1191,10 +1191,3 @@ NodeParameters::get_parameter_overrides() const
 {
   return parameter_overrides_;
 }
-
-void
-NodeParameters::enable_parameter_modification()
-{
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  parameter_modification_enabled_ = true;
-}

rclcpp/src/rclcpp/node_interfaces/node_type_descriptions.cpp

@@ -65,11 +65,11 @@ public:
   : logger_(node_logging->get_logger()),
     node_base_(node_base)
   {
-    rclcpp::ParameterValue enable_param;
     const std::string enable_param_name = "start_type_description_service";
 
-    if (!node_parameters->has_parameter(enable_param_name)) {
-      enable_param = node_parameters->declare_parameter(
+    bool enabled = false;
+    try {
+      auto enable_param = node_parameters->declare_parameter(
         enable_param_name,
         rclcpp::ParameterValue(true),
         rcl_interfaces::msg::ParameterDescriptor()
@@ -77,21 +77,13 @@ public:
         .set__type(rclcpp::PARAMETER_BOOL)
         .set__description("Start the ~/get_type_description service for this node.")
         .set__read_only(true));
-    } else {
-      enable_param = node_parameters->get_parameter(enable_param_name).get_parameter_value();
-    }
-    if (enable_param.get_type() != rclcpp::PARAMETER_BOOL) {
-      RCLCPP_ERROR(
-        logger_,
-            "Invalid type '%s' for parameter 'start_type_description_service', should be 'bool'",
-        rclcpp::to_string(enable_param.get_type()).c_str());
-      std::ostringstream ss;
-      ss << "Wrong parameter type, parameter {" << enable_param_name << "} is of type {bool}, "
-         << "setting it to {" << to_string(enable_param.get_type()) << "} is not allowed.";
-      throw rclcpp::exceptions::InvalidParameterTypeException(enable_param_name, ss.str());
+      enabled = enable_param.get<bool>();
+    } catch (const rclcpp::exceptions::InvalidParameterTypeException & exc) {
+      RCLCPP_ERROR(logger_, "%s", exc.what());
+      throw;
     }
 
-    if (enable_param.get<bool>()) {
+    if (enabled) {
       auto * rcl_node = node_base->get_rcl_node_handle();
       std::shared_ptr<rcl_service_t> rcl_srv(
         new rcl_service_t,
@@ -113,7 +105,6 @@ public:
         RCLCPP_ERROR(
           logger_, "Failed to initialize ~/get_type_description service: %s",
           rcl_get_error_string().str);
-        rcl_reset_error();
         throw std::runtime_error(
                 "Failed to initialize ~/get_type_description service.");
       }

rclcpp/src/rclcpp/node_options.cpp

@@ -80,7 +80,6 @@ NodeOptions::operator=(const NodeOptions & other)
     this->clock_type_ = other.clock_type_;
     this->clock_qos_ = other.clock_qos_;
     this->use_clock_thread_ = other.use_clock_thread_;
-    this->enable_logger_service_ = other.enable_logger_service_;
     this->parameter_event_qos_ = other.parameter_event_qos_;
     this->rosout_qos_ = other.rosout_qos_;
     this->parameter_event_publisher_options_ = other.parameter_event_publisher_options_;

rclcpp/src/rclcpp/parameter_events_filter.cpp

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

rclcpp/src/rclcpp/parameter_map.cpp

@@ -81,15 +81,7 @@ rclcpp::parameter_map_from(const rcl_params_t * const c_params, const char * nod
         throw InvalidParametersException(message);
       }
       const rcl_variant_t * const c_param_value = &(c_params_node->parameter_values[p]);
-      ParameterValue value;
-      try {
-        value = parameter_value_from(c_param_value);
-      } catch (const InvalidParameterValueException & e) {
-        throw InvalidParameterValueException(
-          std::string("parameter_value_from failed for parameter '") +
-          c_param_name + "': " + e.what());
-      }
-      params_node.emplace_back(c_param_name, value);
+      params_node.emplace_back(c_param_name, parameter_value_from(c_param_value));
     }
   }
 

rclcpp/src/rclcpp/publisher_base.cpp

@@ -135,28 +135,15 @@ void
 PublisherBase::bind_event_callbacks(
   const PublisherEventCallbacks & event_callbacks, bool use_default_callbacks)
 {
-  try {
-    if (event_callbacks.deadline_callback) {
-      this->add_event_handler(
-        event_callbacks.deadline_callback,
-        RCL_PUBLISHER_OFFERED_DEADLINE_MISSED);
-    }
-  } catch (const UnsupportedEventTypeException & /*exc*/) {
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Failed to add event handler for deadline; not supported");
+  if (event_callbacks.deadline_callback) {
+    this->add_event_handler(
+      event_callbacks.deadline_callback,
+      RCL_PUBLISHER_OFFERED_DEADLINE_MISSED);
   }
-
-  try {
-    if (event_callbacks.liveliness_callback) {
-      this->add_event_handler(
-        event_callbacks.liveliness_callback,
-        RCL_PUBLISHER_LIVELINESS_LOST);
-    }
-  } catch (const UnsupportedEventTypeException & /*exc*/) {
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Failed to add event handler for liveliness; not supported");
+  if (event_callbacks.liveliness_callback) {
+    this->add_event_handler(
+      event_callbacks.liveliness_callback,
+      RCL_PUBLISHER_LIVELINESS_LOST);
   }
 
   QOSOfferedIncompatibleQoSCallbackType incompatible_qos_cb;
@@ -173,9 +160,9 @@ PublisherBase::bind_event_callbacks(
       this->add_event_handler(incompatible_qos_cb, RCL_PUBLISHER_OFFERED_INCOMPATIBLE_QOS);
     }
   } catch (const UnsupportedEventTypeException & /*exc*/) {
-    RCLCPP_WARN(
+    RCLCPP_DEBUG(
       rclcpp::get_logger("rclcpp"),
-      "Failed to add event handler for incompatible qos; not supported");
+      "Failed to add event handler for incompatible qos; wrong callback type");
   }
 
   IncompatibleTypeCallbackType incompatible_type_cb;
@@ -192,21 +179,14 @@ PublisherBase::bind_event_callbacks(
       this->add_event_handler(incompatible_type_cb, RCL_PUBLISHER_INCOMPATIBLE_TYPE);
     }
   } catch (UnsupportedEventTypeException & /*exc*/) {
-    RCLCPP_WARN(
+    RCLCPP_DEBUG(
       rclcpp::get_logger("rclcpp"),
-      "Failed to add event handler for incompatible type; not supported");
+      "Failed to add event handler for incompatible type; wrong callback type");
   }
-
-  try {
-    if (event_callbacks.matched_callback) {
-      this->add_event_handler(
-        event_callbacks.matched_callback,
-        RCL_PUBLISHER_MATCHED);
-    }
-  } catch (const UnsupportedEventTypeException & /*exc*/) {
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Failed to add event handler for matched; not supported");
+  if (event_callbacks.matched_callback) {
+    this->add_event_handler(
+      event_callbacks.matched_callback,
+      RCL_PUBLISHER_MATCHED);
   }
 }
 
@@ -367,8 +347,10 @@ PublisherBase::default_incompatible_qos_callback(
 
 void
 PublisherBase::default_incompatible_type_callback(
-  [[maybe_unused]] rclcpp::IncompatibleTypeInfo & event) const
+  rclcpp::IncompatibleTypeInfo & event) const
 {
+  (void)event;
+
   RCLCPP_WARN(
     rclcpp::get_logger(rcl_node_get_logger_name(rcl_node_handle_.get())),
     "Incompatible type on topic '%s', no messages will be sent to it.", get_topic_name());

rclcpp/src/rclcpp/qos.cpp

@@ -69,10 +69,8 @@ QoSInitialization::from_rmw(const rmw_qos_profile_t & rmw_qos)
       return KeepLast(rmw_qos.depth, false);
     case RMW_QOS_POLICY_HISTORY_KEEP_LAST:
     case RMW_QOS_POLICY_HISTORY_UNKNOWN:
-      return KeepLast(rmw_qos.depth);
     default:
-      throw std::invalid_argument(
-        "Invalid history policy enum value passed to QoSInitialization::from_rmw");
+      return KeepLast(rmw_qos.depth);
   }
 }
 
@@ -409,7 +407,7 @@ ParameterEventsQoS::ParameterEventsQoS(const QoSInitialization & qos_initializat
 {}
 
 RosoutQoS::RosoutQoS(const QoSInitialization & rosout_initialization)
-: QoS(rosout_initialization, rmw_qos_profile_rosout_default)
+: QoS(rosout_initialization, rcl_qos_profile_rosout_default)
 {}
 
 SystemDefaultsQoS::SystemDefaultsQoS(const QoSInitialization & qos_initialization)

rclcpp/src/rclcpp/rate.cpp

@@ -71,6 +71,12 @@ Rate::sleep()
   return true;
 }
 
+bool
+Rate::is_steady() const
+{
+  return clock_->get_clock_type() == RCL_STEADY_TIME;
+}
+
 rcl_clock_type_t
 Rate::get_type() const
 {

rclcpp/src/rclcpp/serialization.cpp

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

rclcpp/src/rclcpp/serialized_message.cpp

@@ -26,13 +26,8 @@ namespace rclcpp
 
 inline void copy_rcl_message(const rcl_serialized_message_t & from, rcl_serialized_message_t & to)
 {
-  auto ret = RCL_RET_ERROR;
-  if (nullptr == to.buffer) {
-    ret = rmw_serialized_message_init(&to, from.buffer_capacity, &from.allocator);
-  } else {
-    ret = rmw_serialized_message_resize(&to, from.buffer_capacity);
-  }
-
+  const auto ret = rmw_serialized_message_init(
+    &to, from.buffer_capacity, &from.allocator);
   if (RCL_RET_OK != ret) {
     rclcpp::exceptions::throw_from_rcl_error(ret);
   }
@@ -83,6 +78,7 @@ SerializedMessage::SerializedMessage(rcl_serialized_message_t && other)
 SerializedMessage & SerializedMessage::operator=(const SerializedMessage & other)
 {
   if (this != &other) {
+    serialized_message_ = rmw_get_zero_initialized_serialized_message();
     copy_rcl_message(other.serialized_message_, serialized_message_);
   }
 
@@ -92,6 +88,7 @@ SerializedMessage & SerializedMessage::operator=(const SerializedMessage & other
 SerializedMessage & SerializedMessage::operator=(const rcl_serialized_message_t & other)
 {
   if (&serialized_message_ != &other) {
+    serialized_message_ = rmw_get_zero_initialized_serialized_message();
     copy_rcl_message(other, serialized_message_);
   }
 
@@ -101,14 +98,6 @@ SerializedMessage & SerializedMessage::operator=(const rcl_serialized_message_t
 SerializedMessage & SerializedMessage::operator=(SerializedMessage && other)
 {
   if (this != &other) {
-    if (nullptr != serialized_message_.buffer) {
-      const auto fini_ret = rmw_serialized_message_fini(&serialized_message_);
-      if (RCL_RET_OK != fini_ret) {
-        RCLCPP_ERROR(
-          get_logger("rclcpp"),
-          "Failed to destroy serialized message: %s", rcl_get_error_string().str);
-      }
-    }
     serialized_message_ =
       std::exchange(other.serialized_message_, rmw_get_zero_initialized_serialized_message());
   }
@@ -119,14 +108,6 @@ SerializedMessage & SerializedMessage::operator=(SerializedMessage && other)
 SerializedMessage & SerializedMessage::operator=(rcl_serialized_message_t && other)
 {
   if (&serialized_message_ != &other) {
-    if (nullptr != serialized_message_.buffer) {
-      const auto fini_ret = rmw_serialized_message_fini(&serialized_message_);
-      if (RCL_RET_OK != fini_ret) {
-        RCLCPP_ERROR(
-          get_logger("rclcpp"),
-          "Failed to destroy serialized message: %s", rcl_get_error_string().str);
-      }
-    }
     serialized_message_ =
       std::exchange(other, rmw_get_zero_initialized_serialized_message());
   }
@@ -141,7 +122,6 @@ SerializedMessage::~SerializedMessage()
       RCLCPP_ERROR(
         get_logger("rclcpp"),
         "Failed to destroy serialized message: %s", rcl_get_error_string().str);
-      rcl_reset_error();
     }
   }
 }

rclcpp/src/rclcpp/subscription_base.cpp

@@ -112,28 +112,16 @@ void
 SubscriptionBase::bind_event_callbacks(
   const SubscriptionEventCallbacks & event_callbacks, bool use_default_callbacks)
 {
-  try {
-    if (event_callbacks.deadline_callback) {
-      this->add_event_handler(
-        event_callbacks.deadline_callback,
-        RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED);
-    }
-  } catch (const UnsupportedEventTypeException & /*exc*/) {
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Failed to add event handler for deadline; not supported");
+  if (event_callbacks.deadline_callback) {
+    this->add_event_handler(
+      event_callbacks.deadline_callback,
+      RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED);
   }
 
-  try {
-    if (event_callbacks.liveliness_callback) {
-      this->add_event_handler(
-        event_callbacks.liveliness_callback,
-        RCL_SUBSCRIPTION_LIVELINESS_CHANGED);
-    }
-  } catch (const UnsupportedEventTypeException & /*exc*/) {
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Failed to add event handler for liveliness; not supported");
+  if (event_callbacks.liveliness_callback) {
+    this->add_event_handler(
+      event_callbacks.liveliness_callback,
+      RCL_SUBSCRIPTION_LIVELINESS_CHANGED);
   }
 
   QOSRequestedIncompatibleQoSCallbackType incompatible_qos_cb;
@@ -151,9 +139,7 @@ SubscriptionBase::bind_event_callbacks(
       this->add_event_handler(incompatible_qos_cb, RCL_SUBSCRIPTION_REQUESTED_INCOMPATIBLE_QOS);
     }
   } catch (const UnsupportedEventTypeException & /*exc*/) {
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Failed to add event handler for incompatible qos; not supported");
+    // pass
   }
 
   IncompatibleTypeCallbackType incompatible_type_cb;
@@ -170,33 +156,18 @@ SubscriptionBase::bind_event_callbacks(
       this->add_event_handler(incompatible_type_cb, RCL_SUBSCRIPTION_INCOMPATIBLE_TYPE);
     }
   } catch (UnsupportedEventTypeException & /*exc*/) {
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Failed to add event handler for incompatible type; not supported");
+    // pass
   }
 
-  try {
-    if (event_callbacks.message_lost_callback) {
-      this->add_event_handler(
-        event_callbacks.message_lost_callback,
-        RCL_SUBSCRIPTION_MESSAGE_LOST);
-    }
-  } catch (const UnsupportedEventTypeException & /*exc*/) {
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Failed to add event handler for message lost; not supported");
+  if (event_callbacks.message_lost_callback) {
+    this->add_event_handler(
+      event_callbacks.message_lost_callback,
+      RCL_SUBSCRIPTION_MESSAGE_LOST);
   }
-
-  try {
-    if (event_callbacks.matched_callback) {
-      this->add_event_handler(
-        event_callbacks.matched_callback,
-        RCL_SUBSCRIPTION_MATCHED);
-    }
-  } catch (const UnsupportedEventTypeException & /*exc*/) {
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Failed to add event handler for matched; not supported");
+  if (event_callbacks.matched_callback) {
+    this->add_event_handler(
+      event_callbacks.matched_callback,
+      RCL_SUBSCRIPTION_MATCHED);
   }
 }
 
@@ -381,8 +352,10 @@ SubscriptionBase::default_incompatible_qos_callback(
 
 void
 SubscriptionBase::default_incompatible_type_callback(
-  [[maybe_unused]] rclcpp::IncompatibleTypeInfo & event) const
+  rclcpp::IncompatibleTypeInfo & event) const
 {
+  (void)event;
+
   RCLCPP_WARN(
     rclcpp::get_logger(rcl_node_get_logger_name(node_handle_.get())),
     "Incompatible type on topic '%s', no messages will be sent to it.", get_topic_name());

rclcpp/src/rclcpp/time.cpp

@@ -60,10 +60,6 @@ Time::Time(int32_t seconds, uint32_t nanoseconds, rcl_clock_type_t clock_type)
 Time::Time(int64_t nanoseconds, rcl_clock_type_t clock_type)
 : rcl_time_(init_time_point(clock_type))
 {
-  if (nanoseconds < 0) {
-    throw std::runtime_error("cannot store a negative time point in rclcpp::Time");
-  }
-
   rcl_time_.nanoseconds = nanoseconds;
 }
 
@@ -253,9 +249,6 @@ Time::operator+=(const rclcpp::Duration & rhs)
   }
 
   rcl_time_.nanoseconds += rhs.nanoseconds();
-  if (rcl_time_.nanoseconds < 0) {
-    throw std::runtime_error("cannot store a negative time point in rclcpp::Time");
-  }
 
   return *this;
 }
@@ -271,9 +264,6 @@ Time::operator-=(const rclcpp::Duration & rhs)
   }
 
   rcl_time_.nanoseconds -= rhs.nanoseconds();
-  if (rcl_time_.nanoseconds < 0) {
-    throw std::runtime_error("cannot store a negative time point in rclcpp::Time");
-  }
 
   return *this;
 }

rclcpp/src/rclcpp/time_source.cpp

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

rclcpp/src/rclcpp/typesupport_helpers.cpp

@@ -35,6 +35,62 @@ namespace rclcpp
 namespace
 {
 
+// Look for the library in the ament prefix paths.
+std::string get_typesupport_library_path(
+  const std::string & package_name, const std::string & typesupport_identifier)
+{
+  const char * dynamic_library_folder;
+#ifdef _WIN32
+  dynamic_library_folder = "/bin/";
+#elif __APPLE__
+  dynamic_library_folder = "/lib/";
+#else
+  dynamic_library_folder = "/lib/";
+#endif
+
+  std::string package_prefix;
+  try {
+    package_prefix = ament_index_cpp::get_package_prefix(package_name);
+  } catch (ament_index_cpp::PackageNotFoundError & e) {
+    throw std::runtime_error(e.what());
+  }
+
+  const std::string library_path = rcpputils::path_for_library(
+    package_prefix + dynamic_library_folder,
+    package_name + "__" + typesupport_identifier);
+  if (library_path.empty()) {
+    throw std::runtime_error(
+            "Typesupport library for " + package_name + " does not exist in '" + package_prefix +
+            "'.");
+  }
+  return library_path;
+}
+
+std::tuple<std::string, std::string, std::string>
+extract_type_identifier(const std::string & full_type)
+{
+  char type_separator = '/';
+  auto sep_position_back = full_type.find_last_of(type_separator);
+  auto sep_position_front = full_type.find_first_of(type_separator);
+  if (sep_position_back == std::string::npos ||
+    sep_position_back == 0 ||
+    sep_position_back == full_type.length() - 1)
+  {
+    throw std::runtime_error(
+            "Message type is not of the form package/type and cannot be processed");
+  }
+
+  std::string package_name = full_type.substr(0, sep_position_front);
+  std::string middle_module = "";
+  if (sep_position_back - sep_position_front > 0) {
+    middle_module =
+      full_type.substr(sep_position_front + 1, sep_position_back - sep_position_front - 1);
+  }
+  std::string type_name = full_type.substr(sep_position_back + 1);
+
+  return std::make_tuple(package_name, middle_module, type_name);
+}
+
 const void * get_typesupport_handle_impl(
   const std::string & type,
   const std::string & typesupport_identifier,
@@ -75,61 +131,6 @@ const void * get_typesupport_handle_impl(
 
 }  // anonymous namespace
 
-std::tuple<std::string, std::string, std::string>
-extract_type_identifier(const std::string & full_type)
-{
-  char type_separator = '/';
-  auto sep_position_back = full_type.find_last_of(type_separator);
-  auto sep_position_front = full_type.find_first_of(type_separator);
-  if (sep_position_back == std::string::npos ||
-    sep_position_back == 0 ||
-    sep_position_back == full_type.length() - 1)
-  {
-    throw std::runtime_error(
-      "Message type is not of the form package/type and cannot be processed");
-  }
-
-  std::string package_name = full_type.substr(0, sep_position_front);
-  std::string middle_module = "";
-  if (sep_position_back - sep_position_front > 0) {
-    middle_module =
-      full_type.substr(sep_position_front + 1, sep_position_back - sep_position_front - 1);
-  }
-  std::string type_name = full_type.substr(sep_position_back + 1);
-
-  return std::make_tuple(package_name, middle_module, type_name);
-}
-
-std::string get_typesupport_library_path(
-  const std::string & package_name, const std::string & typesupport_identifier)
-{
-  const char * dynamic_library_folder;
-#ifdef _WIN32
-  dynamic_library_folder = "/bin/";
-#elif __APPLE__
-  dynamic_library_folder = "/lib/";
-#else
-  dynamic_library_folder = "/lib/";
-#endif
-
-  std::string package_prefix;
-  try {
-    package_prefix = ament_index_cpp::get_package_prefix(package_name);
-  } catch (ament_index_cpp::PackageNotFoundError & e) {
-    throw std::runtime_error(e.what());
-  }
-
-  const std::string library_path = rcpputils::path_for_library(
-    package_prefix + dynamic_library_folder,
-    package_name + "__" + typesupport_identifier);
-  if (library_path.empty()) {
-    throw std::runtime_error(
-      "Typesupport library for " + package_name + " does not exist in '" + package_prefix +
-        "'.");
-  }
-  return library_path;
-}
-
 std::shared_ptr<rcpputils::SharedLibrary>
 get_typesupport_library(const std::string & type, const std::string & typesupport_identifier)
 {
@@ -138,6 +139,14 @@ get_typesupport_library(const std::string & type, const std::string & typesuppor
   return std::make_shared<rcpputils::SharedLibrary>(library_path);
 }
 
+const rosidl_message_type_support_t * get_typesupport_handle(
+  const std::string & type,
+  const std::string & typesupport_identifier,
+  rcpputils::SharedLibrary & library)
+{
+  return get_message_typesupport_handle(type, typesupport_identifier, library);
+}
+
 const rosidl_message_type_support_t * get_message_typesupport_handle(
   const std::string & type,
   const std::string & typesupport_identifier,
@@ -168,19 +177,4 @@ const rosidl_service_type_support_t * get_service_typesupport_handle(
   ));
 }
 
-const rosidl_action_type_support_t * get_action_typesupport_handle(
-  const std::string & type,
-  const std::string & typesupport_identifier,
-  rcpputils::SharedLibrary & library)
-{
-  static const std::string typesupport_name = "action";
-  static const std::string symbol_part_name = "__get_action_type_support_handle__";
-  static const std::string middle_module_additional = "action";
-
-  return static_cast<const rosidl_action_type_support_t *>(get_typesupport_handle_impl(
-           type, typesupport_identifier, typesupport_name, symbol_part_name,
-           middle_module_additional, library
-  ));
-}
-
 }  // namespace rclcpp

rclcpp/src/rclcpp/waitable.cpp

@@ -54,8 +54,114 @@ Waitable::get_number_of_ready_guard_conditions()
   return 0u;
 }
 
+std::shared_ptr<void>
+Waitable::take_data_by_entity_id(size_t id)
+{
+  (void)id;
+  throw std::runtime_error(
+          "Custom waitables should override take_data_by_entity_id "
+          "if they want to use it.");
+}
+
 bool
 Waitable::exchange_in_use_by_wait_set_state(bool in_use_state)
 {
   return in_use_by_wait_set_.exchange(in_use_state);
 }
+
+void
+Waitable::set_on_ready_callback(std::function<void(size_t, int)> callback)
+{
+  (void)callback;
+
+  throw std::runtime_error(
+          "Custom waitables should override set_on_ready_callback "
+          "if they want to use it.");
+}
+
+void
+Waitable::clear_on_ready_callback()
+{
+  throw std::runtime_error(
+          "Custom waitables should override clear_on_ready_callback if they "
+          "want to use it and make sure to call it on the waitable destructor.");
+}
+
+void
+Waitable::add_to_wait_set(rcl_wait_set_t * wait_set)
+{
+  this->add_to_wait_set(*wait_set);
+}
+
+void
+Waitable::add_to_wait_set(rcl_wait_set_t & wait_set)
+{
+#if !defined(_WIN32)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#else  // !defined(_WIN32)
+# pragma warning(push)
+# pragma warning(disable: 4996)
+#endif
+  this->add_to_wait_set(&wait_set);
+// remove warning suppression
+#if !defined(_WIN32)
+# pragma GCC diagnostic pop
+#else  // !defined(_WIN32)
+# pragma warning(pop)
+#endif
+}
+
+bool
+Waitable::is_ready(rcl_wait_set_t * wait_set)
+{
+  const rcl_wait_set_t & const_wait_set_ref = *wait_set;
+  return this->is_ready(const_wait_set_ref);
+}
+
+bool
+Waitable::is_ready(const rcl_wait_set_t & wait_set)
+{
+#if !defined(_WIN32)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#else  // !defined(_WIN32)
+# pragma warning(push)
+# pragma warning(disable: 4996)
+#endif
+  // note this const cast is only required to support a deprecated function
+  return this->is_ready(&const_cast<rcl_wait_set_t &>(wait_set));
+// remove warning suppression
+#if !defined(_WIN32)
+# pragma GCC diagnostic pop
+#else  // !defined(_WIN32)
+# pragma warning(pop)
+#endif
+}
+
+void
+Waitable::execute(std::shared_ptr<void> & data)
+{
+  const std::shared_ptr<void> & const_data = data;
+  this->execute(const_data);
+}
+
+void
+Waitable::execute(const std::shared_ptr<void> & data)
+{
+#if !defined(_WIN32)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#else  // !defined(_WIN32)
+# pragma warning(push)
+# pragma warning(disable: 4996)
+#endif
+  // note this const cast is only required to support a deprecated function
+  this->execute(const_cast<std::shared_ptr<void> &>(data));
+// remove warning suppression
+#if !defined(_WIN32)
+# pragma GCC diagnostic pop
+#else  // !defined(_WIN32)
+# pragma warning(pop)
+#endif
+}

rclcpp/test/benchmark/benchmark_executor.cpp

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <chrono>
 #include <memory>
 #include <string>
 #include <utility>
@@ -190,6 +189,71 @@ BENCHMARK_F(PerformanceTestExecutorSimple, multi_thread_executor_remove_node)(be
   }
 }
 
+BENCHMARK_F(
+  PerformanceTestExecutorSimple,
+  static_single_thread_executor_add_node)(benchmark::State & st)
+{
+  rclcpp::executors::StaticSingleThreadedExecutor executor;
+  for (auto _ : st) {
+    (void)_;
+    executor.add_node(node);
+    st.PauseTiming();
+    executor.remove_node(node);
+    st.ResumeTiming();
+  }
+}
+
+BENCHMARK_F(
+  PerformanceTestExecutorSimple,
+  static_single_thread_executor_remove_node)(benchmark::State & st)
+{
+  rclcpp::executors::StaticSingleThreadedExecutor executor;
+  for (auto _ : st) {
+    (void)_;
+    st.PauseTiming();
+    executor.add_node(node);
+    st.ResumeTiming();
+    executor.remove_node(node);
+  }
+}
+
+BENCHMARK_F(
+  PerformanceTestExecutorSimple,
+  static_single_thread_executor_spin_until_future_complete)(benchmark::State & st)
+{
+  rclcpp::executors::StaticSingleThreadedExecutor executor;
+  // test success of an immediately finishing future
+  std::promise<bool> promise;
+  std::future<bool> future = promise.get_future();
+  promise.set_value(true);
+  auto shared_future = future.share();
+
+  auto ret = executor.spin_until_future_complete(shared_future, 100ms);
+  if (ret != rclcpp::FutureReturnCode::SUCCESS) {
+    st.SkipWithError(rcutils_get_error_string().str);
+  }
+
+  reset_heap_counters();
+
+  for (auto _ : st) {
+    (void)_;
+    // static_single_thread_executor has a special design. We need to add/remove the node each
+    // time you call spin
+    st.PauseTiming();
+    executor.add_node(node);
+    st.ResumeTiming();
+
+    ret = executor.spin_until_future_complete(shared_future, 100ms);
+    if (ret != rclcpp::FutureReturnCode::SUCCESS) {
+      st.SkipWithError(rcutils_get_error_string().str);
+      break;
+    }
+    st.PauseTiming();
+    executor.remove_node(node);
+    st.ResumeTiming();
+  }
+}
+
 BENCHMARK_F(
   PerformanceTestExecutorSimple,
   single_thread_executor_spin_node_until_future_complete)(benchmark::State & st)
@@ -250,6 +314,30 @@ BENCHMARK_F(
   }
 }
 
+BENCHMARK_F(
+  PerformanceTestExecutorSimple,
+  static_single_thread_executor_spin_node_until_future_complete)(benchmark::State & st)
+{
+  rclcpp::executors::StaticSingleThreadedExecutor executor;
+  // test success of an immediately finishing future
+  std::promise<bool> promise;
+  std::future<bool> future = promise.get_future();
+  promise.set_value(true);
+  auto shared_future = future.share();
+
+  reset_heap_counters();
+
+  for (auto _ : st) {
+    (void)_;
+    auto ret = rclcpp::executors::spin_node_until_future_complete(
+      executor, node, shared_future, 1s);
+    if (ret != rclcpp::FutureReturnCode::SUCCESS) {
+      st.SkipWithError(rcutils_get_error_string().str);
+      break;
+    }
+  }
+}
+
 BENCHMARK_F(PerformanceTestExecutorSimple, spin_until_future_complete)(benchmark::State & st)
 {
   // test success of an immediately finishing future

rclcpp/test/msg/String.msg

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

rclcpp/test/rclcpp/CMakeLists.txt

@@ -31,7 +31,6 @@ endif()
 ament_add_gtest(
   test_exceptions
   exceptions/test_exceptions.cpp)
-ament_add_test_label(test_exceptions mimick)
 if(TARGET test_exceptions)
   target_link_libraries(test_exceptions ${PROJECT_NAME} mimick)
 endif()
@@ -53,20 +52,13 @@ if(TARGET test_any_subscription_callback)
   target_link_libraries(test_any_subscription_callback ${PROJECT_NAME} ${test_msgs_TARGETS})
 endif()
 ament_add_gtest(test_client test_client.cpp)
-ament_add_test_label(test_client mimick)
 if(TARGET test_client)
   target_link_libraries(test_client ${PROJECT_NAME} mimick ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
 endif()
 ament_add_gtest(test_clock test_clock.cpp)
-ament_add_test_label(test_clock mimick)
 if(TARGET test_clock)
   target_link_libraries(test_clock ${PROJECT_NAME} mimick ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
 endif()
-ament_add_gtest(test_clock_conditional test_clock_conditional.cpp)
-ament_add_test_label(test_clock_conditional mimick)
-if(TARGET test_clock_conditional)
-  target_link_libraries(test_clock_conditional ${PROJECT_NAME} mimick ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
-endif()
 ament_add_gtest(test_copy_all_parameter_values test_copy_all_parameter_values.cpp)
 if(TARGET test_copy_all_parameter_values)
   target_link_libraries(test_copy_all_parameter_values ${PROJECT_NAME})
@@ -77,7 +69,6 @@ if(TARGET test_create_timer)
   target_include_directories(test_create_timer PRIVATE ./)
 endif()
 ament_add_gtest(test_generic_client test_generic_client.cpp)
-ament_add_test_label(test_generic_client mimick)
 if(TARGET test_generic_client)
   target_link_libraries(test_generic_client ${PROJECT_NAME}
     mimick
@@ -88,20 +79,7 @@ if(TARGET test_generic_client)
     ${test_msgs_TARGETS}
   )
 endif()
-ament_add_gtest(test_generic_service test_generic_service.cpp)
-ament_add_test_label(test_generic_service mimick)
-if(TARGET test_generic_service)
-  target_link_libraries(test_generic_service ${PROJECT_NAME}
-    mimick
-    ${rcl_interfaces_TARGETS}
-    rmw::rmw
-    rosidl_runtime_cpp::rosidl_runtime_cpp
-    rosidl_typesupport_cpp::rosidl_typesupport_cpp
-    ${test_msgs_TARGETS}
-  )
-endif()
 ament_add_gtest(test_client_common test_client_common.cpp)
-ament_add_test_label(test_client_common mimick)
 if(TARGET test_client_common)
   target_link_libraries(test_client_common ${PROJECT_NAME}
     mimick
@@ -116,8 +94,18 @@ ament_add_gtest(test_create_subscription test_create_subscription.cpp)
 if(TARGET test_create_subscription)
   target_link_libraries(test_create_subscription ${PROJECT_NAME} ${test_msgs_TARGETS})
 endif()
+function(test_add_callback_groups_to_executor_for_rmw_implementation)
+  set(rmw_implementation_env_var RMW_IMPLEMENTATION=${rmw_implementation})
+  ament_add_gmock(test_add_callback_groups_to_executor${target_suffix} test_add_callback_groups_to_executor.cpp
+    ENV ${rmw_implementation_env_var}
+    TIMEOUT 120
+  )
+  if(TARGET test_add_callback_groups_to_executor${target_suffix})
+    target_link_libraries(test_add_callback_groups_to_executor${target_suffix} ${PROJECT_NAME} ${test_msgs_TARGETS})
+  endif()
+endfunction()
+call_for_each_rmw_implementation(test_add_callback_groups_to_executor_for_rmw_implementation)
 ament_add_gtest(test_expand_topic_or_service_name test_expand_topic_or_service_name.cpp)
-ament_add_test_label(test_expand_topic_or_service_name mimick)
 if(TARGET test_expand_topic_or_service_name)
   target_link_libraries(test_expand_topic_or_service_name ${PROJECT_NAME} mimick rcl::rcl rmw::rmw)
 endif()
@@ -149,7 +137,6 @@ if(TARGET test_intra_process_buffer)
 endif()
 
 ament_add_gtest(test_loaned_message test_loaned_message.cpp)
-ament_add_test_label(test_loaned_message mimick)
 target_link_libraries(test_loaned_message ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
 
 ament_add_gtest(test_memory_strategy test_memory_strategy.cpp)
@@ -159,7 +146,6 @@ ament_add_gtest(test_message_memory_strategy test_message_memory_strategy.cpp)
 target_link_libraries(test_message_memory_strategy ${PROJECT_NAME} ${test_msgs_TARGETS})
 
 ament_add_gtest(test_node test_node.cpp TIMEOUT 240)
-ament_add_test_label(test_node mimick)
 if(TARGET test_node)
   target_link_libraries(test_node ${PROJECT_NAME} mimick rcpputils::rcpputils rmw::rmw ${test_msgs_TARGETS})
 endif()
@@ -171,7 +157,6 @@ if(TARGET test_node_interfaces__get_node_interfaces)
 endif()
 ament_add_gtest(test_node_interfaces__node_base
   node_interfaces/test_node_base.cpp)
-ament_add_test_label(test_node_interfaces__node_base mimick)
 if(TARGET test_node_interfaces__node_base)
   target_link_libraries(test_node_interfaces__node_base ${PROJECT_NAME} mimick rcl::rcl rmw::rmw)
 endif()
@@ -183,7 +168,6 @@ endif()
 ament_add_gtest(test_node_interfaces__node_graph
   node_interfaces/test_node_graph.cpp
   TIMEOUT 120)
-ament_add_test_label(test_node_interfaces__node_graph mimick)
 if(TARGET test_node_interfaces__node_graph)
   target_link_libraries(test_node_interfaces__node_graph ${PROJECT_NAME} mimick rcl::rcl ${test_msgs_TARGETS})
 endif()
@@ -194,25 +178,21 @@ if(TARGET test_node_interfaces__node_interfaces)
 endif()
 ament_add_gtest(test_node_interfaces__node_parameters
   node_interfaces/test_node_parameters.cpp)
-ament_add_test_label(test_node_interfaces__node_parameters mimick)
 if(TARGET test_node_interfaces__node_parameters)
-  target_link_libraries(test_node_interfaces__node_parameters ${PROJECT_NAME} mimick rcpputils::rcpputils ${test_msgs_TARGETS})
+  target_link_libraries(test_node_interfaces__node_parameters ${PROJECT_NAME} mimick rcpputils::rcpputils)
 endif()
 ament_add_gtest(test_node_interfaces__node_services
   node_interfaces/test_node_services.cpp)
-ament_add_test_label(test_node_interfaces__node_services mimick)
 if(TARGET test_node_interfaces__node_services)
   target_link_libraries(test_node_interfaces__node_services ${PROJECT_NAME} mimick rcl::rcl)
 endif()
 ament_add_gtest(test_node_interfaces__node_timers
   node_interfaces/test_node_timers.cpp)
-ament_add_test_label(test_node_interfaces__node_timers mimick)
 if(TARGET test_node_interfaces__node_timers)
   target_link_libraries(test_node_interfaces__node_timers ${PROJECT_NAME} mimick rcl::rcl)
 endif()
 ament_add_gtest(test_node_interfaces__node_topics
   node_interfaces/test_node_topics.cpp)
-ament_add_test_label(test_node_interfaces__node_topics mimick)
 if(TARGET test_node_interfaces__node_topics)
   target_link_libraries(test_node_interfaces__node_topics ${PROJECT_NAME} mimick rcl::rcl ${test_msgs_TARGETS})
 endif()
@@ -223,7 +203,6 @@ if(TARGET test_node_interfaces__node_type_descriptions)
 endif()
 ament_add_gtest(test_node_interfaces__node_waitables
   node_interfaces/test_node_waitables.cpp)
-ament_add_test_label(test_node_interfaces__node_waitables mimick)
 if(TARGET test_node_interfaces__node_waitables)
   target_link_libraries(test_node_interfaces__node_waitables ${PROJECT_NAME} mimick rcl::rcl)
 endif()
@@ -259,12 +238,10 @@ if(TARGET test_node_global_args)
   target_link_libraries(test_node_global_args ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_node_options test_node_options.cpp)
-ament_add_test_label(test_node_options mimick)
 if(TARGET test_node_options)
   target_link_libraries(test_node_options ${PROJECT_NAME} mimick rcl::rcl)
 endif()
 ament_add_gtest(test_init_options test_init_options.cpp)
-ament_add_test_label(test_init_options mimick)
 if(TARGET test_init_options)
   target_link_libraries(test_init_options ${PROJECT_NAME} mimick rcl::rcl)
 endif()
@@ -293,7 +270,6 @@ if(TARGET test_parameter_map)
   target_link_libraries(test_parameter_map ${PROJECT_NAME} rcl::rcl rcl_yaml_param_parser::rcl_yaml_param_parser rcutils::rcutils)
 endif()
 ament_add_gtest(test_publisher test_publisher.cpp TIMEOUT 120)
-ament_add_test_label(test_publisher mimick)
 if(TARGET test_publisher)
   target_link_libraries(test_publisher ${PROJECT_NAME} mimick rcl::rcl rcutils::rcutils ${test_msgs_TARGETS})
 endif()
@@ -343,6 +319,27 @@ if(TARGET test_qos)
     rmw::rmw
   )
 endif()
+function(test_generic_pubsub_for_rmw_implementation)
+  set(rmw_implementation_env_var RMW_IMPLEMENTATION=${rmw_implementation})
+  ament_add_gmock(test_generic_pubsub${target_suffix} test_generic_pubsub.cpp
+    ENV ${rmw_implementation_env_var}
+  )
+  if(TARGET test_generic_pubsub${target_suffix})
+    target_link_libraries(test_generic_pubsub${target_suffix} ${PROJECT_NAME} rcl::rcl ${test_msgs_TARGETS})
+  endif()
+endfunction()
+call_for_each_rmw_implementation(test_generic_pubsub_for_rmw_implementation)
+
+function(test_qos_event_for_rmw_implementation)
+  set(rmw_implementation_env_var RMW_IMPLEMENTATION=${rmw_implementation})
+  ament_add_gmock(test_qos_event${target_suffix} test_qos_event.cpp
+    ENV ${rmw_implementation_env_var}
+  )
+  if(TARGET test_qos_event${target_suffix})
+    target_link_libraries(test_qos_event${target_suffix} ${PROJECT_NAME} mimick rcutils::rcutils rmw::rmw ${test_msgs_TARGETS})
+  endif()
+endfunction()
+call_for_each_rmw_implementation(test_qos_event_for_rmw_implementation)
 
 ament_add_gmock(test_qos_overriding_options test_qos_overriding_options.cpp)
 if(TARGET test_qos_overriding_options)
@@ -365,18 +362,15 @@ if(TARGET test_serialized_message)
   target_link_libraries(test_serialized_message ${PROJECT_NAME} rcpputils::rcpputils ${test_msgs_TARGETS})
 endif()
 ament_add_gtest(test_service test_service.cpp)
-ament_add_test_label(test_service mimick)
 if(TARGET test_service)
   target_link_libraries(test_service ${PROJECT_NAME} mimick ${rcl_interfaces_TARGES} ${test_msgs_TARGETS})
 endif()
 ament_add_gmock(test_service_introspection test_service_introspection.cpp)
-ament_add_test_label(test_service_introspection mimick)
 if(TARGET test_service_introspection)
   target_link_libraries(test_service_introspection ${PROJECT_NAME} mimick ${service_msgs_TARGETS} ${test_msgs_TARGETS})
 endif()
 # Creating and destroying nodes is slow with Connext, so this needs larger timeout.
 ament_add_gtest(test_subscription test_subscription.cpp TIMEOUT 120)
-ament_add_test_label(test_subscription mimick)
 if(TARGET test_subscription)
   target_link_libraries(test_subscription ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
 endif()
@@ -427,7 +421,6 @@ endif()
 
 ament_add_gtest(test_timer test_timer.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
-ament_add_test_label(test_timer mimick)
 if(TARGET test_timer)
   target_link_libraries(test_timer ${PROJECT_NAME} mimick rcl::rcl)
 endif()
@@ -446,7 +439,6 @@ endif()
 
 ament_add_gtest(test_utilities test_utilities.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
-ament_add_test_label(test_utilities mimick)
 if(TARGET test_utilities)
   target_link_libraries(test_utilities ${PROJECT_NAME} mimick rcl::rcl)
 endif()
@@ -467,22 +459,11 @@ if(TARGET test_interface_traits)
   target_link_libraries(test_interface_traits ${PROJECT_NAME})
 endif()
 
-ament_add_gtest(test_reinitialized_timers
-  executors/test_reinitialized_timers.cpp
-  TIMEOUT 30)
-if(TARGET test_reinitialized_timers)
-  target_link_libraries(test_reinitialized_timers ${PROJECT_NAME})
-endif()
-
 ament_add_gtest(
   test_executors
   executors/test_executors.cpp
-  executors/test_waitable.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}"
   TIMEOUT 180)
-if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND MSVC)
-  target_compile_options(test_executors PRIVATE "/bigobj")
-endif()
 if(TARGET test_executors)
   target_link_libraries(test_executors ${PROJECT_NAME} rcl::rcl ${test_msgs_TARGETS})
 endif()
@@ -492,7 +473,7 @@ ament_add_gtest(
   executors/test_executors_timer_cancel_behavior.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}"
   TIMEOUT 180)
-if(TARGET test_executors_timer_cancel_behavior)
+if(TARGET test_executors)
   target_link_libraries(test_executors_timer_cancel_behavior ${PROJECT_NAME} ${rosgraph_msgs_TARGETS})
 endif()
 
@@ -501,7 +482,7 @@ ament_add_gtest(
   executors/test_executors_callback_group_behavior.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}"
   TIMEOUT 180)
-if(TARGET test_executors_callback_group_behavior)
+if(TARGET test_executors)
   target_link_libraries(test_executors_callback_group_behavior ${PROJECT_NAME})
 endif()
 
@@ -510,33 +491,12 @@ ament_add_gtest(
   executors/test_executors_intraprocess.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}"
   TIMEOUT 180)
-if(TARGET test_executors_intraprocess)
+if(TARGET test_executors)
   target_link_libraries(test_executors_intraprocess ${PROJECT_NAME} ${test_msgs_TARGETS})
 endif()
 
-ament_add_gtest(
-  test_executors_busy_waiting
-  executors/test_executors_busy_waiting.cpp
-  executors/test_waitable.cpp
-  APPEND_LIBRARY_DIRS "${append_library_dirs}"
-  TIMEOUT 180)
-if(TARGET test_executors_busy_waiting)
-  target_link_libraries(test_executors_busy_waiting ${PROJECT_NAME})
-endif()
-
-ament_add_gtest(
-  test_executors_warmup
-  executors/test_executors_warmup.cpp
-  executors/test_waitable.cpp
-  APPEND_LIBRARY_DIRS "${append_library_dirs}"
-  TIMEOUT 180)
-if(TARGET test_executors_warmup)
-  target_link_libraries(test_executors_warmup ${PROJECT_NAME} ${test_msgs_TARGETS})
-endif()
-
 ament_add_gtest(test_static_single_threaded_executor executors/test_static_single_threaded_executor.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
-ament_add_test_label(test_static_single_threaded_executor mimick)
 if(TARGET test_static_single_threaded_executor)
   target_link_libraries(test_static_single_threaded_executor ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
 endif()
@@ -555,12 +515,11 @@ endif()
 
 ament_add_gtest(test_executor_notify_waitable executors/test_executor_notify_waitable.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}" TIMEOUT 120)
-ament_add_test_label(test_executor_notify_waitable mimick)
 if(TARGET test_executor_notify_waitable)
   target_link_libraries(test_executor_notify_waitable ${PROJECT_NAME} mimick rcpputils::rcpputils)
 endif()
 
-ament_add_gtest(test_events_executor executors/test_events_executor.cpp TIMEOUT 60)
+ament_add_gtest(test_events_executor executors/test_events_executor.cpp TIMEOUT 5)
 if(TARGET test_events_executor)
   target_link_libraries(test_events_executor ${PROJECT_NAME} ${test_msgs_TARGETS})
 endif()
@@ -573,7 +532,6 @@ endif()
 
 ament_add_gtest(test_guard_condition test_guard_condition.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
-ament_add_test_label(test_guard_condition mimick)
 if(TARGET test_guard_condition)
   target_link_libraries(test_guard_condition ${PROJECT_NAME} mimick)
 endif()
@@ -607,7 +565,6 @@ if(TARGET test_dynamic_storage)
 endif()
 
 ament_add_gtest(test_storage_policy_common wait_set_policies/test_storage_policy_common.cpp)
-ament_add_test_label(test_storage_policy_common mimick)
 if(TARGET test_storage_policy_common)
   target_link_libraries(test_storage_policy_common ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
 endif()
@@ -640,70 +597,24 @@ endif()
 ament_add_gtest(test_executor test_executor.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}"
   TIMEOUT 120)
-ament_add_test_label(test_executor mimick)
 if(TARGET test_executor)
-  target_link_libraries(test_executor ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
+  target_link_libraries(test_executor ${PROJECT_NAME} mimick)
 endif()
 
 ament_add_gtest(test_graph_listener test_graph_listener.cpp)
-ament_add_test_label(test_graph_listener mimick)
 if(TARGET test_graph_listener)
   target_link_libraries(test_graph_listener ${PROJECT_NAME} mimick)
 endif()
 
-ament_add_gmock_executable(test_qos_event test_qos_event.cpp)
-if(TARGET test_qos_event)
-  target_link_libraries(test_qos_event ${PROJECT_NAME} mimick rcutils::rcutils rmw::rmw ${test_msgs_TARGETS})
-endif()
-
-ament_add_gmock_executable(test_generic_pubsub test_generic_pubsub.cpp)
-if(TARGET test_generic_pubsub)
-  target_link_libraries(test_generic_pubsub ${PROJECT_NAME} rcl::rcl ${test_msgs_TARGETS})
-endif()
-
-ament_add_gmock_executable(test_add_callback_groups_to_executor test_add_callback_groups_to_executor.cpp)
-if(TARGET test_add_callback_groups_to_executor)
-  target_link_libraries(test_add_callback_groups_to_executor ${PROJECT_NAME} ${test_msgs_TARGETS})
-endif()
-
-ament_add_gmock_executable(test_subscription_content_filter test_subscription_content_filter.cpp)
-if(TARGET test_subscription_content_filter)
-  target_link_libraries(test_subscription_content_filter ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
-endif()
-
-function(test_on_all_rmws)
+function(test_subscription_content_filter_for_rmw_implementation)
   set(rmw_implementation_env_var RMW_IMPLEMENTATION=${rmw_implementation})
-
-  # If the rmw_implementation is rmw_zenoh_cpp, run the tests with multicast discovery enabled.
-  # Note: This is a temporary change that will be reverted before we branch into Kilted.
-  if(rmw_implementation STREQUAL "rmw_zenoh_cpp")
-    list(APPEND rmw_implementation_env_var
-      ZENOH_CONFIG_OVERRIDE=scouting/multicast/enabled=true
-    )
+  ament_add_gmock(test_subscription_content_filter${target_suffix}
+    test_subscription_content_filter.cpp
+    ENV ${rmw_implementation_env_var}
+    TIMEOUT 120
+  )
+  if(TARGET test_subscription_content_filter${target_suffix})
+    target_link_libraries(test_subscription_content_filter${target_suffix} ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
   endif()
-
-  ament_add_gmock_test(test_qos_event
-    TEST_NAME test_qos_event${target_suffix}
-    ENV ${rmw_implementation_env_var}
-  )
-  ament_add_test_label(test_qos_event${target_suffix} mimick)
-
-  ament_add_gmock_test(test_generic_pubsub
-    TEST_NAME test_generic_pubsub${target_suffix}
-    ENV ${rmw_implementation_env_var}
-  )
-
-  ament_add_gmock_test(test_add_callback_groups_to_executor
-    TEST_NAME test_add_callback_groups_to_executor${target_suffix}
-    ENV ${rmw_implementation_env_var}
-    TIMEOUT 120
-  )
-
-  ament_add_gmock_test(test_subscription_content_filter
-    TEST_NAME test_subscription_content_filter${target_suffix}
-    ENV ${rmw_implementation_env_var}
-    TIMEOUT 120
-  )
-  ament_add_test_label(test_subscription_content_filter${target_suffix} mimick)
 endfunction()
-call_for_each_rmw_implementation(test_on_all_rmws)
+call_for_each_rmw_implementation(test_subscription_content_filter_for_rmw_implementation)

rclcpp/test/rclcpp/executors/executor_types.hpp

@@ -25,44 +25,20 @@
 #include "rclcpp/executors/static_single_threaded_executor.hpp"
 #include "rclcpp/executors/multi_threaded_executor.hpp"
 
-// suppress deprecated StaticSingleThreadedExecutor warning
-// we define an alias that explicitly indicates that this class is deprecated, while avoiding
-// polluting a lot of files the gcc pragmas
-#if !defined(_WIN32)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#else  // !defined(_WIN32)
-# pragma warning(push)
-# pragma warning(disable: 4996)
-#endif
-using DeprecatedStaticSingleThreadedExecutor = rclcpp::executors::StaticSingleThreadedExecutor;
-// remove warning suppression
-#if !defined(_WIN32)
-# pragma GCC diagnostic pop
-#else  // !defined(_WIN32)
-# pragma warning(pop)
-#endif
-
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
 using ExecutorTypes =
   ::testing::Types<
   rclcpp::executors::SingleThreadedExecutor,
   rclcpp::executors::MultiThreadedExecutor,
-  DeprecatedStaticSingleThreadedExecutor,
+  rclcpp::executors::StaticSingleThreadedExecutor,
   rclcpp::experimental::executors::EventsExecutor>;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
 
 class ExecutorTypeNames
 {
 public:
   template<typename T>
-  static std::string GetName([[maybe_unused]] int idx)
+  static std::string GetName(int idx)
   {
+    (void)idx;
     if (std::is_same<T, rclcpp::executors::SingleThreadedExecutor>()) {
       return "SingleThreadedExecutor";
     }
@@ -70,16 +46,10 @@ public:
     if (std::is_same<T, rclcpp::executors::MultiThreadedExecutor>()) {
       return "MultiThreadedExecutor";
     }
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-    if (std::is_same<T, DeprecatedStaticSingleThreadedExecutor>()) {
+
+    if (std::is_same<T, rclcpp::executors::StaticSingleThreadedExecutor>()) {
       return "StaticSingleThreadedExecutor";
     }
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
 
     if (std::is_same<T, rclcpp::experimental::executors::EventsExecutor>()) {
       return "EventsExecutor";

rclcpp/test/rclcpp/executors/test_events_executor.cpp

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

rclcpp/test/rclcpp/executors/test_events_queue.cpp

@@ -14,7 +14,6 @@
 
 #include <gtest/gtest.h>
 
-#include <chrono>
 #include <memory>
 
 #include "rclcpp/experimental/executors/events_executor/events_executor_event_types.hpp"