@wip

Signed-off-by: Michael Carroll <mjcarroll@intrinsic.ai>

.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

README.md

@@ -8,7 +8,7 @@ rclcpp provides the standard C++ API for interacting with ROS 2.
 
 `#include "rclcpp/rclcpp.hpp"` allows use of the most common elements of the ROS 2 system.
 
-The link to the latest API documentation can be found on the [rclcpp package info page](https://docs.ros.org/en/rolling/p/rclcpp).
+The link to the latest API documentation can be found on the rclcpp package info page, at the [ROS Index](https://index.ros.org/p/rclcpp/).
 
 
 ### Examples

rclcpp/CHANGELOG.rst

@@ -2,505 +2,6 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-29.6.0 (2025-04-25)
--------------------
-* throws std::invalid_argument if ParameterEvent is NULL. (`#2814 <https://github.com/ros2/rclcpp/issues/2814>`_)
-* Removed clang warnings (`#2823 <https://github.com/ros2/rclcpp/issues/2823>`_)
-* Contributors: Alejandro Hernández Cordero, Tomoya Fujita
-
-29.5.0 (2025-04-18)
--------------------
-* Fix a race condition (`#2819 <https://github.com/ros2/rclcpp/issues/2819>`_)
-* Remove redundant typesupport check in serialization module (`#2808 <https://github.com/ros2/rclcpp/issues/2808>`_)
-* Remove get_typesupport_handle implementation. (`#2806 <https://github.com/ros2/rclcpp/issues/2806>`_)
-* Use NodeParameterInterface instead of /parameter_event to update "use_sim_time" (`#2378 <https://github.com/ros2/rclcpp/issues/2378>`_)
-* Remove cancel_clock_executor_promise\_. (`#2797 <https://github.com/ros2/rclcpp/issues/2797>`_)
-* Enable parameter update recursively only when QoS override parameters. (`#2742 <https://github.com/ros2/rclcpp/issues/2742>`_)
-* Contributors: Pedro de Azeredo, Tanishq Chaudhary, Tomoya Fujita
-
-29.4.0 (2025-04-04)
--------------------
-* Removed trailing whitespace from the codebase. (`#2791 <https://github.com/ros2/rclcpp/issues/2791>`_)
-* Expanded docstring of `get_rmw_qos_profile()` (`#2787 <https://github.com/ros2/rclcpp/issues/2787>`_)
-* Set envars to run tests with rmw_zenoh_cpp with multicast discovery (`#2776 <https://github.com/ros2/rclcpp/issues/2776>`_)
-* fix: Compilefix for clang (`#2775 <https://github.com/ros2/rclcpp/issues/2775>`_)
-* add exception doc for configure_introspection. (`#2773 <https://github.com/ros2/rclcpp/issues/2773>`_)
-* feat: Add ClockWaiter and ClockConditionalVariable (`#2691 <https://github.com/ros2/rclcpp/issues/2691>`_)
-* doc: Added warning to not instantiate Clock directly with RCL_ROS_TIME (`#2768 <https://github.com/ros2/rclcpp/issues/2768>`_)
-* Use rmw_event_type_is_supported in test_qos_event (`#2761 <https://github.com/ros2/rclcpp/issues/2761>`_)
-* Support action typesupport helper (`#2750 <https://github.com/ros2/rclcpp/issues/2750>`_)
-* use maybe_unused attribute for the portability. (`#2758 <https://github.com/ros2/rclcpp/issues/2758>`_)
-* Executor strong reference fix (`#2745 <https://github.com/ros2/rclcpp/issues/2745>`_)
-* Cleanup of https://github.com/ros2/rclcpp/pull/2683 (`#2714 <https://github.com/ros2/rclcpp/issues/2714>`_)
-* Fix typo in doc section for get_service_typesupport_handle (`#2751 <https://github.com/ros2/rclcpp/issues/2751>`_)
-* Test case and fix for for https://github.com/ros2/rclcpp/issues/2652 (`#2713 <https://github.com/ros2/rclcpp/issues/2713>`_)
-* fix(timer): Delete node, after executor thread terminated (`#2737 <https://github.com/ros2/rclcpp/issues/2737>`_)
-* update doc section for spin_xxx methods. (`#2730 <https://github.com/ros2/rclcpp/issues/2730>`_)
-* fix: Expose timers used by rclcpp::Waitables (`#2699 <https://github.com/ros2/rclcpp/issues/2699>`_)
-* use rmw_qos_profile_rosout_default instead of rcl. (`#2663 <https://github.com/ros2/rclcpp/issues/2663>`_)
-* fix(Executor): Fixed entities not beeing executed after just beeing added (`#2724 <https://github.com/ros2/rclcpp/issues/2724>`_)
-* fix: make the loop condition align with the description (`#2726 <https://github.com/ros2/rclcpp/issues/2726>`_)
-* Collect log messages from rcl, and reset. (`#2720 <https://github.com/ros2/rclcpp/issues/2720>`_)
-* Contributors: Abhishek Kashyap, Alejandro Hernández Cordero, Barry Xu, Janosch Machowinski, Leander Stephen D'Souza, Tomoya Fujita, Yuyuan Yuan
-
-29.3.0 (2024-12-20)
--------------------
-* Fix transient local IPC publish  (`#2708 <https://github.com/ros2/rclcpp/issues/2708>`_)
-* 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
-
-28.1.0 (2024-04-16)
--------------------
-* Remove references to index.ros.org. (`#2504 <https://github.com/ros2/rclcpp/issues/2504>`_)
-* Reduce overhead for inheriting from rclcpp::Executor when base functionality is not reused (`#2506 <https://github.com/ros2/rclcpp/issues/2506>`_)
-* Contributors: Chris Lalancette, William Woodall, jmachowinski
-
-28.0.1 (2024-04-16)
--------------------
-* [wjwwood] Updated "Data race fixes" (`#2500 <https://github.com/ros2/rclcpp/issues/2500>`_)
-  * Fix callback group logic in executor
-  * fix: Fixed unnecessary copy of wait_set
-  * fix(executor): Fixed race conditions with rebuild of wait_sets
-  Before this change, the rebuild of wait set would be triggered
-  after the wait set was waken up. With bad timing, this could
-  lead to the rebuild not happening with multi threaded executor.
-  * fix(Executor): Fixed lost of entities rebuild request
-  * chore: Added assert for not set callback_group in execute_any_executable
-  * Add test for cbg getting reset
-  Co-authored-by: Janosch Machowinski <j.machowinski@nospam.org>
-  * chore: renamed test cases to snake_case
-  * style
-  * fixup test to avoid polling and short timeouts
-  * fix: Use correct notify_waitable\_ instance
-  * fix(StaticSingleThreadedExecutor): Added missing special case handling for current_notify_waitable\_
-  * fix(TestCallbackGroup): Fixed test after change to timers
-  ---------
-  Co-authored-by: Janosch Machowinski <j.machowinski@cellumation.com>
-  Co-authored-by: Michael Carroll <mjcarroll@intrinsic.ai>
-  Co-authored-by: Janosch Machowinski <j.machowinski@nospam.org>
-* fixup var names to snake case (`#2501 <https://github.com/ros2/rclcpp/issues/2501>`_)
-* Added optional TimerInfo to timer callback (`#2343 <https://github.com/ros2/rclcpp/issues/2343>`_)
-  Co-authored-by: Alexis Tsogias <a.tsogias@cellumation.com>
-  Co-authored-by: Janosch Machowinski <J.Machowinski@cellumation.com>
-* Fix uninitialized memory in test (`#2498 <https://github.com/ros2/rclcpp/issues/2498>`_)
-  When I added in the tests for large messages, I made a mistake and reserved space in the strings, but didn't actually expand it.  Thus, we were writing into uninitialized memory.  Fix this by just using the correct constructor for string, which will allocate and initialize the memory properly.
-* Ensure waitables handle guard condition retriggering (`#2483 <https://github.com/ros2/rclcpp/issues/2483>`_)
-  Co-authored-by: Michael Carroll <mjcarroll@intrinsic.ai>
-* fix: init concatenated_vector with begin() & end() (`#2492 <https://github.com/ros2/rclcpp/issues/2492>`_)
-  * this commit will fix the warning [-Wstringop-overflow=] `#2461 <https://github.com/ros2/rclcpp/issues/2461>`_
-* Use the same context for the specified node in rclcpp::spin functions (`#2433 <https://github.com/ros2/rclcpp/issues/2433>`_)
-  * Use the same conext for the specified node in rclcpp::spin_xx functions
-  * Add test for spinning with non-default-context
-  * Format code
-  ---------
-* Disable compare-function-pointers in test_utilities (`#2489 <https://github.com/ros2/rclcpp/issues/2489>`_)
-* address ambiguous auto variable. (`#2481 <https://github.com/ros2/rclcpp/issues/2481>`_)
-* Increase the cppcheck timeout to 1200 seconds (`#2484 <https://github.com/ros2/rclcpp/issues/2484>`_)
-* Removed test_timers_manager clang warning (`#2479 <https://github.com/ros2/rclcpp/issues/2479>`_)
-* Flaky timer test fix (`#2469 <https://github.com/ros2/rclcpp/issues/2469>`_)
-  * fix(time_source): Fixed possible race condition
-  * fix(test_executors_time_cancel_behaviour): Fixed multiple race conditions
-  ---------
-  Co-authored-by: Janosch Machowinski <j.machowinski@nospam.org>
-* Add tracepoint for generic publisher/subscriber (`#2448 <https://github.com/ros2/rclcpp/issues/2448>`_)
-* update rclcpp::Waitable API to use references and const (`#2467 <https://github.com/ros2/rclcpp/issues/2467>`_)
-* Utilize rclcpp::WaitSet as part of the executors (`#2142 <https://github.com/ros2/rclcpp/issues/2142>`_)
-  * Deprecate callback_group call taking context
-  * Add base executor objects that can be used by implementors
-  * Template common operations
-  * Address reviewer feedback:
-  * Add callback to EntitiesCollector constructor
-  * Make function to check automatically added callback groups take a list
-  * Lint
-  * Address reviewer feedback and fix templates
-  * Lint and docs
-  * Make executor own the notify waitable
-  * Add pending queue to collector, remove from waitable
-  Also change node's get_guard_condition to return shared_ptr
-  * Change interrupt guard condition to shared_ptr
-  Check if guard condition is valid before adding it to the waitable
-  * Lint and docs
-  * Utilize rclcpp::WaitSet as part of the executors
-  * Don't exchange atomic twice
-  * Fix add_node and add more tests
-  * Make get_notify_guard_condition follow API tick-tock
-  * Improve callback group tick-tocking
-  * Don't lock twice
-  * Address reviewer feedback
-  * Add thread safety annotations and make locks consistent
-  * @wip
-  * Reset callback groups for multithreaded executor
-  * Avoid many small function calls when building executables
-  * Re-trigger guard condition if buffer has data
-  * Address reviewer feedback
-  * Trace points
-  * Remove tracepoints
-  * Reducing diff
-  * Reduce diff
-  * Uncrustify
-  * Restore tests
-  * Back to weak_ptr and reduce test time
-  * reduce diff and lint
-  * Restore static single threaded tests that weren't working before
-  * Restore more tests
-  * Fix multithreaded test
-  * Fix assert
-  * Fix constructor test
-  * Change ready_executables signature back
-  * Don't enforce removing callback groups before nodes
-  * Remove the "add_valid_node" API
-  * Only notify if the trigger condition is valid
-  * Only trigger if valid and needed
-  * Fix spin_some/spin_all implementation
-  * Restore single threaded executor
-  * Picking ABI-incompatible executor changes
-  * Add PIMPL
-  * Additional waitset prune
-  * Fix bad merge
-  * Expand test timeout
-  * Introduce method to clear expired entities from a collection
-  * Make sure to call remove_expired_entities().
-  * Prune queued work when callback group is removed
-  * Prune subscriptions from dynamic storage
-  * Styles fixes.
-  * Re-trigger guard conditions
-  * Condense to just use watiable.take_data
-  * Lint
-  * Address reviewer comments (nits)
-  * Lock mutex when copying
-  * Refactors to static single threaded based on reviewers
-  * More small refactoring
-  * Lint
-  * Lint
-  * Add ready executable accessors to WaitResult
-  * Make use of accessors from wait_set
-  * Fix tests
-  * Fix more tests
-  * Tidy up single threaded executor implementation
-  * Don't null out timer, rely on call
-  * change how timers are checked from wait result in executors
-  * peak -> peek
-  * fix bug in next_waitable logic
-  * fix bug in StaticSTE that broke the add callback groups to executor tests
-  * style
-  ---------
-  Co-authored-by: Chris Lalancette <clalancette@gmail.com>
-  Co-authored-by: William Woodall <william@osrfoundation.org>
-* fix flakiness in TestTimersManager unit-test (`#2468 <https://github.com/ros2/rclcpp/issues/2468>`_)
-  the previous version of the test was relying on the assumption that a timer with 1ms period gets called at least 6 times if the main thread waits 15ms. this is true most of the times, but it's not guaranteed, especially when running the test on windows CI servers. the new version of the test makes no assumptions on how much time it takes for the timers manager to invoke the timers, but rather focuses on ensuring that they are called the right amount of times, which is what's important for the purpose of the test
-* Contributors: Alberto Soragna, Alejandro Hernández Cordero, Chris Lalancette, Homalozoa X, Kotaro Yoshimoto, Michael Carroll, Tomoya Fujita, William Woodall, h-suzuki-isp, jmachowinski
-
-28.0.0 (2024-03-28)
--------------------
-* fix spin_some_max_duration unit-test for events-executor (`#2465 <https://github.com/ros2/rclcpp/issues/2465>`_)
-* refactor and improve the parameterized spin_some tests for executors (`#2460 <https://github.com/ros2/rclcpp/issues/2460>`_)
-  * refactor and improve the spin_some parameterized tests for executors
-  * disable spin_some_max_duration for the StaticSingleThreadedExecutor and EventsExecutor
-  * fixup and clarify the docstring for Executor::spin_some()
-  * style
-  * review comments
-  ---------
-* enable simulation clock for timer canceling test. (`#2458 <https://github.com/ros2/rclcpp/issues/2458>`_)
-  * enable simulation clock for timer canceling test.
-  * move MainExecutorTypes to test_executors_timer_cancel_behavior.cpp.
-  ---------
-* Revert "relax the test simulation rate for timer canceling tests. (`#2453 <https://github.com/ros2/rclcpp/issues/2453>`_)" (`#2456 <https://github.com/ros2/rclcpp/issues/2456>`_)
-  This reverts commit 1c350d0d7fb9c7158e0a39057112486ddbd38e9a.
-* relax the test simulation rate for timer canceling tests. (`#2453 <https://github.com/ros2/rclcpp/issues/2453>`_)
-* Fix TypeAdapted publishing with large messages. (`#2443 <https://github.com/ros2/rclcpp/issues/2443>`_)
-  Mostly by ensuring we aren't attempting to store
-  large messages on the stack.  Also add in tests.
-  I verified that before these changes, the tests failed,
-  while after them they succeed.
-* Implement generic client (`#2358 <https://github.com/ros2/rclcpp/issues/2358>`_)
-  * Implement generic client
-  * Fix the incorrect parameter declaration
-  * Deleted copy constructor and assignment for FutureAndRequestId
-  * Update codes after rebase
-  * Address review comments
-  * Address review comments from iuhilnehc-ynos
-  * Correct an error in a description
-  * Fix window build errors
-  * Address review comments from William
-  * Add doc strings to create_generic_client
-  ---------
-* Rule of five: implement move operators (`#2425 <https://github.com/ros2/rclcpp/issues/2425>`_)
-* Various cleanups to deal with uncrustify 0.78. (`#2439 <https://github.com/ros2/rclcpp/issues/2439>`_)
-  These should also work with uncrustify 0.72.
-* Remove the set_deprecated signatures in any_subscription_callback. (`#2431 <https://github.com/ros2/rclcpp/issues/2431>`_)
-  These have been deprecated since April 2021, so it is safe
-  to remove them now.
-* fix doxygen syntax for NodeInterfaces (`#2428 <https://github.com/ros2/rclcpp/issues/2428>`_)
-* Set hints to find the python version we actually want. (`#2426 <https://github.com/ros2/rclcpp/issues/2426>`_)
-  The comment in the commit explains the reasoning behind it.
-* Update quality declaration documents (`#2427 <https://github.com/ros2/rclcpp/issues/2427>`_)
-* feat: add/minus for msg::Time and rclcpp::Duration (`#2419 <https://github.com/ros2/rclcpp/issues/2419>`_)
-  * feat: add/minus for msg::Time and rclcpp::Duration
-* Contributors: Alberto Soragna, Barry Xu, Chris Lalancette, Christophe Bedard, HuaTsai, Jonas Otto, Tim Clephas, Tomoya Fujita, William Woodall
-
-27.0.0 (2024-02-07)
--------------------
-* Split test_executors up into smaller chunks. (`#2421 <https://github.com/ros2/rclcpp/issues/2421>`_)
-* [events executor] - Fix Behavior with Timer Cancel (`#2375 <https://github.com/ros2/rclcpp/issues/2375>`_)
-* Removed deprecated header (`#2413 <https://github.com/ros2/rclcpp/issues/2413>`_)
-* Make sure to mark RingBuffer methods as 'override'. (`#2410 <https://github.com/ros2/rclcpp/issues/2410>`_)
-* Contributors: Alejandro Hernández Cordero, Chris Lalancette, Matt Condino
-
-26.0.0 (2024-01-24)
--------------------
-* Increase the cppcheck timeout to 600 seconds. (`#2409 <https://github.com/ros2/rclcpp/issues/2409>`_)
-* Add transient local durability support to publisher and subscriptions when using intra-process communication (`#2303 <https://github.com/ros2/rclcpp/issues/2303>`_)
-* Stop storing the context in the guard condition. (`#2400 <https://github.com/ros2/rclcpp/issues/2400>`_)
-* Contributors: Chris Lalancette, Jeffery Hsu
-
-25.0.0 (2023-12-26)
--------------------
-* Updated GenericSubscription to AnySubscriptionCallback (`#1928 <https://github.com/ros2/rclcpp/issues/1928>`_)
-* make type support helper supported for service (`#2209 <https://github.com/ros2/rclcpp/issues/2209>`_)
-* Adding QoS to subscription options (`#2323 <https://github.com/ros2/rclcpp/issues/2323>`_)
-* Switch to target_link_libraries. (`#2374 <https://github.com/ros2/rclcpp/issues/2374>`_)
-* aligh with rcl that a rosout publisher of a node might not exist (`#2357 <https://github.com/ros2/rclcpp/issues/2357>`_)
-* Fix data race in EventHandlerBase (`#2349 <https://github.com/ros2/rclcpp/issues/2349>`_)
-* Support users holding onto shared pointers in the message memory pool (`#2336 <https://github.com/ros2/rclcpp/issues/2336>`_)
-* Contributors: Chen Lihui, Chris Lalancette, DensoADAS, Lucas Wendland, mauropasse
-
-24.0.0 (2023-11-06)
--------------------
-* fix (signal_handler.hpp): spelling (`#2356 <https://github.com/ros2/rclcpp/issues/2356>`_)
-* Updates to not use std::move in some places. (`#2353 <https://github.com/ros2/rclcpp/issues/2353>`_)
-* rclcpp::Time::max() clock type support. (`#2352 <https://github.com/ros2/rclcpp/issues/2352>`_)
-* Serialized Messages with Topic Statistics (`#2274 <https://github.com/ros2/rclcpp/issues/2274>`_)
-* Add a custom deleter when constructing rcl_service_t (`#2351 <https://github.com/ros2/rclcpp/issues/2351>`_)
-* Disable the loaned messages inside the executor. (`#2335 <https://github.com/ros2/rclcpp/issues/2335>`_)
-* Use message_info in SubscriptionTopicStatistics instead of typed message (`#2337 <https://github.com/ros2/rclcpp/issues/2337>`_)
-* Add missing 'enable_rosout' comments (`#2345 <https://github.com/ros2/rclcpp/issues/2345>`_)
-* Adjust rclcpp usage of type description service (`#2344 <https://github.com/ros2/rclcpp/issues/2344>`_)
-* address rate related flaky tests. (`#2329 <https://github.com/ros2/rclcpp/issues/2329>`_)
-* Fixes pointed out by the clang analyzer. (`#2339 <https://github.com/ros2/rclcpp/issues/2339>`_)
-* Remove useless ROSRate class (`#2326 <https://github.com/ros2/rclcpp/issues/2326>`_)
-* Contributors: Alexey Merzlyakov, Chris Lalancette, Jiaqi Li, Lucas Wendland, Michael Carroll, Michael Orlov, Tomoya Fujita, Zard-C
-
-23.2.0 (2023-10-09)
--------------------
-* add clients & services count (`#2072 <https://github.com/ros2/rclcpp/issues/2072>`_)
-* remove invalid sized allocation test for SerializedMessage. (`#2330 <https://github.com/ros2/rclcpp/issues/2330>`_)
-* Adding API to copy all parameters from one node to another (`#2304 <https://github.com/ros2/rclcpp/issues/2304>`_)
-* Contributors: Minju, Lee, Steve Macenski, Tomoya Fujita
-
-23.1.0 (2023-10-04)
--------------------
-* Add locking to protect the TimeSource::NodeState::node_base\_ (`#2320 <https://github.com/ros2/rclcpp/issues/2320>`_)
-* Update SignalHandler get_global_signal_handler to avoid complex types in static memory (`#2316 <https://github.com/ros2/rclcpp/issues/2316>`_)
-* Removing Old Connext Tests (`#2313 <https://github.com/ros2/rclcpp/issues/2313>`_)
-* Documentation for list_parameters  (`#2315 <https://github.com/ros2/rclcpp/issues/2315>`_)
-* Decouple rosout publisher init from node init. (`#2174 <https://github.com/ros2/rclcpp/issues/2174>`_)
-* fix the depth to relative in list_parameters (`#2300 <https://github.com/ros2/rclcpp/issues/2300>`_)
-* Contributors: Chris Lalancette, Lucas Wendland, Minju, Lee, Tomoya Fujita, Tully Foote
-
-23.0.0 (2023-09-08)
--------------------
-* Fix the return type of Rate::period. (`#2301 <https://github.com/ros2/rclcpp/issues/2301>`_)
-* Update API docs links in package READMEs (`#2302 <https://github.com/ros2/rclcpp/issues/2302>`_)
-* Cleanup flaky timers_manager tests. (`#2299 <https://github.com/ros2/rclcpp/issues/2299>`_)
-* Contributors: Chris Lalancette, Christophe Bedard
-
-22.2.0 (2023-09-07)
--------------------
-* Topic correct typeadapter deduction (`#2294 <https://github.com/ros2/rclcpp/issues/2294>`_)
-* Fix C++20 allocator construct deprecation (`#2292 <https://github.com/ros2/rclcpp/issues/2292>`_)
-* Make Rate to select the clock to work with (`#2123 <https://github.com/ros2/rclcpp/issues/2123>`_)
-* Correct the position of a comment. (`#2290 <https://github.com/ros2/rclcpp/issues/2290>`_)
-* Remove unnecessary lambda captures in the tests. (`#2289 <https://github.com/ros2/rclcpp/issues/2289>`_)
-* Add rcl_logging_interface as an explicit dependency. (`#2284 <https://github.com/ros2/rclcpp/issues/2284>`_)
-* Revamp list_parameters to be more efficient and easier to read. (`#2282 <https://github.com/ros2/rclcpp/issues/2282>`_)
-* Contributors: AiVerisimilitude, Alexey Merzlyakov, Chen Lihui, Chris Lalancette, Jiaqi Li
-
-22.1.0 (2023-08-21)
--------------------
-* Do not crash Executor when send_response fails due to client failure. (`#2276 <https://github.com/ros2/rclcpp/issues/2276>`_)
-* Adding Custom Unknown Type Error (`#2272 <https://github.com/ros2/rclcpp/issues/2272>`_)
-* Add a pimpl inside rclcpp::Node for future distro backports (`#2228 <https://github.com/ros2/rclcpp/issues/2228>`_)
-* Remove an unused variable from the events executor tests. (`#2270 <https://github.com/ros2/rclcpp/issues/2270>`_)
-* Add spin_all shortcut (`#2246 <https://github.com/ros2/rclcpp/issues/2246>`_)
-* Adding Missing Group Exceptions (`#2256 <https://github.com/ros2/rclcpp/issues/2256>`_)
-* Change associated clocks storage to unordered_set (`#2257 <https://github.com/ros2/rclcpp/issues/2257>`_)
-* associated clocks should be protected by mutex. (`#2255 <https://github.com/ros2/rclcpp/issues/2255>`_)
-* Instrument loaned message publication code path (`#2240 <https://github.com/ros2/rclcpp/issues/2240>`_)
-* Contributors: Chris Lalancette, Christophe Bedard, Emerson Knapp, Luca Della Vedova, Lucas Wendland, Tomoya Fujita, Tony Najjar
-
-22.0.0 (2023-07-11)
--------------------
-* Implement get_node_type_descriptions_interface for lifecyclenode and add smoke test for it (`#2237 <https://github.com/ros2/rclcpp/issues/2237>`_)
-* Add new node interface TypeDescriptionsInterface to provide GetTypeDescription service (`#2224 <https://github.com/ros2/rclcpp/issues/2224>`_)
-* Move always_false_v to detail namespace (`#2232 <https://github.com/ros2/rclcpp/issues/2232>`_)
-* Revamp the test_subscription.cpp tests. (`#2227 <https://github.com/ros2/rclcpp/issues/2227>`_)
-* warning: comparison of integer expressions of different signedness (`#2219 <https://github.com/ros2/rclcpp/issues/2219>`_)
-* Modifies timers API to select autostart state (`#2005 <https://github.com/ros2/rclcpp/issues/2005>`_)
-* Enable callback group tests for connextdds (`#2182 <https://github.com/ros2/rclcpp/issues/2182>`_)
-* Contributors: Chris Lalancette, Christopher Wecht, Eloy Briceno, Emerson Knapp, Nathan Wiebe Neufeldt, Tomoya Fujita
-
-21.3.0 (2023-06-12)
--------------------
-* Fix up misspellings of "receive". (`#2208 <https://github.com/ros2/rclcpp/issues/2208>`_)
-* Remove flaky stressAddRemoveNode test (`#2206 <https://github.com/ros2/rclcpp/issues/2206>`_)
-* Use TRACETOOLS\_ prefix for tracepoint-related macros (`#2162 <https://github.com/ros2/rclcpp/issues/2162>`_)
-* Contributors: Chris Lalancette, Christophe Bedard, Michael Carroll
-
-21.2.0 (2023-06-07)
--------------------
-* remove nolint since ament_cpplint updated for the c++17 header (`#2198 <https://github.com/ros2/rclcpp/issues/2198>`_)
-* Feature/available capacity of ipm (`#2173 <https://github.com/ros2/rclcpp/issues/2173>`_)
-* add mutex to protect events_executor current entity collection (`#2187 <https://github.com/ros2/rclcpp/issues/2187>`_)
-* Declare rclcpp callbacks before the rcl entities (`#2024 <https://github.com/ros2/rclcpp/issues/2024>`_)
-* Contributors: Alberto Soragna, Chen Lihui, DensoADAS, mauropasse
-
-21.1.1 (2023-05-11)
--------------------
-* Fix race condition in events-executor (`#2177 <https://github.com/ros2/rclcpp/issues/2177>`_)
-* Add missing stdexcept include (`#2186 <https://github.com/ros2/rclcpp/issues/2186>`_)
-* Fix a format-security warning when building with clang (`#2171 <https://github.com/ros2/rclcpp/issues/2171>`_)
-* Fix delivered message kind (`#2175 <https://github.com/ros2/rclcpp/issues/2175>`_)
-* Contributors: Alberto Soragna, Chris Lalancette, methylDragon, Øystein Sture
-
-21.1.0 (2023-04-27)
--------------------
-
-21.0.0 (2023-04-18)
--------------------
-* Add support for logging service. (`#2122 <https://github.com/ros2/rclcpp/issues/2122>`_)
-* Picking ABI-incompatible executor changes (`#2170 <https://github.com/ros2/rclcpp/issues/2170>`_)
-* add events-executor and timers-manager in rclcpp (`#2155 <https://github.com/ros2/rclcpp/issues/2155>`_)
-* Create common structures for executors to use (`#2143 <https://github.com/ros2/rclcpp/issues/2143>`_)
-* Implement deliver message kind (`#2168 <https://github.com/ros2/rclcpp/issues/2168>`_)
-* Contributors: Alberto Soragna, Lei Liu, Michael Carroll, methylDragon
-
 20.0.0 (2023-04-13)
 -------------------
 * applied tracepoints for ring_buffer (`#2091 <https://github.com/ros2/rclcpp/issues/2091>`_)

rclcpp/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.20)
+cmake_minimum_required(VERSION 3.12)
 
 project(rclcpp)
 
@@ -10,14 +10,11 @@ find_package(builtin_interfaces REQUIRED)
 find_package(libstatistics_collector REQUIRED)
 find_package(rcl REQUIRED)
 find_package(rcl_interfaces REQUIRED)
-find_package(rcl_logging_interface REQUIRED)
 find_package(rcl_yaml_param_parser REQUIRED)
 find_package(rcpputils REQUIRED)
 find_package(rcutils REQUIRED)
 find_package(rmw REQUIRED)
 find_package(rosgraph_msgs REQUIRED)
-find_package(rosidl_dynamic_typesupport REQUIRED)
-find_package(rosidl_runtime_c REQUIRED)
 find_package(rosidl_runtime_cpp REQUIRED)
 find_package(rosidl_typesupport_c REQUIRED)
 find_package(rosidl_typesupport_cpp REQUIRED)
@@ -45,9 +42,7 @@ set(${PROJECT_NAME}_SRCS
   src/rclcpp/clock.cpp
   src/rclcpp/context.cpp
   src/rclcpp/contexts/default_context.cpp
-  src/rclcpp/create_generic_client.cpp
   src/rclcpp/detail/add_guard_condition_to_rcl_wait_set.cpp
-  src/rclcpp/detail/resolve_intra_process_buffer_type.cpp
   src/rclcpp/detail/resolve_parameter_overrides.cpp
   src/rclcpp/detail/rmw_implementation_specific_payload.cpp
   src/rclcpp/detail/rmw_implementation_specific_publisher_payload.cpp
@@ -63,7 +58,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
@@ -75,9 +69,7 @@ set(${PROJECT_NAME}_SRCS
   src/rclcpp/experimental/executors/events_executor/events_executor.cpp
   src/rclcpp/experimental/timers_manager.cpp
   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
@@ -99,7 +91,6 @@ set(${PROJECT_NAME}_SRCS
   src/rclcpp/node_interfaces/node_time_source.cpp
   src/rclcpp/node_interfaces/node_timers.cpp
   src/rclcpp/node_interfaces/node_topics.cpp
-  src/rclcpp/node_interfaces/node_type_descriptions.cpp
   src/rclcpp/node_interfaces/node_waitables.cpp
   src/rclcpp/node_options.cpp
   src/rclcpp/parameter.cpp
@@ -113,7 +104,6 @@ set(${PROJECT_NAME}_SRCS
   src/rclcpp/qos.cpp
   src/rclcpp/event_handler.cpp
   src/rclcpp/qos_overriding_options.cpp
-  src/rclcpp/rate.cpp
   src/rclcpp/serialization.cpp
   src/rclcpp/serialized_message.cpp
   src/rclcpp/service.cpp
@@ -130,21 +120,6 @@ set(${PROJECT_NAME}_SRCS
   src/rclcpp/waitable.cpp
 )
 
-# By default, without the settings below, find_package(Python3) will attempt
-# to find the newest python version it can, and additionally will find the
-# most specific version.  For instance, on a system that has
-# /usr/bin/python3.10, /usr/bin/python3.11, and /usr/bin/python3, it will find
-# /usr/bin/python3.11, even if /usr/bin/python3 points to /usr/bin/python3.10.
-# The behavior we want is to prefer the "system" installed version unless the
-# user specifically tells us othewise through the Python3_EXECUTABLE hint.
-# Setting CMP0094 to NEW means that the search will stop after the first
-# python version is found.  Setting Python3_FIND_UNVERSIONED_NAMES means that
-# the search will prefer /usr/bin/python3 over /usr/bin/python3.11.  And that
-# latter functionality is only available in CMake 3.20 or later, so we need
-# at least that version.
-cmake_policy(SET CMP0094 NEW)
-set(Python3_FIND_UNVERSIONED_NAMES FIRST)
-
 find_package(Python3 REQUIRED COMPONENTS Interpreter)
 
 # "watch" template for changes
@@ -223,28 +198,22 @@ target_include_directories(${PROJECT_NAME} PUBLIC
   "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
   "$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>"
   "$<INSTALL_INTERFACE:include/${PROJECT_NAME}>")
-target_link_libraries(${PROJECT_NAME} PUBLIC
-  ${builtin_interfaces_TARGETS}
-  libstatistics_collector::libstatistics_collector
-  rcl::rcl
-  ${rcl_interfaces_TARGETS}
-  rcl_yaml_param_parser::rcl_yaml_param_parser
-  rcpputils::rcpputils
-  rcutils::rcutils
-  rmw::rmw
-  ${rosgraph_msgs_TARGETS}
-  rosidl_dynamic_typesupport::rosidl_dynamic_typesupport
-  rosidl_runtime_c::rosidl_runtime_c
-  rosidl_runtime_cpp::rosidl_runtime_cpp
-  rosidl_typesupport_cpp::rosidl_typesupport_cpp
-  ${statistics_msgs_TARGETS}
-  tracetools::tracetools
-  ${CMAKE_THREAD_LIBS_INIT}
-)
-
-target_link_libraries(${PROJECT_NAME} PRIVATE
-  ament_index_cpp::ament_index_cpp
-  rcl_logging_interface::rcl_logging_interface
+target_link_libraries(${PROJECT_NAME} ${CMAKE_THREAD_LIBS_INIT})
+# specific order: dependents before dependencies
+ament_target_dependencies(${PROJECT_NAME}
+  "ament_index_cpp"
+  "libstatistics_collector"
+  "rcl"
+  "rcl_interfaces"
+  "rcl_yaml_param_parser"
+  "rcpputils"
+  "rcutils"
+  "builtin_interfaces"
+  "rosgraph_msgs"
+  "rosidl_typesupport_cpp"
+  "rosidl_runtime_cpp"
+  "statistics_msgs"
+  "tracetools"
 )
 
 # Causes the visibility macros to use dllexport rather than dllimport,
@@ -266,23 +235,20 @@ ament_export_libraries(${PROJECT_NAME})
 # Export modern CMake targets
 ament_export_targets(${PROJECT_NAME})
 
-ament_export_dependencies(
-  builtin_interfaces
-  libstatistics_collector
-  rcl
-  rcl_interfaces
-  rcl_yaml_param_parser
-  rcpputils
-  rcutils
-  rmw
-  rosgraph_msgs
-  rosidl_dynamic_typesupport
-  rosidl_runtime_c
-  rosidl_runtime_cpp
-  rosidl_typesupport_cpp
-  statistics_msgs
-  tracetools
-)
+# specific order: dependents before dependencies
+ament_export_dependencies(ament_index_cpp)
+ament_export_dependencies(libstatistics_collector)
+ament_export_dependencies(rcl)
+ament_export_dependencies(rcpputils)
+ament_export_dependencies(rcutils)
+ament_export_dependencies(builtin_interfaces)
+ament_export_dependencies(rosgraph_msgs)
+ament_export_dependencies(rosidl_typesupport_cpp)
+ament_export_dependencies(rosidl_typesupport_c)
+ament_export_dependencies(rosidl_runtime_cpp)
+ament_export_dependencies(rcl_yaml_param_parser)
+ament_export_dependencies(statistics_msgs)
+ament_export_dependencies(tracetools)
 
 if(BUILD_TESTING)
   find_package(ament_lint_auto REQUIRED)
@@ -300,7 +266,7 @@ install(
 
 if(TEST cppcheck)
   # must set the property after ament_package()
-  set_tests_properties(cppcheck PROPERTIES TIMEOUT 1200)
+  set_tests_properties(cppcheck PROPERTIES TIMEOUT 500)
 endif()
 
 if(TEST cpplint)

rclcpp/QUALITY_DECLARATION.md

@@ -4,7 +4,7 @@ This document is a declaration of software quality for the `rclcpp` package, bas
 
 The package `rclcpp` claims to be in the **Quality Level 1** category when it is used with a **Quality Level 1** middleware.
 
-Below are the rationales, notes, and caveats for this claim, organized by each requirement listed in the [Package Requirements for Quality Level 1 in REP-2004](https://www.ros.org/reps/rep-2004.html).
+Below are the rationales, notes, and caveats for this claim, organized by each requirement listed in the [Package Quality Categories in REP-2004](https://www.ros.org/reps/rep-2004.html) of the ROS2 developer guide.
 
 ## Version Policy [1]
 
@@ -94,7 +94,7 @@ There is an automated test which runs a linter that ensures each file has at lea
 
 ### Feature Testing [4.i]
 
-Each feature in `rclcpp` has corresponding tests which simulate typical usage, and they are located in the [`test`](https://github.com/ros2/rclcpp/tree/rolling/test) directory.
+Each feature in `rclcpp` has corresponding tests which simulate typical usage, and they are located in the [`test`](https://github.com/ros2/rclcpp/tree/master/test) directory.
 New features are required to have tests before being added.
 
 Currently nightly test results can be seen here:
@@ -129,7 +129,7 @@ Current coverage statistics can be viewed [here](https://ci.ros2.org/job/nightly
 
 `rclcpp` follows the recommendations for performance testing of C/C++ code in the [ROS 2 Developer Guide](https://docs.ros.org/en/rolling/Contributing/Developer-Guide.html#performance), and opts to do performance analysis on each release rather than each change.
 
-The performance tests of `rclcpp` are located in the [test/benchmark directory](https://github.com/ros2/rclcpp/tree/rolling/rclcpp/test/benchmark).
+The performance tests of `rclcpp` are located in the [test/benchmark directory](https://github.com/ros2/rclcpp/tree/master/rclcpp/test/benchmark).
 
 System level performance benchmarks that cover features of `rclcpp` can be found at:
 * [Benchmarks](http://build.ros2.org/view/Rci/job/Rci__benchmark_ubuntu_focal_amd64/BenchmarkTable/)
@@ -139,7 +139,7 @@ Changes that introduce regressions in performance must be adequately justified i
 
 ### Linters and Static Analysis [4.v]
 
-`rclcpp` uses and passes all the ROS 2 standard linters and static analysis tools for a C++ package as described in the [ROS 2 Developer Guide](https://docs.ros.org/en/rolling/Contributing/Developer-Guide.html#linters-and-static-analysis). Passing implies there are no linter/static errors when testing against CI of supported platforms.
+`rclcpp` uses and passes all the ROS2 standard linters and static analysis tools for a C++ package as described in the [ROS 2 Developer Guide](https://docs.ros.org/en/rolling/Contributing/Developer-Guide.html#linters-and-static-analysis). Passing implies there are no linter/static errors when testing against CI of supported platforms.
 
 Currently nightly test results can be seen here:
 * [linux-aarch64_release](https://ci.ros2.org/view/nightly/job/nightly_linux-aarch64_release/lastBuild/testReport/rclcpp/)
@@ -163,49 +163,49 @@ It also has several test dependencies, which do not affect the resulting quality
 
 The `libstatistics_collector` package provides lightweight aggregation utilities to collect statistics and measure message metrics.
 
-It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros-tooling/libstatistics_collector/tree/rolling/QUALITY_DECLARATION.md).
+It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros-tooling/libstatistics_collector/tree/master/QUALITY_DECLARATION.md).
 
 #### `rcl`
 
 `rcl` a library to support implementation of language specific ROS 2 Client Libraries.
 
-It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/rcl/blob/rolling/rcl/QUALITY_DECLARATION.md).
+It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/rcl/blob/master/rcl/QUALITY_DECLARATION.md).
 
 #### `rcl_yaml_param_parser`
 
 The `rcl_yaml_param_parser` package provides an API that is used to parse YAML configuration files which may be used to configure ROS and specific nodes.
 
-It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/rcl/tree/rolling/rcl_yaml_param_parser/QUALITY_DECLARATION.md).
+It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/rcl/tree/master/rcl_yaml_param_parser/QUALITY_DECLARATION.md).
 
 #### `rcpputils`
 
 The `rcpputils` package provides an API which contains common utilities and data structures useful when programming in C++.
 
-It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/rcpputils/blob/rolling/QUALITY_DECLARATION.md).
+It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/rcpputils/blob/master/QUALITY_DECLARATION.md).
 
 #### `rcutils`
 
 The `rcutils` package provides an API which contains common utilities and data structures useful when programming in C.
 
-It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/rcutils/blob/rolling/QUALITY_DECLARATION.md).
+It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/rcutils/blob/master/QUALITY_DECLARATION.md).
 
 #### `rmw`
 
 `rmw` is the ROS 2 middleware library.
 
-It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/rmw/blob/rolling/rmw/QUALITY_DECLARATION.md).
+It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/rmw/blob/master/rmw/QUALITY_DECLARATION.md).
 
 #### `statistics_msgs`
 
 The `statistics_msgs` package contains ROS 2 message definitions for reporting statistics for topics and system resources.
 
-It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/rcl_interfaces/blob/rolling/statistics_msgs/QUALITY_DECLARATION.md).
+It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/rcl_interfaces/blob/master/statistics_msgs/QUALITY_DECLARATION.md).
 
 #### `tracetools`
 
 The `tracetools` package provides utilities for instrumenting the code in `rclcpp` so that it may be traced for debugging and performance analysis.
 
-It is **Quality Level 1**, see its [Quality Declaration document](https://github.com/ros2/ros2_tracing/blob/rolling/tracetools/QUALITY_DECLARATION.md).
+It is **Quality Level 1**, see its [Quality Declaration document](https://gitlab.com/ros-tracing/ros2_tracing/-/blob/master/tracetools/QUALITY_DECLARATION.md).
 
 ### Direct Runtime non-ROS Dependency [5.iii]
 

rclcpp/README.md

@@ -2,7 +2,7 @@
 
 The ROS client library in C++.
 
-The link to the latest rclcpp API documentation, which includes a complete list of its main components and features, can be found on the [rclcpp package info page](https://docs.ros.org/en/rolling/p/rclcpp).
+Visit the [rclcpp API documentation](http://docs.ros2.org/latest/api/rclcpp/) for a complete list of its main components and features.
 
 ## Quality Declaration
 

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

@@ -45,9 +45,9 @@ struct AnyExecutable
   rclcpp::ClientBase::SharedPtr client;
   rclcpp::Waitable::SharedPtr waitable;
   // These are used to keep the scope on the containing items
-  rclcpp::CallbackGroup::SharedPtr callback_group {nullptr};
-  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base {nullptr};
-  std::shared_ptr<void> data {nullptr};
+  rclcpp::CallbackGroup::SharedPtr callback_group;
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base;
+  std::shared_ptr<void> data;
 };
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/any_service_callback.hpp

@@ -156,7 +156,7 @@ public:
     const std::shared_ptr<rmw_request_id_t> & request_header,
     std::shared_ptr<typename ServiceT::Request> request)
   {
-    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), false);
+    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.
@@ -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>();
@@ -184,7 +182,7 @@ public:
       const auto & cb = std::get<SharedPtrWithRequestHeaderCallback>(callback_);
       cb(request_header, std::move(request), response);
     }
-    TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
+    TRACEPOINT(callback_end, static_cast<const void *>(this));
     return response;
   }
 
@@ -193,9 +191,9 @@ public:
 #ifndef TRACETOOLS_DISABLED
     std::visit(
       [this](auto && arg) {
-        if (TRACETOOLS_TRACEPOINT_ENABLED(rclcpp_callback_register)) {
+        if (TRACEPOINT_ENABLED(rclcpp_callback_register)) {
           char * symbol = tracetools::get_symbol(arg);
-          TRACETOOLS_DO_TRACEPOINT(
+          DO_TRACEPOINT(
             rclcpp_callback_register,
             static_cast<const void *>(this),
             symbol);

rclcpp/include/rclcpp/any_subscription_callback.hpp

@@ -20,7 +20,7 @@
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
-#include <variant>
+#include <variant>  // NOLINT[build/include_order]
 
 #include "rosidl_runtime_cpp/traits.hpp"
 #include "tracetools/tracetools.h"
@@ -30,19 +30,19 @@
 #include "rclcpp/detail/subscription_callback_type_helper.hpp"
 #include "rclcpp/function_traits.hpp"
 #include "rclcpp/message_info.hpp"
-#include "rclcpp/serialization.hpp"
 #include "rclcpp/serialized_message.hpp"
 #include "rclcpp/type_adapter.hpp"
 
+
+template<class>
+inline constexpr bool always_false_v = false;
+
 namespace rclcpp
 {
 
 namespace detail
 {
 
-template<class>
-inline constexpr bool always_false_v = false;
-
 template<typename MessageT, typename AllocatorT>
 struct MessageDeleterHelper
 {
@@ -158,14 +158,13 @@ struct AnySubscriptionCallbackPossibleTypes
 template<
   typename MessageT,
   typename AllocatorT,
-  bool is_adapted_type = rclcpp::TypeAdapter<MessageT>::is_specialized::value,
-  bool is_serialized_type = serialization_traits::is_serialized_message_class<MessageT>::value
+  bool is_adapted_type = rclcpp::TypeAdapter<MessageT>::is_specialized::value
 >
 struct AnySubscriptionCallbackHelper;
 
 /// Specialization for when MessageT is not a TypeAdapter.
 template<typename MessageT, typename AllocatorT>
-struct AnySubscriptionCallbackHelper<MessageT, AllocatorT, false, false>
+struct AnySubscriptionCallbackHelper<MessageT, AllocatorT, false>
 {
   using CallbackTypes = AnySubscriptionCallbackPossibleTypes<MessageT, AllocatorT>;
 
@@ -195,7 +194,7 @@ struct AnySubscriptionCallbackHelper<MessageT, AllocatorT, false, false>
 
 /// Specialization for when MessageT is a TypeAdapter.
 template<typename MessageT, typename AllocatorT>
-struct AnySubscriptionCallbackHelper<MessageT, AllocatorT, true, false>
+struct AnySubscriptionCallbackHelper<MessageT, AllocatorT, true>
 {
   using CallbackTypes = AnySubscriptionCallbackPossibleTypes<MessageT, AllocatorT>;
 
@@ -233,26 +232,6 @@ struct AnySubscriptionCallbackHelper<MessageT, AllocatorT, true, false>
   >;
 };
 
-/// Specialization for when MessageT is a SerializedMessage to exclude duplicated declarations.
-template<typename MessageT, typename AllocatorT>
-struct AnySubscriptionCallbackHelper<MessageT, AllocatorT, false, true>
-{
-  using CallbackTypes = AnySubscriptionCallbackPossibleTypes<MessageT, AllocatorT>;
-
-  using variant_type = std::variant<
-    typename CallbackTypes::ConstRefSerializedMessageCallback,
-    typename CallbackTypes::ConstRefSerializedMessageWithInfoCallback,
-    typename CallbackTypes::UniquePtrSerializedMessageCallback,
-    typename CallbackTypes::UniquePtrSerializedMessageWithInfoCallback,
-    typename CallbackTypes::SharedConstPtrSerializedMessageCallback,
-    typename CallbackTypes::SharedConstPtrSerializedMessageWithInfoCallback,
-    typename CallbackTypes::ConstRefSharedConstPtrSerializedMessageCallback,
-    typename CallbackTypes::ConstRefSharedConstPtrSerializedMessageWithInfoCallback,
-    typename CallbackTypes::SharedPtrSerializedMessageCallback,
-    typename CallbackTypes::SharedPtrSerializedMessageWithInfoCallback
-  >;
-};
-
 }  // namespace detail
 
 template<
@@ -393,12 +372,58 @@ public:
     // converted to one another, e.g. shared_ptr and unique_ptr.
     using scbth = detail::SubscriptionCallbackTypeHelper<MessageT, CallbackT>;
 
-    callback_variant_ = static_cast<typename scbth::callback_type>(callback);
+    // Determine if the given CallbackT is a deprecated signature or not.
+    constexpr auto is_deprecated =
+      rclcpp::function_traits::same_arguments<
+      typename scbth::callback_type,
+      std::function<void(std::shared_ptr<MessageT>)>
+      >::value
+      ||
+      rclcpp::function_traits::same_arguments<
+      typename scbth::callback_type,
+      std::function<void(std::shared_ptr<MessageT>, const rclcpp::MessageInfo &)>
+      >::value;
+
+    // Use the discovered type to force the type of callback when assigning
+    // into the variant.
+    if constexpr (is_deprecated) {
+      // If deprecated, call sub-routine that is deprecated.
+      set_deprecated(static_cast<typename scbth::callback_type>(callback));
+    } else {
+      // Otherwise just assign it.
+      callback_variant_ = static_cast<typename scbth::callback_type>(callback);
+    }
 
     // Return copy of self for easier testing, normally will be compiled out.
     return *this;
   }
 
+  /// Function for shared_ptr to non-const MessageT, which is deprecated.
+  template<typename SetT>
+#if !defined(RCLCPP_AVOID_DEPRECATIONS_FOR_UNIT_TESTS)
+  // suppress deprecation warnings in `test_any_subscription_callback.cpp`
+  [[deprecated("use 'void(std::shared_ptr<const MessageT>)' instead")]]
+#endif
+  void
+  set_deprecated(std::function<void(std::shared_ptr<SetT>)> callback)
+  {
+    callback_variant_ = callback;
+  }
+
+  /// Function for shared_ptr to non-const MessageT with MessageInfo, which is deprecated.
+  template<typename SetT>
+#if !defined(RCLCPP_AVOID_DEPRECATIONS_FOR_UNIT_TESTS)
+  // suppress deprecation warnings in `test_any_subscription_callback.cpp`
+  [[deprecated(
+          "use 'void(std::shared_ptr<const MessageT>, const rclcpp::MessageInfo &)' instead"
+  )]]
+#endif
+  void
+  set_deprecated(std::function<void(std::shared_ptr<SetT>, const rclcpp::MessageInfo &)> callback)
+  {
+    callback_variant_ = callback;
+  }
+
   std::unique_ptr<ROSMessageType, ROSMessageTypeDeleter>
   create_ros_unique_ptr_from_ros_shared_ptr_message(
     const std::shared_ptr<const ROSMessageType> & message)
@@ -462,14 +487,12 @@ public:
   }
 
   // Dispatch when input is a ros message and the output could be anything.
-  template<typename TMsg = ROSMessageType>
-  typename std::enable_if<!serialization_traits::is_serialized_message_class<TMsg>::value,
-    void>::type
+  void
   dispatch(
     std::shared_ptr<ROSMessageType> message,
     const rclcpp::MessageInfo & message_info)
   {
-    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), false);
+    TRACEPOINT(callback_start, static_cast<const void *>(this), false);
     // Check if the variant is "unset", throw if it is.
     if (callback_variant_.index() == 0) {
       if (std::get<0>(callback_variant_) == nullptr) {
@@ -557,19 +580,19 @@ public:
         }
         // condition to catch unhandled callback types
         else {  // NOLINT[readability/braces]
-          static_assert(detail::always_false_v<T>, "unhandled callback type");
+          static_assert(always_false_v<T>, "unhandled callback type");
         }
       }, callback_variant_);
-    TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
+    TRACEPOINT(callback_end, static_cast<const void *>(this));
   }
 
   // Dispatch when input is a serialized message and the output could be anything.
   void
   dispatch(
-    std::shared_ptr<const rclcpp::SerializedMessage> serialized_message,
+    std::shared_ptr<rclcpp::SerializedMessage> serialized_message,
     const rclcpp::MessageInfo & message_info)
   {
-    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), false);
+    TRACEPOINT(callback_start, static_cast<const void *>(this), false);
     // Check if the variant is "unset", throw if it is.
     if (callback_variant_.index() == 0) {
       if (std::get<0>(callback_variant_) == nullptr) {
@@ -637,10 +660,10 @@ public:
         }
         // condition to catch unhandled callback types
         else {  // NOLINT[readability/braces]
-          static_assert(detail::always_false_v<T>, "unhandled callback type");
+          static_assert(always_false_v<T>, "unhandled callback type");
         }
       }, callback_variant_);
-    TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
+    TRACEPOINT(callback_end, static_cast<const void *>(this));
   }
 
   void
@@ -648,7 +671,7 @@ public:
     std::shared_ptr<const SubscribedType> message,
     const rclcpp::MessageInfo & message_info)
   {
-    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), true);
+    TRACEPOINT(callback_start, static_cast<const void *>(this), true);
     // Check if the variant is "unset", throw if it is.
     if (callback_variant_.index() == 0) {
       if (std::get<0>(callback_variant_) == nullptr) {
@@ -767,10 +790,10 @@ public:
         }
         // condition to catch unhandled callback types
         else {  // NOLINT[readability/braces]
-          static_assert(detail::always_false_v<T>, "unhandled callback type");
+          static_assert(always_false_v<T>, "unhandled callback type");
         }
       }, callback_variant_);
-    TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
+    TRACEPOINT(callback_end, static_cast<const void *>(this));
   }
 
   void
@@ -778,7 +801,7 @@ public:
     std::unique_ptr<SubscribedType, SubscribedTypeDeleter> message,
     const rclcpp::MessageInfo & message_info)
   {
-    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), true);
+    TRACEPOINT(callback_start, static_cast<const void *>(this), true);
     // Check if the variant is "unset", throw if it is.
     if (callback_variant_.index() == 0) {
       if (std::get<0>(callback_variant_) == nullptr) {
@@ -901,10 +924,10 @@ public:
         }
         // condition to catch unhandled callback types
         else {  // NOLINT[readability/braces]
-          static_assert(detail::always_false_v<T>, "unhandled callback type");
+          static_assert(always_false_v<T>, "unhandled callback type");
         }
       }, callback_variant_);
-    TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
+    TRACEPOINT(callback_end, static_cast<const void *>(this));
   }
 
   constexpr
@@ -942,9 +965,9 @@ public:
 #ifndef TRACETOOLS_DISABLED
     std::visit(
       [this](auto && callback) {
-        if (TRACETOOLS_TRACEPOINT_ENABLED(rclcpp_callback_register)) {
+        if (TRACEPOINT_ENABLED(rclcpp_callback_register)) {
           char * symbol = tracetools::get_symbol(callback);
-          TRACETOOLS_DO_TRACEPOINT(
+          DO_TRACEPOINT(
             rclcpp_callback_register,
             static_cast<const void *>(this),
             symbol);

rclcpp/include/rclcpp/callback_group.hpp

@@ -89,7 +89,48 @@ public:
    * added to the executor in either case.
    *
    * \param[in] group_type The type of the callback group.
-   * \param[in] context A weak pointer to the context associated with this 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'
+   * 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] get_node_context Lambda to retrieve the node context when
+   *   checking that the creating node is valid and using the guard condition.
    * \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.
@@ -97,7 +138,7 @@ public:
   RCLCPP_PUBLIC
   explicit CallbackGroup(
     CallbackGroupType group_type,
-    rclcpp::Context::WeakPtr context,
+    std::function<rclcpp::Context::SharedPtr(void)> get_node_context,
     bool automatically_add_to_executor_with_node = true);
 
   /// Default destructor.
@@ -144,8 +185,7 @@ public:
    * \return the number of entities in the callback group.
    */
   RCLCPP_PUBLIC
-  size_t
-  size() const;
+  size_t size() const;
 
   /// Return a reference to the 'can be taken' atomic boolean.
   /**
@@ -177,8 +217,7 @@ public:
    * \param[in] waitable_fuinc Function to execute for each waitable
    */
   RCLCPP_PUBLIC
-  void
-  collect_all_ptrs(
+  void collect_all_ptrs(
     std::function<void(const rclcpp::SubscriptionBase::SharedPtr &)> sub_func,
     std::function<void(const rclcpp::ServiceBase::SharedPtr &)> service_func,
     std::function<void(const rclcpp::ClientBase::SharedPtr &)> client_func,
@@ -210,6 +249,16 @@ public:
   bool
   automatically_add_to_executor_with_node() const;
 
+  /// Retrieve the guard condition used to signal changes to this callback group.
+  /**
+   * \param[in] context_ptr context to use when creating the guard condition
+   * \return guard condition if it is valid, otherwise nullptr.
+   */
+  [[deprecated("Use get_notify_guard_condition() without arguments")]]
+  RCLCPP_PUBLIC
+  rclcpp::GuardCondition::SharedPtr
+  get_notify_guard_condition(const rclcpp::Context::SharedPtr context_ptr);
+
   /// Retrieve the guard condition used to signal changes to this callback group.
   /**
    * \return guard condition if it is valid, otherwise nullptr.
@@ -269,7 +318,7 @@ protected:
   std::shared_ptr<rclcpp::GuardCondition> notify_guard_condition_ = nullptr;
   std::recursive_mutex notify_guard_condition_mutex_;
 
-  rclcpp::Context::WeakPtr context_;
+  std::function<rclcpp::Context::SharedPtr(void)> get_context_;
 
 private:
   template<typename TypeT, typename Function>

rclcpp/include/rclcpp/client.hpp

@@ -20,13 +20,13 @@
 #include <future>
 #include <memory>
 #include <mutex>
-#include <optional>
+#include <optional>  // NOLINT, cpplint doesn't think this is a cpp std header
 #include <sstream>
 #include <string>
 #include <tuple>
 #include <unordered_map>
 #include <utility>
-#include <variant>
+#include <variant>  // NOLINT
 #include <vector>
 
 #include "rcl/client.h"
@@ -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().
@@ -107,29 +115,6 @@ struct FutureAndRequestId
   /// Destructor.
   ~FutureAndRequestId() = default;
 };
-
-template<typename PendingRequestsT, typename AllocatorT = std::allocator<int64_t>>
-size_t
-prune_requests_older_than_impl(
-  PendingRequestsT & pending_requests,
-  std::mutex & pending_requests_mutex,
-  std::chrono::time_point<std::chrono::system_clock> time_point,
-  std::vector<int64_t, AllocatorT> * pruned_requests = nullptr)
-{
-  std::lock_guard guard(pending_requests_mutex);
-  auto old_size = pending_requests.size();
-  for (auto it = pending_requests.begin(), last = pending_requests.end(); it != last; ) {
-    if (it->second.first < time_point) {
-      if (pruned_requests) {
-        pruned_requests->push_back(it->first);
-      }
-      it = pending_requests.erase(it);
-    } else {
-      ++it;
-    }
-  }
-  return old_size - pending_requests.size();
-}
 }  // namespace detail
 
 namespace node_interfaces
@@ -378,16 +363,12 @@ protected:
   std::shared_ptr<rclcpp::Context> context_;
   rclcpp::Logger node_logger_;
 
-  std::recursive_mutex callback_mutex_;
-  // It is important to declare on_new_response_callback_ before
-  // client_handle_, so on destruction the client is
-  // destroyed first. Otherwise, the rmw client callback
-  // would point briefly to a destroyed function.
-  std::function<void(size_t)> on_new_response_callback_{nullptr};
-  // Declare client_handle_ after callback
   std::shared_ptr<rcl_client_t> client_handle_;
 
   std::atomic<bool> in_use_by_wait_set_{false};
+
+  std::recursive_mutex callback_mutex_;
+  std::function<void(size_t)> on_new_response_callback_{nullptr};
 };
 
 template<typename ServiceT>
@@ -428,6 +409,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 +463,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,
@@ -777,11 +767,19 @@ public:
     std::chrono::time_point<std::chrono::system_clock> time_point,
     std::vector<int64_t, AllocatorT> * pruned_requests = nullptr)
   {
-    return detail::prune_requests_older_than_impl(
-      pending_requests_,
-      pending_requests_mutex_,
-      time_point,
-      pruned_requests);
+    std::lock_guard guard(pending_requests_mutex_);
+    auto old_size = pending_requests_.size();
+    for (auto it = pending_requests_.begin(), last = pending_requests_.end(); it != last; ) {
+      if (it->second.first < time_point) {
+        if (pruned_requests) {
+          pruned_requests->push_back(it->first);
+        }
+        it = pending_requests_.erase(it);
+      } else {
+        ++it;
+      }
+    }
+    return old_size - pending_requests_.size();
   }
 
   /// Configure client introspection.
@@ -789,9 +787,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(
@@ -850,7 +845,7 @@ protected:
         "Received invalid sequence number. Ignoring...");
       return std::nullopt;
     }
-    std::optional<CallbackInfoVariant> value = std::move(it->second.second);
+    auto value = std::move(it->second.second);
     this->pending_requests_.erase(request_number);
     return value;
   }

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.
    */
@@ -214,13 +207,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.
    *
@@ -229,7 +222,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
@@ -257,117 +250,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/context.hpp

@@ -26,7 +26,6 @@
 #include <unordered_set>
 #include <utility>
 #include <vector>
-#include <stdexcept>
 
 #include "rcl/context.h"
 #include "rcl/guard_condition.h"

rclcpp/include/rclcpp/copy_all_parameter_values.hpp

@@ -1,82 +0,0 @@
-// Copyright 2023 Open Navigation LLC
-//
-// 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__COPY_ALL_PARAMETER_VALUES_HPP_
-#define RCLCPP__COPY_ALL_PARAMETER_VALUES_HPP_
-
-#include <string>
-#include <vector>
-
-#include "rcl_interfaces/srv/list_parameters.hpp"
-#include "rcl_interfaces/msg/parameter_descriptor.hpp"
-#include "rcl_interfaces/msg/set_parameters_result.hpp"
-
-#include "rclcpp/parameter.hpp"
-#include "rclcpp/logger.hpp"
-#include "rclcpp/logging.hpp"
-
-namespace rclcpp
-{
-
-/**
- * Copy all parameters from one source node to another destination node.
- * May throw exceptions if parameters from source are uninitialized or undeclared.
- * \param source Node to copy parameters from
- * \param destination Node to copy parameters to
- * \param override_existing_params Default false. Whether to override existing destination params
- * if both the source and destination contain the same parameter.
- */
-template<typename NodeT1, typename NodeT2>
-void
-copy_all_parameter_values(
-  const NodeT1 & source, const NodeT2 & destination, const bool override_existing_params = false)
-{
-  using Parameters = std::vector<rclcpp::Parameter>;
-  using Descriptions = std::vector<rcl_interfaces::msg::ParameterDescriptor>;
-  auto source_params = source->get_node_parameters_interface();
-  auto dest_params = destination->get_node_parameters_interface();
-  rclcpp::Logger logger = destination->get_node_logging_interface()->get_logger();
-
-  std::vector<std::string> param_names = source_params->list_parameters({}, 0).names;
-  Parameters params = source_params->get_parameters(param_names);
-  Descriptions descriptions = source_params->describe_parameters(param_names);
-
-  for (unsigned int idx = 0; idx != params.size(); idx++) {
-    if (!dest_params->has_parameter(params[idx].get_name())) {
-      dest_params->declare_parameter(
-        params[idx].get_name(), params[idx].get_parameter_value(), descriptions[idx]);
-    } else if (override_existing_params) {
-      try {
-        rcl_interfaces::msg::SetParametersResult result =
-          dest_params->set_parameters_atomically({params[idx]});
-        if (!result.successful) {
-          // Parameter update rejected or read-only
-          RCLCPP_WARN(
-            logger,
-            "Unable to set parameter (%s): %s!",
-            params[idx].get_name().c_str(), result.reason.c_str());
-        }
-      } catch (const rclcpp::exceptions::InvalidParameterTypeException & e) {
-        RCLCPP_WARN(
-          logger,
-          "Unable to set parameter (%s): incompatable parameter type (%s)!",
-          params[idx].get_name().c_str(), e.what());
-      }
-    }
-  }
-}
-
-}  // namespace rclcpp
-
-#endif  // RCLCPP__COPY_ALL_PARAMETER_VALUES_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_client.hpp

@@ -1,90 +0,0 @@
-// Copyright 2023 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_CLIENT_HPP_
-#define RCLCPP__CREATE_GENERIC_CLIENT_HPP_
-
-#include <memory>
-#include <string>
-
-#include "rclcpp/generic_client.hpp"
-#include "rclcpp/node_interfaces/get_node_base_interface.hpp"
-#include "rclcpp/node_interfaces/get_node_graph_interface.hpp"
-#include "rclcpp/node_interfaces/get_node_services_interface.hpp"
-#include "rclcpp/node_interfaces/node_base_interface.hpp"
-#include "rclcpp/node_interfaces/node_graph_interface.hpp"
-#include "rclcpp/node_interfaces/node_services_interface.hpp"
-#include "rclcpp/qos.hpp"
-
-namespace rclcpp
-{
-/// Create a generic service client with a name of given type.
-/**
- * \param[in] node_base NodeBaseInterface implementation of the node on which
- *  to create the client.
- * \param[in] node_graph NodeGraphInterface implementation of the node on which
- *  to create the client.
- * \param[in] node_services NodeServicesInterface implementation of the node on
- *  which to create the client.
- * \param[in] service_name The name on which the service is accessible.
- * \param[in] service_type The name of service type, e.g. "test_msgs/srv/BasicTypes"
- * \param[in] qos Quality of service profile for client.
- * \param[in] group Callback group to handle the reply to service calls.
- * \return Shared pointer to the created client.
- */
-RCLCPP_PUBLIC
-rclcpp::GenericClient::SharedPtr
-create_generic_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 std::string & service_type,
-  const rclcpp::QoS & qos = rclcpp::ServicesQoS(),
-  rclcpp::CallbackGroup::SharedPtr group = nullptr);
-
-/// Create a generic service client with a name of given type.
-/**
- * The NodeT type needs to have NodeBaseInterface implementation, NodeGraphInterface implementation
- * and NodeServicesInterface implementation of the node which to create the client.
- *
- * \param[in] node The node on which to create the client.
- * \param[in] service_name The name on which the service is accessible.
- * \param[in] service_type The name of service type, e.g. "test_msgs/srv/BasicTypes"
- * \param[in] qos Quality of service profile for client.
- * \param[in] group Callback group to handle the reply to service calls.
- * \return Shared pointer to the created client.
- */
-template<typename NodeT>
-rclcpp::GenericClient::SharedPtr
-create_generic_client(
-  NodeT node,
-  const std::string & service_name,
-  const std::string & service_type,
-  const rclcpp::QoS & qos = rclcpp::ServicesQoS(),
-  rclcpp::CallbackGroup::SharedPtr group = nullptr)
-{
-  return create_generic_client(
-    rclcpp::node_interfaces::get_node_base_interface(node),
-    rclcpp::node_interfaces::get_node_graph_interface(node),
-    rclcpp::node_interfaces::get_node_services_interface(node),
-    service_name,
-    service_type,
-    qos,
-    group
-  );
-}
-}  // namespace rclcpp
-
-#endif  // RCLCPP__CREATE_GENERIC_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/create_generic_subscription.hpp

@@ -45,15 +45,13 @@ namespace rclcpp
  * Not all publisher options are currently respected, the only relevant options for this
  * publisher are `event_callbacks`, `use_default_callbacks`, and `%callback_group`.
  */
-template<
-  typename CallbackT,
-  typename AllocatorT = std::allocator<void>>
+template<typename AllocatorT = std::allocator<void>>
 std::shared_ptr<GenericSubscription> create_generic_subscription(
   rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr topics_interface,
   const std::string & topic_name,
   const std::string & topic_type,
   const rclcpp::QoS & qos,
-  CallbackT && callback,
+  std::function<void(std::shared_ptr<rclcpp::SerializedMessage>)> callback,
   const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options = (
     rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()
   )
@@ -62,20 +60,13 @@ std::shared_ptr<GenericSubscription> create_generic_subscription(
   auto ts_lib = rclcpp::get_typesupport_library(
     topic_type, "rosidl_typesupport_cpp");
 
-  auto allocator = options.get_allocator();
-
-  using rclcpp::AnySubscriptionCallback;
-  AnySubscriptionCallback<rclcpp::SerializedMessage, AllocatorT>
-  any_subscription_callback(*allocator);
-  any_subscription_callback.set(std::forward<CallbackT>(callback));
-
   auto subscription = std::make_shared<GenericSubscription>(
     topics_interface->get_node_base_interface(),
     std::move(ts_lib),
     topic_name,
     topic_type,
     qos,
-    any_subscription_callback,
+    callback,
     options);
 
   topics_interface->add_subscription(subscription, options.callback_group);

rclcpp/include/rclcpp/create_subscription.hpp

@@ -50,8 +50,8 @@ template<
   typename SubscriptionT,
   typename MessageMemoryStrategyT,
   typename NodeParametersT,
-  typename NodeTopicsT
->
+  typename NodeTopicsT,
+  typename ROSMessageType = typename SubscriptionT::ROSMessageType>
 typename std::shared_ptr<SubscriptionT>
 create_subscription(
   NodeParametersT & node_parameters,
@@ -70,7 +70,7 @@ create_subscription(
   using rclcpp::node_interfaces::get_node_topics_interface;
   auto node_topics_interface = get_node_topics_interface(node_topics);
 
-  std::shared_ptr<rclcpp::topic_statistics::SubscriptionTopicStatistics>
+  std::shared_ptr<rclcpp::topic_statistics::SubscriptionTopicStatistics<ROSMessageType>>
   subscription_topic_stats = nullptr;
 
   if (rclcpp::detail::resolve_enable_topic_statistics(
@@ -80,7 +80,8 @@ create_subscription(
     if (options.topic_stats_options.publish_period <= std::chrono::milliseconds(0)) {
       throw std::invalid_argument(
               "topic_stats_options.publish_period must be greater than 0, specified value of " +
-              std::to_string(options.topic_stats_options.publish_period.count()) + " ms");
+              std::to_string(options.topic_stats_options.publish_period.count()) +
+              " ms");
     }
 
     std::shared_ptr<Publisher<statistics_msgs::msg::MetricsMessage>>
@@ -88,14 +89,14 @@ create_subscription(
       node_parameters,
       node_topics_interface,
       options.topic_stats_options.publish_topic,
-      options.topic_stats_options.qos);
+      qos);
 
-    subscription_topic_stats =
-      std::make_shared<rclcpp::topic_statistics::SubscriptionTopicStatistics>(
-      node_topics_interface->get_node_base_interface()->get_name(), publisher);
+    subscription_topic_stats = std::make_shared<
+      rclcpp::topic_statistics::SubscriptionTopicStatistics<ROSMessageType>
+      >(node_topics_interface->get_node_base_interface()->get_name(), publisher);
 
     std::weak_ptr<
-      rclcpp::topic_statistics::SubscriptionTopicStatistics
+      rclcpp::topic_statistics::SubscriptionTopicStatistics<ROSMessageType>
     > weak_subscription_topic_stats(subscription_topic_stats);
     auto sub_call_back = [weak_subscription_topic_stats]() {
         auto subscription_topic_stats = weak_subscription_topic_stats.lock();

rclcpp/include/rclcpp/create_timer.hpp

@@ -90,8 +90,7 @@ create_timer(
   rclcpp::Clock::SharedPtr clock,
   rclcpp::Duration period,
   CallbackT && callback,
-  rclcpp::CallbackGroup::SharedPtr group = nullptr,
-  bool autostart = true)
+  rclcpp::CallbackGroup::SharedPtr group = nullptr)
 {
   return create_timer(
     clock,
@@ -99,8 +98,7 @@ create_timer(
     std::forward<CallbackT>(callback),
     group,
     node_base.get(),
-    node_timers.get(),
-    autostart);
+    node_timers.get());
 }
 
 /// Create a timer with a given clock
@@ -111,8 +109,7 @@ create_timer(
   rclcpp::Clock::SharedPtr clock,
   rclcpp::Duration period,
   CallbackT && callback,
-  rclcpp::CallbackGroup::SharedPtr group = nullptr,
-  bool autostart = true)
+  rclcpp::CallbackGroup::SharedPtr group = nullptr)
 {
   return create_timer(
     clock,
@@ -120,8 +117,7 @@ create_timer(
     std::forward<CallbackT>(callback),
     group,
     rclcpp::node_interfaces::get_node_base_interface(node).get(),
-    rclcpp::node_interfaces::get_node_timers_interface(node).get(),
-    autostart);
+    rclcpp::node_interfaces::get_node_timers_interface(node).get());
 }
 
 /// Convenience method to create a general timer with node resources.
@@ -136,7 +132,6 @@ create_timer(
  * \param group callback group
  * \param node_base node base interface
  * \param node_timers node timer interface
- * \param autostart defines if the timer should start it's countdown on initialization or not.
  * \return shared pointer to a generic timer
  * \throws std::invalid_argument if either clock, node_base or node_timers
  * are nullptr, or period is negative or too large
@@ -149,8 +144,7 @@ create_timer(
   CallbackT callback,
   rclcpp::CallbackGroup::SharedPtr group,
   node_interfaces::NodeBaseInterface * node_base,
-  node_interfaces::NodeTimersInterface * node_timers,
-  bool autostart = true)
+  node_interfaces::NodeTimersInterface * node_timers)
 {
   if (clock == nullptr) {
     throw std::invalid_argument{"clock cannot be null"};
@@ -166,7 +160,7 @@ create_timer(
 
   // Add a new generic timer.
   auto timer = rclcpp::GenericTimer<CallbackT>::make_shared(
-    std::move(clock), period_ns, std::move(callback), node_base->get_context(), autostart);
+    std::move(clock), period_ns, std::move(callback), node_base->get_context());
   node_timers->add_timer(timer, group);
   return timer;
 }
@@ -193,8 +187,7 @@ create_wall_timer(
   CallbackT callback,
   rclcpp::CallbackGroup::SharedPtr group,
   node_interfaces::NodeBaseInterface * node_base,
-  node_interfaces::NodeTimersInterface * node_timers,
-  bool autostart = true)
+  node_interfaces::NodeTimersInterface * node_timers)
 {
   if (node_base == nullptr) {
     throw std::invalid_argument{"input node_base cannot be null"};
@@ -208,7 +201,7 @@ create_wall_timer(
 
   // Add a new wall timer.
   auto timer = rclcpp::WallTimer<CallbackT>::make_shared(
-    period_ns, std::move(callback), node_base->get_context(), autostart);
+    period_ns, std::move(callback), node_base->get_context());
   node_timers->add_timer(timer, group);
   return timer;
 }

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/detail/resolve_intra_process_buffer_type.hpp

@@ -47,11 +47,6 @@ resolve_intra_process_buffer_type(
   return resolved_buffer_type;
 }
 
-RCLCPP_PUBLIC
-rclcpp::IntraProcessBufferType
-resolve_intra_process_buffer_type(
-  const rclcpp::IntraProcessBufferType buffer_type);
-
 }  // namespace detail
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/duration.hpp

@@ -18,7 +18,6 @@
 #include <chrono>
 
 #include "builtin_interfaces/msg/duration.hpp"
-#include "builtin_interfaces/msg/time.hpp"
 #include "rcl/time.h"
 #include "rclcpp/visibility_control.hpp"
 
@@ -159,14 +158,6 @@ private:
   Duration() = default;
 };
 
-RCLCPP_PUBLIC
-builtin_interfaces::msg::Time
-operator+(const builtin_interfaces::msg::Time & lhs, const rclcpp::Duration & rhs);
-
-RCLCPP_PUBLIC
-builtin_interfaces::msg::Time
-operator-(const builtin_interfaces::msg::Time & lhs, const rclcpp::Duration & rhs);
-
 }  // namespace rclcpp
 
 #endif  // RCLCPP__DURATION_HPP_

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"
@@ -118,12 +117,12 @@ public:
   /// Add the Waitable to a wait set.
   RCLCPP_PUBLIC
   void
-  add_to_wait_set(rcl_wait_set_t & wait_set) override;
+  add_to_wait_set(rcl_wait_set_t * wait_set) override;
 
   /// Check if the Waitable is ready.
   RCLCPP_PUBLIC
   bool
-  is_ready(const rcl_wait_set_t & wait_set) override;
+  is_ready(rcl_wait_set_t * wait_set) override;
 
   /// Set a callback to be called when each new event instance occurs.
   /**
@@ -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
 {
@@ -266,16 +260,6 @@ public:
     }
   }
 
-  ~EventHandler()
-  {
-    // Since the rmw event listener holds a reference to the
-    // "on ready" callback, we need to clear it on destruction of this class.
-    // This clearing is not needed for other rclcpp entities like pub/subs, since
-    // they do own the underlying rmw entities, which are destroyed
-    // on their rclcpp destructors, thus no risk of dangling pointers.
-    clear_on_ready_callback();
-  }
-
   /// Take data so that the callback cannot be scheduled again
   std::shared_ptr<void>
   take_data() override
@@ -286,21 +270,21 @@ 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();
   }
 
   /// Execute any entities of the Waitable that are ready.
   void
-  execute(const std::shared_ptr<void> & data) override
+  execute(std::shared_ptr<void> & data) override
   {
     if (!data) {
       throw std::runtime_error("'data' is empty");
@@ -317,6 +301,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:
@@ -215,14 +206,6 @@ public:
   const std::vector<std::string> unknown_ros_args;
 };
 
-/// Thrown when an unknown type is passed
-class UnknownTypeError : public std::runtime_error
-{
-public:
-  explicit UnknownTypeError(const std::string & type)
-  : std::runtime_error("Unknown type: " + type) {}
-};
-
 /// Thrown when an invalid rclcpp::Event object or SharedPtr is encountered.
 class InvalidEventError : public std::runtime_error
 {
@@ -239,14 +222,6 @@ public:
   : std::runtime_error("event already registered") {}
 };
 
-/// Thrown when a callback group is missing from the node, when it wants to utilize the group.
-class MissingGroupNodeException : public std::runtime_error
-{
-public:
-  explicit MissingGroupNodeException(const std::string & obj_type)
-  : std::runtime_error("cannot create: " + obj_type + " , callback group not in node") {}
-};
-
 /// Thrown if passed parameters are inconsistent or invalid
 class InvalidParametersException : public std::runtime_error
 {

rclcpp/include/rclcpp/executor.hpp

@@ -19,6 +19,7 @@
 #include <cassert>
 #include <chrono>
 #include <cstdlib>
+#include <deque>
 #include <iostream>
 #include <list>
 #include <map>
@@ -272,63 +273,29 @@ public:
    * \param[in] node Shared pointer to the node to add.
    */
   RCLCPP_PUBLIC
-  virtual void
+  void
   spin_node_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node);
 
   /// Convenience function which takes Node and forwards NodeBaseInterface.
   RCLCPP_PUBLIC
-  virtual void
+  void
   spin_node_some(std::shared_ptr<rclcpp::Node> node);
 
-  /// Collect work once and execute all available work, optionally within a max duration.
+  /// Collect work once and execute all available work, optionally within a duration.
   /**
-   * This function can be overridden.
-   * The default implementation is suitable for a single-threaded model of execution.
-   * 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
-   * max_duration has been exceeded, and if it has it returns without starting
-   * the execution of the next piece of work.
-   *
-   * If a max_duration of 0 is given, then all of the collected work will be
-   * executed before the function returns.
+   * This function can be overridden. The default implementation is suitable for a
+   * single-threaded model of execution.
+   * Adding subscriptions, timers, services, etc. with blocking callbacks will cause this function
+   * to block (which may have unintended consequences).
    *
    * \param[in] max_duration The maximum amount of time to spend executing work, or 0 for no limit.
+   * Note that spin_some() may take longer than this time as it only returns once max_duration has
+   * been exceeded.
    */
   RCLCPP_PUBLIC
   virtual void
   spin_some(std::chrono::nanoseconds max_duration = std::chrono::nanoseconds(0));
 
-  /// Add a node, complete all immediately available work exhaustively, and remove the node.
-  /**
-   * \param[in] node Shared pointer to the node to add.
-   */
-  RCLCPP_PUBLIC
-  virtual void
-  spin_node_all(
-    rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node,
-    std::chrono::nanoseconds max_duration);
-
-  /// Convenience function which takes Node and forwards NodeBaseInterface.
-  RCLCPP_PUBLIC
-  virtual void
-  spin_node_all(std::shared_ptr<rclcpp::Node> node, std::chrono::nanoseconds max_duration);
-
   /// Collect and execute work repeatedly within a duration or until no more work is available.
   /**
    * This function can be overridden. The default implementation is suitable for a
@@ -378,12 +345,52 @@ public:
     const FutureT & future,
     std::chrono::duration<TimeRepT, TimeT> timeout = std::chrono::duration<TimeRepT, TimeT>(-1))
   {
-    return spin_until_future_complete_impl(
-      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout),
-      [&future](std::chrono::nanoseconds wait_time) {
-        return future.wait_for(wait_time);
+    // TODO(wjwwood): does not work recursively; can't call spin_node_until_future_complete
+    // inside a callback executed by an executor.
+
+    // Check the future before entering the while loop.
+    // If the future is already complete, don't try to spin.
+    std::future_status status = future.wait_for(std::chrono::seconds(0));
+    if (status == std::future_status::ready) {
+      return FutureReturnCode::SUCCESS;
+    }
+
+    auto end_time = std::chrono::steady_clock::now();
+    std::chrono::nanoseconds timeout_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
+      timeout);
+    if (timeout_ns > std::chrono::nanoseconds::zero()) {
+      end_time += timeout_ns;
+    }
+    std::chrono::nanoseconds timeout_left = timeout_ns;
+
+    if (spinning.exchange(true)) {
+      throw std::runtime_error("spin_until_future_complete() called while already spinning");
+    }
+    RCPPUTILS_SCOPE_EXIT(this->spinning.store(false); );
+    while (rclcpp::ok(this->context_) && spinning.load()) {
+      // Do one item of work.
+      spin_once_impl(timeout_left);
+
+      // Check if the future is set, return SUCCESS if it is.
+      status = future.wait_for(std::chrono::seconds(0));
+      if (status == std::future_status::ready) {
+        return FutureReturnCode::SUCCESS;
       }
-    );
+      // If the original timeout is < 0, then this is blocking, never TIMEOUT.
+      if (timeout_ns < std::chrono::nanoseconds::zero()) {
+        continue;
+      }
+      // Otherwise check if we still have time to wait, return TIMEOUT if not.
+      auto now = std::chrono::steady_clock::now();
+      if (now >= end_time) {
+        return FutureReturnCode::TIMEOUT;
+      }
+      // Subtract the elapsed time from the original timeout.
+      timeout_left = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - now);
+    }
+
+    // The future did not complete before ok() returned false, return INTERRUPTED.
+    return FutureReturnCode::INTERRUPTED;
   }
 
   /// Cancel any running spin* function, causing it to return.
@@ -392,7 +399,7 @@ public:
    * \throws std::runtime_error if there is an issue triggering the guard condition
    */
   RCLCPP_PUBLIC
-  virtual void
+  void
   cancel();
 
   /// Returns true if the executor is currently spinning.
@@ -405,14 +412,6 @@ public:
   is_spinning();
 
 protected:
-  /// Constructor that will not initialize any non-trivial members.
-  /**
-  * This constructor is intended to be used by any derived executor
-  * that explicitly does not want to use the default implementation provided
-  * by this class.
-  */
-  explicit Executor(const std::shared_ptr<rclcpp::Context> & context);
-
   /// Add a node to executor, execute the next available unit of work, and remove the node.
   /**
    * Implementation of spin_node_once using std::chrono::nanoseconds
@@ -427,23 +426,6 @@ protected:
     rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node,
     std::chrono::nanoseconds timeout);
 
-  /// Spin (blocking) until the future is complete, it times out waiting, or rclcpp is interrupted.
-  /**
-   * \sa spin_until_future_complete()
-   * The only difference with spin_until_future_complete() is that the future's
-   * type is obscured through a std::function which lets you wait on it
-   * reguardless of type.
-   *
-   * \param[in] timeout see spin_until_future_complete() for details
-   * \param[in] wait_for_future function to wait on the future and get the
-   *   status after waiting
-   */
-  RCLCPP_PUBLIC
-  virtual FutureReturnCode
-  spin_until_future_complete_impl(
-    std::chrono::nanoseconds timeout,
-    const std::function<std::future_status(std::chrono::nanoseconds wait_time)> & wait_for_future);
-
   /// Collect work and execute available work, optionally within a duration.
   /**
    * Implementation of spin_some and spin_all.
@@ -484,7 +466,7 @@ protected:
    */
   RCLCPP_PUBLIC
   static void
-  execute_timer(rclcpp::TimerBase::SharedPtr timer, const std::shared_ptr<void> & data_ptr);
+  execute_timer(rclcpp::TimerBase::SharedPtr timer);
 
   /// Run service server executable.
   /**
@@ -547,16 +529,6 @@ protected:
     AnyExecutable & any_executable,
     std::chrono::nanoseconds timeout = std::chrono::nanoseconds(-1));
 
-  /// This function triggers a recollect of all entities that are registered to the executor.
-  /**
-   * Calling this function is thread safe.
-   *
-   * \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);
-
   /// Spinning state, used to prevent multi threaded calls to spin and to cancel blocking spins.
   std::atomic_bool spinning;
 
@@ -582,7 +554,7 @@ protected:
    * This waitable contains the interrupt and shutdown guard condition, as well
    * as the guard condition associated with each node and callback group.
    * By default, if any change is detected in the monitored entities, the notify
-   * waitable will awake the executor and rebuild the collections.
+   * waitable will awake the executor and rebuild  the collections.
    */
   std::shared_ptr<rclcpp::executors::ExecutorNotifyWaitable> notify_waitable_;
 
@@ -591,9 +563,8 @@ protected:
   /// Collector used to associate executable entities from nodes and guard conditions
   rclcpp::executors::ExecutorEntitiesCollector collector_;
 
-  /// WaitSet to be waited on.
+  /// Waitset to be waited on.
   rclcpp::WaitSet wait_set_ RCPPUTILS_TSA_GUARDED_BY(mutex_);
-  std::optional<rclcpp::WaitResult<rclcpp::WaitSet>> wait_result_ RCPPUTILS_TSA_GUARDED_BY(mutex_);
 
   /// Hold the current state of the collection being waited on by the waitset
   rclcpp::executors::ExecutorEntitiesCollection current_collection_ RCPPUTILS_TSA_GUARDED_BY(
@@ -603,6 +574,9 @@ protected:
   std::shared_ptr<rclcpp::executors::ExecutorNotifyWaitable> current_notify_waitable_
   RCPPUTILS_TSA_GUARDED_BY(mutex_);
 
+  /// Hold the list of executables currently available to be executed.
+  std::deque<rclcpp::AnyExecutable> ready_executables_ RCPPUTILS_TSA_GUARDED_BY(mutex_);
+
   /// shutdown callback handle registered to Context
   rclcpp::OnShutdownCallbackHandle shutdown_callback_handle_;
 

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

@@ -29,18 +29,6 @@
 namespace rclcpp
 {
 
-/// Create a default single-threaded executor and execute all available work exhaustively.
-/** \param[in] node_ptr Shared pointer to the node to spin. */
-RCLCPP_PUBLIC
-void
-spin_all(
-  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
-  std::chrono::nanoseconds max_duration);
-
-RCLCPP_PUBLIC
-void
-spin_all(rclcpp::Node::SharedPtr node_ptr, std::chrono::nanoseconds max_duration);
-
 /// Create a default single-threaded executor and execute any immediately available work.
 /** \param[in] node_ptr Shared pointer to the node to spin. */
 RCLCPP_PUBLIC
@@ -120,9 +108,7 @@ spin_until_future_complete(
   const FutureT & future,
   std::chrono::duration<TimeRepT, TimeT> timeout = std::chrono::duration<TimeRepT, TimeT>(-1))
 {
-  rclcpp::ExecutorOptions options;
-  options.context = node_ptr->get_context();
-  rclcpp::executors::SingleThreadedExecutor executor(options);
+  rclcpp::executors::SingleThreadedExecutor executor;
   return executors::spin_node_until_future_complete<FutureT>(executor, node_ptr, future, timeout);
 }
 

rclcpp/include/rclcpp/executors/executor_entities_collection.hpp

@@ -178,12 +178,6 @@ struct ExecutorEntitiesCollection
 
   /// Clear the entities collection
   void clear();
-
-  /// Remove entities that have expired weak ownership
-  /**
-   * \return The total number of removed entities
-   */
-  size_t remove_expired_entities();
 };
 
 /// Build an entities collection from callback groups

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,19 +41,18 @@ 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
   ~ExecutorNotifyWaitable() override = default;
 
   RCLCPP_PUBLIC
-  ExecutorNotifyWaitable(ExecutorNotifyWaitable & other);
+  ExecutorNotifyWaitable(const ExecutorNotifyWaitable & other);
+
 
   RCLCPP_PUBLIC
-  ExecutorNotifyWaitable & operator=(ExecutorNotifyWaitable & other);
+  ExecutorNotifyWaitable & operator=(const ExecutorNotifyWaitable & other);
 
   /// Add conditions to the wait set
   /**
@@ -62,7 +60,7 @@ public:
    */
   RCLCPP_PUBLIC
   void
-  add_to_wait_set(rcl_wait_set_t & wait_set) override;
+  add_to_wait_set(rcl_wait_set_t * wait_set) override;
 
   /// Check conditions against the wait set
   /**
@@ -71,7 +69,7 @@ public:
    */
   RCLCPP_PUBLIC
   bool
-  is_ready(const rcl_wait_set_t & wait_set) override;
+  is_ready(rcl_wait_set_t * wait_set) override;
 
   /// Perform work associated with the waitable.
   /**
@@ -80,7 +78,7 @@ public:
    */
   RCLCPP_PUBLIC
   void
-  execute(const std::shared_ptr<void> & data) override;
+  execute(std::shared_ptr<void> & data) override;
 
   /// Retrieve data to be used in the next execute call.
   /**
@@ -125,14 +123,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 +139,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)
@@ -120,21 +113,21 @@ protected:
    * @param spin_once if true executes only the first ready executable.
    * @return true if any executable was ready.
    */
+  RCLCPP_PUBLIC
   bool
   execute_ready_executables(
     const rclcpp::executors::ExecutorEntitiesCollection & collection,
     rclcpp::WaitResult<rclcpp::WaitSet> & wait_result,
     bool spin_once);
 
+  RCLCPP_PUBLIC
   void
   spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive);
 
+  RCLCPP_PUBLIC
   void
   spin_once_impl(std::chrono::nanoseconds timeout) override;
 
-  std::optional<rclcpp::WaitResult<rclcpp::WaitSet>>
-  collect_and_wait(std::chrono::nanoseconds timeout);
-
 private:
   RCLCPP_DISABLE_COPY(StaticSingleThreadedExecutor)
 };

rclcpp/include/rclcpp/experimental/buffers/buffer_implementation_base.hpp

@@ -15,8 +15,6 @@
 #ifndef RCLCPP__EXPERIMENTAL__BUFFERS__BUFFER_IMPLEMENTATION_BASE_HPP_
 #define RCLCPP__EXPERIMENTAL__BUFFERS__BUFFER_IMPLEMENTATION_BASE_HPP_
 
-#include <vector>
-
 namespace rclcpp
 {
 namespace experimental
@@ -33,11 +31,8 @@ public:
   virtual BufferT dequeue() = 0;
   virtual void enqueue(BufferT request) = 0;
 
-  virtual std::vector<BufferT> get_all_data() = 0;
-
   virtual void clear() = 0;
   virtual bool has_data() const = 0;
-  virtual size_t available_capacity() const = 0;
 };
 
 }  // namespace buffers

rclcpp/include/rclcpp/experimental/buffers/intra_process_buffer.hpp

@@ -19,7 +19,6 @@
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
-#include <vector>
 
 #include "rclcpp/allocator/allocator_common.hpp"
 #include "rclcpp/allocator/allocator_deleter.hpp"
@@ -45,7 +44,6 @@ public:
 
   virtual bool has_data() const = 0;
   virtual bool use_take_shared_method() const = 0;
-  virtual size_t available_capacity() const = 0;
 };
 
 template<
@@ -67,9 +65,6 @@ public:
 
   virtual MessageSharedPtr consume_shared() = 0;
   virtual MessageUniquePtr consume_unique() = 0;
-
-  virtual std::vector<MessageSharedPtr> get_all_data_shared() = 0;
-  virtual std::vector<MessageUniquePtr> get_all_data_unique() = 0;
 };
 
 template<
@@ -100,7 +95,7 @@ public:
 
     buffer_ = std::move(buffer_impl);
 
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_buffer_to_ipb,
       static_cast<const void *>(buffer_.get()),
       static_cast<const void *>(this));
@@ -133,16 +128,6 @@ public:
     return consume_unique_impl<BufferT>();
   }
 
-  std::vector<MessageSharedPtr> get_all_data_shared() override
-  {
-    return get_all_data_shared_impl();
-  }
-
-  std::vector<MessageUniquePtr> get_all_data_unique() override
-  {
-    return get_all_data_unique_impl();
-  }
-
   bool has_data() const override
   {
     return buffer_->has_data();
@@ -158,11 +143,6 @@ public:
     return std::is_same<BufferT, MessageSharedPtr>::value;
   }
 
-  size_t available_capacity() const override
-  {
-    return buffer_->available_capacity();
-  }
-
 private:
   std::unique_ptr<BufferImplementationBase<BufferT>> buffer_;
 
@@ -257,71 +237,6 @@ private:
   {
     return buffer_->dequeue();
   }
-
-  // MessageSharedPtr to MessageSharedPtr
-  template<typename T = BufferT>
-  typename std::enable_if<
-    std::is_same<T, MessageSharedPtr>::value,
-    std::vector<MessageSharedPtr>
-  >::type
-  get_all_data_shared_impl()
-  {
-    return buffer_->get_all_data();
-  }
-
-  // MessageUniquePtr to MessageSharedPtr
-  template<typename T = BufferT>
-  typename std::enable_if<
-    std::is_same<T, MessageUniquePtr>::value,
-    std::vector<MessageSharedPtr>
-  >::type
-  get_all_data_shared_impl()
-  {
-    std::vector<MessageSharedPtr> result;
-    auto uni_ptr_vec = buffer_->get_all_data();
-    result.reserve(uni_ptr_vec.size());
-    for (MessageUniquePtr & uni_ptr : uni_ptr_vec) {
-      result.emplace_back(std::move(uni_ptr));
-    }
-    return result;
-  }
-
-  // MessageSharedPtr to MessageUniquePtr
-  template<typename T = BufferT>
-  typename std::enable_if<
-    std::is_same<T, MessageSharedPtr>::value,
-    std::vector<MessageUniquePtr>
-  >::type
-  get_all_data_unique_impl()
-  {
-    std::vector<MessageUniquePtr> result;
-    auto shared_ptr_vec = buffer_->get_all_data();
-    result.reserve(shared_ptr_vec.size());
-    for (MessageSharedPtr shared_msg : shared_ptr_vec) {
-      MessageUniquePtr unique_msg;
-      MessageDeleter * deleter = std::get_deleter<MessageDeleter, const MessageT>(shared_msg);
-      auto ptr = MessageAllocTraits::allocate(*message_allocator_.get(), 1);
-      MessageAllocTraits::construct(*message_allocator_.get(), ptr, *shared_msg);
-      if (deleter) {
-        unique_msg = MessageUniquePtr(ptr, *deleter);
-      } else {
-        unique_msg = MessageUniquePtr(ptr);
-      }
-      result.push_back(std::move(unique_msg));
-    }
-    return result;
-  }
-
-  // MessageUniquePtr to MessageUniquePtr
-  template<typename T = BufferT>
-  typename std::enable_if<
-    std::is_same<T, MessageUniquePtr>::value,
-    std::vector<MessageUniquePtr>
-  >::type
-  get_all_data_unique_impl()
-  {
-    return buffer_->get_all_data();
-  }
 };
 
 }  // namespace buffers

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

@@ -15,9 +15,7 @@
 #ifndef RCLCPP__EXPERIMENTAL__BUFFERS__RING_BUFFER_IMPLEMENTATION_HPP_
 #define RCLCPP__EXPERIMENTAL__BUFFERS__RING_BUFFER_IMPLEMENTATION_HPP_
 
-#include <memory>
 #include <mutex>
-#include <shared_mutex>
 #include <stdexcept>
 #include <utility>
 #include <vector>
@@ -54,10 +52,7 @@ public:
     if (capacity == 0) {
       throw std::invalid_argument("capacity must be a positive, non-zero value");
     }
-    TRACETOOLS_TRACEPOINT(
-      rclcpp_construct_ring_buffer,
-      static_cast<const void *>(this),
-      capacity_);
+    TRACEPOINT(rclcpp_construct_ring_buffer, static_cast<const void *>(this), capacity_);
   }
 
   virtual ~RingBufferImplementation() {}
@@ -68,13 +63,13 @@ public:
    *
    * \param request the element to be stored in the ring buffer
    */
-  void enqueue(BufferT request) override
+  void enqueue(BufferT request)
   {
-    std::unique_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
 
     write_index_ = next_(write_index_);
     ring_buffer_[write_index_] = std::move(request);
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_ring_buffer_enqueue,
       static_cast<const void *>(this),
       write_index_,
@@ -94,16 +89,16 @@ public:
    *
    * \return the element that is being removed from the ring buffer
    */
-  BufferT dequeue() override
+  BufferT dequeue()
   {
-    std::unique_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
 
     if (!has_data_()) {
       return BufferT();
     }
 
     auto request = std::move(ring_buffer_[read_index_]);
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_ring_buffer_dequeue,
       static_cast<const void *>(this),
       read_index_,
@@ -115,17 +110,6 @@ public:
     return request;
   }
 
-  /// Get all the elements from the ring buffer
-  /**
-   * This member function is thread-safe.
-   *
-   * \return a vector containing all the elements from the ring buffer
-   */
-  std::vector<BufferT> get_all_data() override
-  {
-    return get_all_data_impl();
-  }
-
   /// Get the next index value for the ring buffer
   /**
    * This member function is thread-safe.
@@ -135,7 +119,7 @@ public:
    */
   inline size_t next(size_t val)
   {
-    std::unique_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
     return next_(val);
   }
 
@@ -145,9 +129,9 @@ public:
    *
    * \return `true` if there is data and `false` otherwise
    */
-  inline bool has_data() const override
+  inline bool has_data() const
   {
-    std::shared_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
     return has_data_();
   }
 
@@ -160,27 +144,13 @@ public:
    */
   inline bool is_full() const
   {
-    std::shared_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
     return is_full_();
   }
 
-  /// Get the remaining capacity to store messages
-  /**
-   * This member function is thread-safe.
-   *
-   * \return the number of free capacity for new messages
-   */
-  size_t available_capacity() const override
+  void clear()
   {
-    std::shared_lock lock(mutex_);
-    return available_capacity_();
-  }
-
-  void clear() override
-  {
-    TRACETOOLS_TRACEPOINT(rclcpp_ring_buffer_clear, static_cast<const void *>(this));
-    std::unique_lock lock(mutex_);
-    clear_();
+    TRACEPOINT(rclcpp_ring_buffer_clear, static_cast<const void *>(this));
   }
 
 private:
@@ -219,91 +189,7 @@ private:
     return size_ == capacity_;
   }
 
-  /// Get the remaining capacity to store messages
-  /**
-   * This member function is not thread-safe.
-   *
-   * \return the number of free capacity for new messages
-   */
-  inline size_t available_capacity_() const
-  {
-    return capacity_ - size_;
-  }
-
-  inline void clear_()
-  {
-    ring_buffer_.clear();
-    size_ = 0;
-    read_index_ = 0;
-    write_index_ = capacity_ - 1;
-  }
-
-  /// Traits for checking if a type is std::unique_ptr
-  template<typename ...>
-  struct is_std_unique_ptr final : std::false_type {};
-  template<class T, typename ... Args>
-  struct is_std_unique_ptr<std::unique_ptr<T, Args...>> final : std::true_type
-  {
-    typedef T Ptr_type;
-  };
-
-  /// Get all the elements from the ring buffer
-  /**
-   * This member function is thread-safe.
-   * Two versions for the implementation of the function.
-   * One for buffer containing unique_ptr and the other for other types
-   *
-   * \return a vector containing all the elements from the ring buffer
-   */
-  template<typename T = BufferT, std::enable_if_t<is_std_unique_ptr<T>::value &&
-    std::is_copy_constructible<
-      typename is_std_unique_ptr<T>::Ptr_type
-    >::value,
-    void> * = nullptr>
-  std::vector<BufferT> get_all_data_impl()
-  {
-    std::unique_lock lock(mutex_);
-    std::vector<BufferT> result_vtr;
-    result_vtr.reserve(size_);
-    for (size_t id = 0; id < size_; ++id) {
-      result_vtr.emplace_back(
-        new typename is_std_unique_ptr<T>::Ptr_type(
-          *(ring_buffer_[(read_index_ + id) % capacity_])));
-    }
-    return result_vtr;
-  }
-
-  template<typename T = BufferT, std::enable_if_t<
-      std::is_copy_constructible<T>::value, void> * = nullptr>
-  std::vector<BufferT> get_all_data_impl()
-  {
-    std::unique_lock lock(mutex_);
-    std::vector<BufferT> result_vtr;
-    result_vtr.reserve(size_);
-    for (size_t id = 0; id < size_; ++id) {
-      result_vtr.emplace_back(ring_buffer_[(read_index_ + id) % capacity_]);
-    }
-    return result_vtr;
-  }
-
-  template<typename T = BufferT, std::enable_if_t<!is_std_unique_ptr<T>::value &&
-    !std::is_copy_constructible<T>::value, void> * = nullptr>
-  std::vector<BufferT> get_all_data_impl()
-  {
-    throw std::logic_error("Underlined type results in invalid get_all_data_impl()");
-    return {};
-  }
-
-  template<typename T = BufferT, std::enable_if_t<is_std_unique_ptr<T>::value &&
-    !std::is_copy_constructible<typename is_std_unique_ptr<T>::Ptr_type>::value,
-    void> * = nullptr>
-  std::vector<BufferT> get_all_data_impl()
-  {
-    throw std::logic_error("Underlined type in unique_ptr results in invalid get_all_data_impl()");
-    return {};
-  }
-
-  const size_t capacity_;
+  size_t capacity_;
 
   std::vector<BufferT> ring_buffer_;
 
@@ -311,7 +197,7 @@ private:
   size_t read_index_;
   size_t size_;
 
-  mutable std::shared_mutex mutex_;
+  mutable std::mutex mutex_;
 };
 
 }  // namespace buffers

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
@@ -165,21 +243,11 @@ private:
   std::function<void(size_t, int)>
   create_waitable_callback(const rclcpp::Waitable * waitable_id);
 
-  /// Utility to add the notify waitable to an entities collection
-  void
-  add_notify_waitable_to_collection(
-    rclcpp::executors::ExecutorEntitiesCollection::WaitableCollection & collection);
-
   /// Searches for the provided entity_id in the collection and returns the entity if valid
   template<typename CollectionType>
   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 +268,13 @@ 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::ExecutorEntitiesCollection> current_entities_collection_;
+  std::shared_ptr<rclcpp::executors::ExecutorNotifyWaitable> notify_waitable_;
+
+  /// 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/executors/events_executor/events_executor_event_types.hpp

@@ -15,8 +15,6 @@
 #ifndef RCLCPP__EXPERIMENTAL__EXECUTORS__EVENTS_EXECUTOR__EVENTS_EXECUTOR_EVENT_TYPES_HPP_
 #define RCLCPP__EXPERIMENTAL__EXECUTORS__EVENTS_EXECUTOR__EVENTS_EXECUTOR_EVENT_TYPES_HPP_
 
-#include <memory>
-
 namespace rclcpp
 {
 namespace experimental
@@ -36,7 +34,6 @@ enum ExecutorEventType
 struct ExecutorEvent
 {
   const void * entity_key;
-  std::shared_ptr<void> data;
   int waitable_data;
   ExecutorEventType type;
   size_t num_events;

rclcpp/include/rclcpp/experimental/intra_process_manager.hpp

@@ -28,7 +28,6 @@
 #include <typeinfo>
 
 #include "rclcpp/allocator/allocator_deleter.hpp"
-#include "rclcpp/experimental/buffers/intra_process_buffer.hpp"
 #include "rclcpp/experimental/ros_message_intra_process_buffer.hpp"
 #include "rclcpp/experimental/subscription_intra_process.hpp"
 #include "rclcpp/experimental/subscription_intra_process_base.hpp"
@@ -113,40 +112,9 @@ public:
    * \param subscription the SubscriptionIntraProcess to register.
    * \return an unsigned 64-bit integer which is the subscription's unique id.
    */
-  template<
-    typename ROSMessageType,
-    typename Alloc = std::allocator<ROSMessageType>
-  >
+  RCLCPP_PUBLIC
   uint64_t
-  add_subscription(rclcpp::experimental::SubscriptionIntraProcessBase::SharedPtr subscription)
-  {
-    std::unique_lock<std::shared_timed_mutex> lock(mutex_);
-
-    uint64_t sub_id = IntraProcessManager::get_next_unique_id();
-
-    subscriptions_[sub_id] = subscription;
-
-    // adds the subscription id to all the matchable publishers
-    for (auto & pair : publishers_) {
-      auto publisher = pair.second.lock();
-      if (!publisher) {
-        continue;
-      }
-      if (can_communicate(publisher, subscription)) {
-        uint64_t pub_id = pair.first;
-        insert_sub_id_for_pub(sub_id, pub_id, subscription->use_take_shared_method());
-        if (publisher->is_durability_transient_local() &&
-          subscription->is_durability_transient_local())
-        {
-          do_transient_local_publish<ROSMessageType, Alloc>(
-            pub_id, sub_id,
-            subscription->use_take_shared_method());
-        }
-      }
-    }
-
-    return sub_id;
-  }
+  add_subscription(rclcpp::experimental::SubscriptionIntraProcessBase::SharedPtr subscription);
 
   /// Unregister a subscription using the subscription's unique id.
   /**
@@ -163,21 +131,14 @@ public:
    * This method stores the publisher intra process object, together with
    * the information of its wrapped publisher (i.e. topic name and QoS).
    *
-   * If the publisher's durability is transient local, its buffer pointer should
-   * be passed and the method will store it as well.
-   *
    * In addition this generates a unique intra process id for the publisher.
    *
    * \param publisher publisher to be registered with the manager.
-   * \param buffer publisher's buffer to be stored if its duability is transient local.
    * \return an unsigned 64-bit integer which is the publisher's unique id.
    */
   RCLCPP_PUBLIC
   uint64_t
-  add_publisher(
-    rclcpp::PublisherBase::SharedPtr publisher,
-    rclcpp::experimental::buffers::IntraProcessBufferBase::SharedPtr buffer =
-    rclcpp::experimental::buffers::IntraProcessBufferBase::SharedPtr());
+  add_publisher(rclcpp::PublisherBase::SharedPtr publisher);
 
   /// Unregister a publisher using the publisher's unique id.
   /**
@@ -253,8 +214,7 @@ public:
       // So this case is equivalent to all the buffers requiring ownership
 
       // Merge the two vector of ids into a unique one
-      std::vector<uint64_t> concatenated_vector(
-        sub_ids.take_shared_subscriptions.begin(), sub_ids.take_shared_subscriptions.end());
+      std::vector<uint64_t> concatenated_vector(sub_ids.take_shared_subscriptions);
       concatenated_vector.insert(
         concatenated_vector.end(),
         sub_ids.take_ownership_subscriptions.begin(),
@@ -332,34 +292,6 @@ public:
     }
   }
 
-  template<
-    typename MessageT,
-    typename Alloc,
-    typename Deleter,
-    typename ROSMessageType>
-  void
-  add_shared_msg_to_buffer(
-    std::shared_ptr<const MessageT> message,
-    uint64_t subscription_id)
-  {
-    add_shared_msg_to_buffers<MessageT, Alloc, Deleter, ROSMessageType>(message, {subscription_id});
-  }
-
-  template<
-    typename MessageT,
-    typename Alloc,
-    typename Deleter,
-    typename ROSMessageType>
-  void
-  add_owned_msg_to_buffer(
-    std::unique_ptr<MessageT, Deleter> message,
-    uint64_t subscription_id,
-    typename allocator::AllocRebind<MessageT, Alloc>::allocator_type & allocator)
-  {
-    add_owned_msg_to_buffers<MessageT, Alloc, Deleter, ROSMessageType>(
-      std::move(message), {subscription_id}, allocator);
-  }
-
   /// Return true if the given rmw_gid_t matches any stored Publishers.
   RCLCPP_PUBLIC
   bool
@@ -374,11 +306,6 @@ public:
   rclcpp::experimental::SubscriptionIntraProcessBase::SharedPtr
   get_subscription_intra_process(uint64_t intra_process_subscription_id);
 
-  /// Return the lowest available capacity for all subscription buffers for a publisher id.
-  RCLCPP_PUBLIC
-  size_t
-  lowest_available_capacity(const uint64_t intra_process_publisher_id) const;
-
 private:
   struct SplittedSubscriptions
   {
@@ -392,9 +319,6 @@ private:
   using PublisherMap =
     std::unordered_map<uint64_t, rclcpp::PublisherBase::WeakPtr>;
 
-  using PublisherBufferMap =
-    std::unordered_map<uint64_t, rclcpp::experimental::buffers::IntraProcessBufferBase::WeakPtr>;
-
   using PublisherToSubscriptionIdsMap =
     std::unordered_map<uint64_t, SplittedSubscriptions>;
 
@@ -413,54 +337,6 @@ private:
     rclcpp::PublisherBase::SharedPtr pub,
     rclcpp::experimental::SubscriptionIntraProcessBase::SharedPtr sub) const;
 
-  template<
-    typename ROSMessageType,
-    typename Alloc = std::allocator<ROSMessageType>
-  >
-  void do_transient_local_publish(
-    const uint64_t pub_id, const uint64_t sub_id,
-    const bool use_take_shared_method)
-  {
-    using ROSMessageTypeAllocatorTraits = allocator::AllocRebind<ROSMessageType, Alloc>;
-    using ROSMessageTypeAllocator = typename ROSMessageTypeAllocatorTraits::allocator_type;
-    using ROSMessageTypeDeleter = allocator::Deleter<ROSMessageTypeAllocator, ROSMessageType>;
-
-    auto publisher_buffer = publisher_buffers_[pub_id].lock();
-    if (!publisher_buffer) {
-      throw std::runtime_error("publisher buffer has unexpectedly gone out of scope");
-    }
-    auto buffer = std::dynamic_pointer_cast<
-      rclcpp::experimental::buffers::IntraProcessBuffer<
-        ROSMessageType,
-        ROSMessageTypeAllocator,
-        ROSMessageTypeDeleter
-      >
-      >(publisher_buffer);
-    if (!buffer) {
-      throw std::runtime_error(
-              "failed to dynamic cast publisher's IntraProcessBufferBase to "
-              "IntraProcessBuffer<ROSMessageType,ROSMessageTypeAllocator,"
-              "ROSMessageTypeDeleter> which can happen when the publisher and "
-              "subscription use different allocator types, which is not supported");
-    }
-    if (use_take_shared_method) {
-      auto data_vec = buffer->get_all_data_shared();
-      for (auto shared_data : data_vec) {
-        this->template add_shared_msg_to_buffer<
-          ROSMessageType, ROSMessageTypeAllocator, ROSMessageTypeDeleter, ROSMessageType>(
-          shared_data, sub_id);
-      }
-    } else {
-      auto data_vec = buffer->get_all_data_unique();
-      for (auto & owned_data : data_vec) {
-        auto allocator = ROSMessageTypeAllocator();
-        this->template add_owned_msg_to_buffer<
-          ROSMessageType, ROSMessageTypeAllocator, ROSMessageTypeDeleter, ROSMessageType>(
-          std::move(owned_data), sub_id, allocator);
-      }
-    }
-  }
-
   template<
     typename MessageT,
     typename Alloc,
@@ -586,7 +462,7 @@ private:
           auto ptr = MessageAllocTraits::allocate(allocator, 1);
           MessageAllocTraits::construct(allocator, ptr, *message);
 
-          subscription->provide_intra_process_data(MessageUniquePtr(ptr, deleter));
+          subscription->provide_intra_process_data(std::move(MessageUniquePtr(ptr, deleter)));
         }
 
         continue;
@@ -605,13 +481,13 @@ private:
                 "subscription use different allocator types, which is not supported");
       }
 
-      if constexpr (rclcpp::TypeAdapter<MessageT, ROSMessageType>::is_specialized::value) {
+      if constexpr (rclcpp::TypeAdapter<MessageT>::is_specialized::value) {
         ROSMessageTypeAllocator ros_message_alloc(allocator);
-        auto ptr = ROSMessageTypeAllocatorTraits::allocate(ros_message_alloc, 1);
-        ROSMessageTypeAllocatorTraits::construct(ros_message_alloc, ptr);
+        auto ptr = ros_message_alloc.allocate(1);
+        ros_message_alloc.construct(ptr);
         ROSMessageTypeDeleter deleter;
         allocator::set_allocator_for_deleter(&deleter, &allocator);
-        rclcpp::TypeAdapter<MessageT, ROSMessageType>::convert_to_ros_message(*message, *ptr);
+        rclcpp::TypeAdapter<MessageT>::convert_to_ros_message(*message, *ptr);
         auto ros_msg = std::unique_ptr<ROSMessageType, ROSMessageTypeDeleter>(ptr, deleter);
         ros_message_subscription->provide_intra_process_message(std::move(ros_msg));
       } else {
@@ -629,7 +505,7 @@ private:
             MessageAllocTraits::construct(allocator, ptr, *message);
 
             ros_message_subscription->provide_intra_process_message(
-              MessageUniquePtr(ptr, deleter));
+              std::move(MessageUniquePtr(ptr, deleter)));
           }
         }
       }
@@ -639,7 +515,6 @@ private:
   PublisherToSubscriptionIdsMap pub_to_subs_;
   SubscriptionMap subscriptions_;
   PublisherMap publishers_;
-  PublisherBufferMap publisher_buffers_;
 
   mutable std::shared_timed_mutex mutex_;
 };

rclcpp/include/rclcpp/experimental/subscription_intra_process.hpp

@@ -87,7 +87,7 @@ public:
       buffer_type),
     any_callback_(callback)
   {
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_subscription_callback_added,
       static_cast<const void *>(this),
       static_cast<const void *>(&any_callback_));
@@ -101,23 +101,6 @@ public:
 
   virtual ~SubscriptionIntraProcess() = default;
 
-  void
-  add_to_wait_set(rcl_wait_set_t & wait_set) override
-  {
-    // This block is necessary when the guard condition wakes the wait set, but
-    // the intra process waitable was not handled before the wait set is waited
-    // on again.
-    // Basically we're keeping the guard condition triggered so long as there is
-    // data in the buffer.
-    if (this->buffer_->has_data()) {
-      // If there is data still to be processed, indicate to the
-      // executor or waitset by triggering the guard condition.
-      this->trigger_guard_condition();
-    }
-    // Let the parent classes handle the rest of the work:
-    return SubscriptionIntraProcessBufferT::add_to_wait_set(wait_set);
-  }
-
   std::shared_ptr<void>
   take_data() override
   {
@@ -149,7 +132,7 @@ public:
     );
   }
 
-  void execute(const std::shared_ptr<void> & data) override
+  void execute(std::shared_ptr<void> & data) override
   {
     execute_impl<SubscribedType>(data);
   }
@@ -157,16 +140,17 @@ public:
 protected:
   template<typename T>
   typename std::enable_if<std::is_same<T, rcl_serialized_message_t>::value, void>::type
-  execute_impl(const std::shared_ptr<void> &)
+  execute_impl(std::shared_ptr<void> & data)
   {
+    (void)data;
     throw std::runtime_error("Subscription intra-process can't handle serialized messages");
   }
 
   template<class T>
   typename std::enable_if<!std::is_same<T, rcl_serialized_message_t>::value, void>::type
-  execute_impl(const std::shared_ptr<void> & data)
+  execute_impl(std::shared_ptr<void> & data)
   {
-    if (nullptr == data) {
+    if (!data) {
       return;
     }
 

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"
@@ -61,31 +60,23 @@ public:
 
   RCLCPP_PUBLIC
   void
-  add_to_wait_set(rcl_wait_set_t & wait_set) override;
-
-  RCLCPP_PUBLIC
-  virtual
-  size_t
-  available_capacity() const = 0;
-
-  RCLCPP_PUBLIC
-  bool
-  is_durability_transient_local() const;
+  add_to_wait_set(rcl_wait_set_t * wait_set) override;
 
   bool
-  is_ready(const rcl_wait_set_t & wait_set) override = 0;
+  is_ready(rcl_wait_set_t * wait_set) override = 0;
 
   std::shared_ptr<void>
   take_data() override = 0;
 
   std::shared_ptr<void>
-  take_data_by_entity_id([[maybe_unused]] size_t id) override
+  take_data_by_entity_id(size_t id) override
   {
+    (void)id;
     return take_data();
   }
 
   void
-  execute(const std::shared_ptr<void> & data) override = 0;
+  execute(std::shared_ptr<void> & data) override = 0;
 
   virtual
   bool
@@ -180,13 +171,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

@@ -30,7 +30,6 @@
 #include "rclcpp/experimental/ros_message_intra_process_buffer.hpp"
 #include "rclcpp/qos.hpp"
 #include "rclcpp/type_support_decl.hpp"
-#include "rclcpp/detail/add_guard_condition_to_rcl_wait_set.hpp"
 
 #include "tracetools/tracetools.h"
 
@@ -94,24 +93,16 @@ public:
       buffer_type,
       qos_profile,
       std::make_shared<Alloc>(subscribed_type_allocator_));
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_ipb_to_subscription,
       static_cast<const void *>(buffer_.get()),
       static_cast<const void *>(this));
   }
 
-  void
-  add_to_wait_set(rcl_wait_set_t & wait_set) override
-  {
-    if (this->buffer_->has_data()) {
-      this->trigger_guard_condition();
-    }
-    detail::add_guard_condition_to_rcl_wait_set(wait_set, this->gc_);
-  }
-
   bool
-  is_ready([[maybe_unused]] const rcl_wait_set_t & wait_set) override
+  is_ready(rcl_wait_set_t * wait_set) override
   {
+    (void) wait_set;
     return buffer_->has_data();
   }
 
@@ -178,11 +169,6 @@ public:
     return buffer_->use_take_shared_method();
   }
 
-  size_t available_capacity() const override
-  {
-    return buffer_->available_capacity();
-  }
-
 protected:
   void
   trigger_guard_condition() override

rclcpp/include/rclcpp/experimental/timers_manager.hpp

@@ -22,10 +22,10 @@
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <optional>
 #include <thread>
 #include <utility>
 #include <vector>
+
 #include "rclcpp/context.hpp"
 #include "rclcpp/timer.hpp"
 
@@ -86,8 +86,7 @@ public:
   RCLCPP_PUBLIC
   TimersManager(
     std::shared_ptr<rclcpp::Context> context,
-    std::function<void(const rclcpp::TimerBase *,
-    const std::shared_ptr<void> &)> on_ready_callback = nullptr);
+    std::function<void(const rclcpp::TimerBase *)> on_ready_callback = nullptr);
 
   /**
    * @brief Destruct the TimersManager object making sure to stop thread and release memory.
@@ -165,23 +164,21 @@ public:
    * the TimersManager on_ready_callback was passed during construction.
    *
    * @param timer_id the timer ID of the timer to execute
-   * @param data internal data of the timer
    */
   RCLCPP_PUBLIC
-  void execute_ready_timer(const rclcpp::TimerBase * timer_id, const std::shared_ptr<void> & data);
+  void execute_ready_timer(const rclcpp::TimerBase * timer_id);
 
   /**
    * @brief Get the amount of time before the next timer triggers.
    * This function is thread safe.
    *
-   * @return std::optional<std::chrono::nanoseconds> to wait,
+   * @return std::chrono::nanoseconds to wait,
    * the returned value could be negative if the timer is already expired
    * or std::chrono::nanoseconds::max() if there are no timers stored in the object.
-   * If the head timer was cancelled, then this will return a nullopt.
    * @throws std::runtime_error if the timers thread was already running.
    */
   RCLCPP_PUBLIC
-  std::optional<std::chrono::nanoseconds> get_head_timeout();
+  std::chrono::nanoseconds get_head_timeout();
 
 private:
   RCLCPP_DISABLE_COPY(TimersManager)
@@ -515,13 +512,12 @@ private:
    * @brief Get the amount of time before the next timer triggers.
    * This function is not thread safe, acquire a mutex before calling it.
    *
-   * @return std::optional<std::chrono::nanoseconds> to wait,
+   * @return std::chrono::nanoseconds to wait,
    * the returned value could be negative if the timer is already expired
    * or std::chrono::nanoseconds::max() if the heap is empty.
-   * If the head timer was cancelled, then this will return a nullopt.
    * This function is not thread safe, acquire the timers_mutex_ before calling it.
    */
-  std::optional<std::chrono::nanoseconds> get_head_timeout_unsafe();
+  std::chrono::nanoseconds get_head_timeout_unsafe();
 
   /**
    * @brief Executes all the timers currently ready when the function is invoked
@@ -531,8 +527,7 @@ private:
   void execute_ready_timers_unsafe();
 
   // Callback to be called when timer is ready
-  std::function<void(const rclcpp::TimerBase *,
-    const std::shared_ptr<void> &)> on_ready_callback_ = nullptr;
+  std::function<void(const rclcpp::TimerBase *)> on_ready_callback_ = nullptr;
 
   // Thread used to run the timers execution task
   std::thread timers_thread_;

rclcpp/include/rclcpp/generic_client.hpp

@@ -1,303 +0,0 @@
-// Copyright 2023 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_CLIENT_HPP_
-#define RCLCPP__GENERIC_CLIENT_HPP_
-
-#include <map>
-#include <memory>
-#include <future>
-#include <string>
-#include <tuple>
-#include <vector>
-#include <utility>
-
-#include "rcl/client.h"
-
-#include "rclcpp/client.hpp"
-#include "rclcpp/visibility_control.hpp"
-#include "rcpputils/shared_library.hpp"
-
-#include "rosidl_typesupport_introspection_cpp/message_introspection.hpp"
-
-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 SharedResponse = std::shared_ptr<void>;
-
-  using Promise = std::promise<SharedResponse>;
-  using SharedPromise = std::shared_ptr<Promise>;
-
-  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.
-  /**
-   * Public members:
-   * - future: a std::future<void *>.
-   * - request_id: the request id associated with the future.
-   *
-   * All the other methods are equivalent to the ones std::future provides.
-   */
-  struct FutureAndRequestId
-    : detail::FutureAndRequestId<Future>
-  {
-    using detail::FutureAndRequestId<Future>::FutureAndRequestId;
-
-    /// See std::future::share().
-    SharedFuture share() noexcept {return this->future.share();}
-
-    /// Move constructor.
-    FutureAndRequestId(FutureAndRequestId && other) noexcept = default;
-    /// Deleted copy constructor, each instance is a unique owner of the future.
-    FutureAndRequestId(const FutureAndRequestId & other) = delete;
-    /// Move assignment.
-    FutureAndRequestId & operator=(FutureAndRequestId && other) noexcept = default;
-    /// Deleted copy assignment, each instance is a unique owner of the future.
-    FutureAndRequestId & operator=(const FutureAndRequestId & other) = delete;
-    /// Destructor.
-    ~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,
-    const std::string & service_name,
-    const std::string & service_type,
-    rcl_client_options_t & client_options);
-
-  RCLCPP_PUBLIC
-  SharedResponse
-  create_response() override;
-
-  RCLCPP_PUBLIC
-  std::shared_ptr<rmw_request_id_t>
-  create_request_header() override;
-
-  RCLCPP_PUBLIC
-  void
-  handle_response(
-    std::shared_ptr<rmw_request_id_t> request_header,
-    std::shared_ptr<void> response) override;
-
-  /// Send a request to the service server.
-  /**
-   * This method returns a `FutureAndRequestId` instance
-   * that can be passed to Executor::spin_until_future_complete() to
-   * wait until it has been completed.
-   *
-   * 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.
-   *
-   * ```cpp
-   * auto future = generic_client->async_send_request(my_request);
-   * if (
-   *   rclcpp::FutureReturnCode::TIMEOUT ==
-   *   executor->spin_until_future_complete(future, timeout))
-   * {
-   *   generic_client->remove_pending_request(future);
-   *   // handle timeout
-   * } else {
-   *   handle_response(future.get());
-   * }
-   * ```
-   *
-   * \param[in] request request to be send.
-   * \return a FutureAndRequestId instance.
-   */
-  RCLCPP_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.
-   * \param[inout] pruned_requests Removed requests id will be pushed to the vector
-   *  if a pointer is provided.
-   * \return number of pending requests that were removed.
-   */
-  template<typename AllocatorT = std::allocator<int64_t>>
-  size_t
-  prune_requests_older_than(
-    std::chrono::time_point<std::chrono::system_clock> time_point,
-    std::vector<int64_t, AllocatorT> * pruned_requests = nullptr)
-  {
-    return detail::prune_requests_older_than_impl(
-      pending_requests_,
-      pending_requests_mutex_,
-      time_point,
-      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().
-   *
-   * \param[out] response_out The reference to a Service Response into
-   *   which the middleware will copy the response being taken.
-   * \param[out] request_header_out The request header to be filled by the
-   *   middleware when taking, and which can be used to associate the response
-   *   to a specific request.
-   * \returns true if the response was taken, otherwise false.
-   * \throws rclcpp::exceptions::RCLError based exceptions if the underlying
-   *   rcl function fail.
-   */
-  RCLCPP_PUBLIC
-  bool
-  take_response(Response response_out, rmw_request_id_t & request_header_out)
-  {
-    return this->take_type_erased_response(response_out, request_header_out);
-  }
-
-protected:
-  using CallbackTypeValueVariant = std::tuple<CallbackType, SharedFuture, Promise>;
-  using CallbackInfoVariant = std::variant<
-    std::promise<SharedResponse>,
-    CallbackTypeValueVariant>;  // Use variant for extension
-
-  RCLCPP_PUBLIC
-  int64_t
-  async_send_request_impl(
-    const Request request,
-    CallbackInfoVariant value);
-
-  std::optional<CallbackInfoVariant>
-  get_and_erase_pending_request(
-    int64_t request_number);
-
-  RCLCPP_DISABLE_COPY(GenericClient)
-
-  std::map<int64_t, std::pair<
-      std::chrono::time_point<std::chrono::system_clock>,
-      CallbackInfoVariant>> pending_requests_;
-  std::mutex pending_requests_mutex_;
-
-private:
-  std::shared_ptr<rcpputils::SharedLibrary> ts_lib_;
-  const rosidl_typesupport_introspection_cpp::MessageMembers * response_members_;
-};
-}  // namespace rclcpp
-
-#endif  // RCLCPP__GENERIC_CLIENT_HPP_

rclcpp/include/rclcpp/generic_publisher.hpp

@@ -77,7 +77,7 @@ public:
   : rclcpp::PublisherBase(
       node_base,
       topic_name,
-      *rclcpp::get_message_typesupport_handle(topic_type, "rosidl_typesupport_cpp", *ts_lib),
+      *rclcpp::get_typesupport_handle(topic_type, "rosidl_typesupport_cpp", *ts_lib),
       options.template to_rcl_publisher_options<rclcpp::SerializedMessage>(qos),
       // NOTE(methylDragon): Passing these args separately is necessary for event binding
       options.event_callbacks,

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/generic_subscription.hpp

@@ -74,32 +74,20 @@ public:
     const std::string & topic_name,
     const std::string & topic_type,
     const rclcpp::QoS & qos,
-    AnySubscriptionCallback<rclcpp::SerializedMessage, AllocatorT> callback,
+    // TODO(nnmm): Add variant for callback with message info. See issue #1604.
+    std::function<void(std::shared_ptr<rclcpp::SerializedMessage>)> callback,
     const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options)
   : SubscriptionBase(
       node_base,
-      *rclcpp::get_message_typesupport_handle(topic_type, "rosidl_typesupport_cpp", *ts_lib),
+      *rclcpp::get_typesupport_handle(topic_type, "rosidl_typesupport_cpp", *ts_lib),
       topic_name,
       options.to_rcl_subscription_options(qos),
       options.event_callbacks,
       options.use_default_callbacks,
       DeliveredMessageKind::SERIALIZED_MESSAGE),
-    any_callback_(callback),
+    callback_(callback),
     ts_lib_(ts_lib)
-  {
-    TRACETOOLS_TRACEPOINT(
-      rclcpp_subscription_init,
-      static_cast<const void *>(get_subscription_handle().get()),
-      static_cast<const void *>(this));
-    TRACETOOLS_TRACEPOINT(
-      rclcpp_subscription_callback_added,
-      static_cast<const void *>(this),
-      static_cast<const void *>(&any_callback_));
-
-#ifndef TRACETOOLS_DISABLED
-    any_callback_.register_callback_for_tracing();
-#endif
-  }
+  {}
 
   RCLCPP_PUBLIC
   virtual ~GenericSubscription() = default;
@@ -162,7 +150,8 @@ public:
 
 private:
   RCLCPP_DISABLE_COPY(GenericSubscription)
-  AnySubscriptionCallback<rclcpp::SerializedMessage, std::allocator<void>> any_callback_;
+
+  std::function<void(std::shared_ptr<rclcpp::SerializedMessage>)> callback_;
   // The type support library should stay loaded, so it is stored in the GenericSubscription
   std::shared_ptr<rcpputils::SharedLibrary> ts_lib_;
 };

rclcpp/include/rclcpp/guard_condition.hpp

@@ -48,7 +48,7 @@ public:
    */
   RCLCPP_PUBLIC
   explicit GuardCondition(
-    const rclcpp::Context::SharedPtr & context =
+    rclcpp::Context::SharedPtr context =
     rclcpp::contexts::get_global_default_context(),
     rcl_guard_condition_options_t guard_condition_options =
     rcl_guard_condition_get_default_options());
@@ -57,6 +57,11 @@ public:
   virtual
   ~GuardCondition();
 
+  /// Return the context used when creating this guard condition.
+  RCLCPP_PUBLIC
+  rclcpp::Context::SharedPtr
+  get_context() const;
+
   /// Return the underlying rcl guard condition structure.
   RCLCPP_PUBLIC
   rcl_guard_condition_t &
@@ -100,7 +105,7 @@ public:
    */
   RCLCPP_PUBLIC
   void
-  add_to_wait_set(rcl_wait_set_t & wait_set);
+  add_to_wait_set(rcl_wait_set_t * wait_set);
 
   /// Set a callback to be called whenever the guard condition is triggered.
   /**
@@ -123,14 +128,13 @@ public:
   set_on_trigger_callback(std::function<void(size_t)> callback);
 
 protected:
+  rclcpp::Context::SharedPtr context_;
   rcl_guard_condition_t rcl_guard_condition_;
   std::atomic<bool> in_use_by_wait_set_{false};
   std::recursive_mutex reentrant_mutex_;
   std::function<void(size_t)> on_trigger_callback_{nullptr};
   size_t unread_count_{0};
-  // the type of wait_set_ is actually rcl_wait_set_t *, but it's never
-  // dereferenced, only compared to, so make it void * to avoid accidental use
-  void * wait_set_{nullptr};
+  rcl_wait_set_t * wait_set_{nullptr};
 };
 
 }  // namespace rclcpp

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>
@@ -87,8 +86,8 @@ get_node_logger(const rcl_node_t * node);
  * \throws rclcpp::exceptions::RCLError if an unexpected error occurs.
  */
 RCLCPP_PUBLIC
-std::filesystem::path
-get_log_directory();
+rcpputils::fs::path
+get_logging_directory();
 
 class Logger
 {
@@ -127,6 +126,9 @@ private:
   std::shared_ptr<std::pair<std::string, std::string>> logger_sublogger_pairname_ = nullptr;
 
 public:
+  RCLCPP_PUBLIC
+  Logger(const Logger &) = default;
+
   /// Get the name of this logger.
   /**
    * \return the full name of the logger including any prefixes, or

rclcpp/include/rclcpp/node.hpp

@@ -42,9 +42,7 @@
 #include "rclcpp/clock.hpp"
 #include "rclcpp/context.hpp"
 #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"
@@ -58,7 +56,6 @@
 #include "rclcpp/node_interfaces/node_time_source_interface.hpp"
 #include "rclcpp/node_interfaces/node_timers_interface.hpp"
 #include "rclcpp/node_interfaces/node_topics_interface.hpp"
-#include "rclcpp/node_interfaces/node_type_descriptions_interface.hpp"
 #include "rclcpp/node_interfaces/node_waitables_interface.hpp"
 #include "rclcpp/node_options.hpp"
 #include "rclcpp/parameter.hpp"
@@ -235,15 +232,13 @@ public:
    * \param[in] period Time interval between triggers of the callback.
    * \param[in] callback User-defined callback function.
    * \param[in] group Callback group to execute this timer's callback in.
-   * \param[in] autostart The state of the clock on initialization.
    */
   template<typename DurationRepT = int64_t, typename DurationT = std::milli, typename CallbackT>
   typename rclcpp::WallTimer<CallbackT>::SharedPtr
   create_wall_timer(
     std::chrono::duration<DurationRepT, DurationT> period,
     CallbackT callback,
-    rclcpp::CallbackGroup::SharedPtr group = nullptr,
-    bool autostart = true);
+    rclcpp::CallbackGroup::SharedPtr group = nullptr);
 
   /// Create a timer that uses the node clock to drive the callback.
   /**
@@ -258,6 +253,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 +283,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.
@@ -288,40 +317,6 @@ public:
     const rclcpp::QoS & qos = rclcpp::ServicesQoS(),
     rclcpp::CallbackGroup::SharedPtr group = nullptr);
 
-  /// Create and return a GenericClient.
-  /**
-   * \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] qos Quality of service profile for client.
-   * \param[in] group Callback group to handle the reply to service calls.
-   * \return Shared pointer to the created GenericClient.
-   */
-  RCLCPP_PUBLIC
-  rclcpp::GenericClient::SharedPtr
-  create_generic_client(
-    const std::string & service_name,
-    const std::string & service_type,
-    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
@@ -360,14 +355,12 @@ public:
  * `%callback_group`.
    * \return Shared pointer to the created generic subscription.
    */
-  template<
-    typename CallbackT,
-    typename AllocatorT = std::allocator<void>>
+  template<typename AllocatorT = std::allocator<void>>
   std::shared_ptr<rclcpp::GenericSubscription> create_generic_subscription(
     const std::string & topic_name,
     const std::string & topic_type,
     const rclcpp::QoS & qos,
-    CallbackT && callback,
+    std::function<void(std::shared_ptr<rclcpp::SerializedMessage>)> callback,
     const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options = (
       rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()
     )
@@ -976,16 +969,7 @@ public:
 
   /// Return a list of parameters with any of the given prefixes, up to the given depth.
   /**
-   * Parameters are separated into a hierarchy using the "." (dot) character.
-   * The "prefixes" argument is a way to select only particular parts of the hierarchy.
-   *
-   * \param[in] prefixes The list of prefixes that should be searched for within the
-   * current parameters. If this vector of prefixes is empty, then list_parameters
-   * will return all parameters.
-   * \param[in] depth An unsigned integer that represents the recursive depth to search.
-   * If this depth = 0, then all parameters that fit the prefixes will be returned.
-   * \returns A ListParametersResult message which contains both an array of unique prefixes
-   * and an array of names that were matched to the prefixes given.
+   * \todo: properly document and test this method.
    */
   RCLCPP_PUBLIC
   rcl_interfaces::msg::ListParametersResult
@@ -1000,6 +984,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;
@@ -1316,26 +1302,6 @@ public:
   size_t
   count_subscribers(const std::string & topic_name) const;
 
-  /// Return the number of clients created for a given service.
-  /**
-   * \param[in] service_name the actual service name used; it will not be automatically remapped.
-   * \return number of clients that have been created for the given service.
-   * \throws std::runtime_error if clients could not be counted
-   */
-  RCLCPP_PUBLIC
-  size_t
-  count_clients(const std::string & service_name) const;
-
-  /// Return the number of services created for a given service.
-  /**
-   * \param[in] service_name the actual service name used; it will not be automatically remapped.
-   * \return number of services that have been created for the given service.
-   * \throws std::runtime_error if services could not be counted
-   */
-  RCLCPP_PUBLIC
-  size_t
-  count_services(const std::string & service_name) const;
-
   /// Return the topic endpoint information about publishers on a given topic.
   /**
    * The returned parameter is a list of topic endpoint information, where each item will contain
@@ -1430,7 +1396,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
    */
@@ -1488,11 +1454,6 @@ public:
   rclcpp::node_interfaces::NodeTimeSourceInterface::SharedPtr
   get_node_time_source_interface();
 
-  /// Return the Node's internal NodeTypeDescriptionsInterface implementation.
-  RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeTypeDescriptionsInterface::SharedPtr
-  get_node_type_descriptions_interface();
-
   /// Return the sub-namespace, if this is a sub-node, otherwise an empty string.
   /**
    * The returned sub-namespace is either the accumulated sub-namespaces which
@@ -1559,10 +1520,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.
@@ -1629,18 +1586,11 @@ private:
   rclcpp::node_interfaces::NodeClockInterface::SharedPtr node_clock_;
   rclcpp::node_interfaces::NodeParametersInterface::SharedPtr node_parameters_;
   rclcpp::node_interfaces::NodeTimeSourceInterface::SharedPtr node_time_source_;
-  rclcpp::node_interfaces::NodeTypeDescriptionsInterface::SharedPtr node_type_descriptions_;
   rclcpp::node_interfaces::NodeWaitablesInterface::SharedPtr node_waitables_;
 
   const rclcpp::NodeOptions node_options_;
   const std::string sub_namespace_;
   const std::string effective_namespace_;
-
-  class NodeImpl;
-  // This member is meant to be a place to backport features into stable distributions,
-  // and new features targeting Rolling should not use this.
-  // See the comment in node.cpp for more information.
-  std::shared_ptr<NodeImpl> hidden_impl_{nullptr};
 };
 
 }  // namespace rclcpp

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"
@@ -111,16 +110,14 @@ typename rclcpp::WallTimer<CallbackT>::SharedPtr
 Node::create_wall_timer(
   std::chrono::duration<DurationRepT, DurationT> period,
   CallbackT callback,
-  rclcpp::CallbackGroup::SharedPtr group,
-  bool autostart)
+  rclcpp::CallbackGroup::SharedPtr group)
 {
   return rclcpp::create_wall_timer(
     period,
     std::move(callback),
     group,
     this->node_base_.get(),
-    this->node_timers_.get(),
-    autostart);
+    this->node_timers_.get());
 }
 
 template<typename DurationRepT, typename DurationT, typename CallbackT>
@@ -155,6 +152,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 +185,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);
 }
 
@@ -208,13 +219,13 @@ Node::create_generic_publisher(
   );
 }
 
-template<typename CallbackT, typename AllocatorT>
+template<typename AllocatorT>
 std::shared_ptr<rclcpp::GenericSubscription>
 Node::create_generic_subscription(
   const std::string & topic_name,
   const std::string & topic_type,
   const rclcpp::QoS & qos,
-  CallbackT && callback,
+  std::function<void(std::shared_ptr<rclcpp::SerializedMessage>)> callback,
   const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options)
 {
   return rclcpp::create_generic_subscription(
@@ -222,7 +233,7 @@ Node::create_generic_subscription(
     extend_name_with_sub_namespace(topic_name, this->get_sub_namespace()),
     topic_type,
     qos,
-    std::forward<CallbackT>(callback),
+    std::move(callback),
     options
   );
 }
@@ -323,9 +334,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 +353,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/detail/node_interfaces_helpers.hpp

@@ -167,7 +167,6 @@ init_tuple(NodeT & n)
  * something like that, then you'll need to create your own specialization of
  * the NodeInterfacesSupports struct without this macro.
  */
-// *INDENT-OFF*
 #define RCLCPP_NODE_INTERFACE_HELPERS_SUPPORT(NodeInterfaceType, NodeInterfaceName) \
   namespace rclcpp::node_interfaces::detail { \
   template<typename StorageClassT, typename ... RemainingInterfaceTs> \
@@ -190,7 +189,7 @@ init_tuple(NodeT & n)
     /* Perfect forwarding constructor to get arguments down to StorageClassT (eventually). */ \
     template<typename ... ArgsT> \
     explicit NodeInterfacesSupports(ArgsT && ... args) \
-    : NodeInterfacesSupports<StorageClassT, RemainingInterfaceTs ...>( \
+      : NodeInterfacesSupports<StorageClassT, RemainingInterfaceTs ...>( \
         std::forward<ArgsT>(args) ...) \
     {} \
  \
@@ -201,7 +200,6 @@ init_tuple(NodeT & n)
     } \
   }; \
   }  // namespace rclcpp::node_interfaces::detail
-// *INDENT-ON*
 
 }  // namespace detail
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_graph.hpp

@@ -113,14 +113,6 @@ public:
   size_t
   count_subscribers(const std::string & topic_name) const override;
 
-  RCLCPP_PUBLIC
-  size_t
-  count_clients(const std::string & service_name) const override;
-
-  RCLCPP_PUBLIC
-  size_t
-  count_services(const std::string & service_name) const override;
-
   RCLCPP_PUBLIC
   const rcl_guard_condition_t *
   get_graph_guard_condition() const override;

rclcpp/include/rclcpp/node_interfaces/node_graph_interface.hpp

@@ -305,24 +305,6 @@ public:
   size_t
   count_subscribers(const std::string & topic_name) const = 0;
 
-  /// Return the number of clients created for a given service.
-  /*
-   * \param[in] service_name the actual service name used; it will not be automatically remapped.
-   */
-  RCLCPP_PUBLIC
-  virtual
-  size_t
-  count_clients(const std::string & service_name) const = 0;
-
-  /// Return the number of services created for a given service.
-  /*
-   * \param[in] service_name the actual service name used; it will not be automatically remapped.
-   */
-  RCLCPP_PUBLIC
-  virtual
-  size_t
-  count_services(const std::string & service_name) const = 0;
-
   /// Return the rcl guard condition which is triggered when the ROS graph changes.
   RCLCPP_PUBLIC
   virtual

rclcpp/include/rclcpp/node_interfaces/node_interfaces.hpp

@@ -30,7 +30,6 @@
   rclcpp::node_interfaces::NodeTimeSourceInterface, \
   rclcpp::node_interfaces::NodeTimersInterface, \
   rclcpp::node_interfaces::NodeTopicsInterface, \
-  rclcpp::node_interfaces::NodeTypeDescriptionsInterface, \
   rclcpp::node_interfaces::NodeWaitablesInterface
 
 
@@ -119,7 +118,6 @@ public:
    *   - rclcpp::node_interfaces::NodeTimeSourceInterface
    *   - rclcpp::node_interfaces::NodeTimersInterface
    *   - rclcpp::node_interfaces::NodeTopicsInterface
-   *   - rclcpp::node_interfaces::NodeTypeDescriptionsInterface
    *   - rclcpp::node_interfaces::NodeWaitablesInterface
    *
    * Or you use custom interfaces as long as you make a template specialization
@@ -127,9 +125,7 @@ public:
    * the RCLCPP_NODE_INTERFACE_HELPERS_SUPPORT macro.
    *
    * Usage example:
-   *   ```cpp
-   *   RCLCPP_NODE_INTERFACE_HELPERS_SUPPORT(rclcpp::node_interfaces::NodeBaseInterface, base)
-   *   ```
+   *   ```RCLCPP_NODE_INTERFACE_HELPERS_SUPPORT(rclcpp::node_interfaces::NodeBaseInterface, base)```
    *
    * If you choose not to use the helper macro, then you can specialize the
    * template yourself, but you must:

rclcpp/include/rclcpp/node_interfaces/node_logging.hpp

@@ -23,9 +23,6 @@
 #include "rclcpp/node_interfaces/node_logging_interface.hpp"
 #include "rclcpp/visibility_control.hpp"
 
-#include "rcl_interfaces/srv/get_logger_levels.hpp"
-#include "rcl_interfaces/srv/set_logger_levels.hpp"
-
 namespace rclcpp
 {
 namespace node_interfaces
@@ -38,7 +35,7 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(NodeLoggingInterface)
 
   RCLCPP_PUBLIC
-  explicit NodeLogging(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base);
+  explicit NodeLogging(rclcpp::node_interfaces::NodeBaseInterface * node_base);
 
   RCLCPP_PUBLIC
   virtual
@@ -52,21 +49,13 @@ public:
   const char *
   get_logger_name() const override;
 
-  RCLCPP_PUBLIC
-  void
-  create_logger_services(
-    node_interfaces::NodeServicesInterface::SharedPtr node_services) override;
-
 private:
   RCLCPP_DISABLE_COPY(NodeLogging)
 
   /// Handle to the NodeBaseInterface given in the constructor.
-  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base_;
+  rclcpp::node_interfaces::NodeBaseInterface * node_base_;
 
   rclcpp::Logger logger_;
-
-  rclcpp::Service<rcl_interfaces::srv::GetLoggerLevels>::SharedPtr get_loggers_service_;
-  rclcpp::Service<rcl_interfaces::srv::SetLoggerLevels>::SharedPtr set_loggers_service_;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_logging_interface.hpp

@@ -19,7 +19,6 @@
 
 #include "rclcpp/logger.hpp"
 #include "rclcpp/macros.hpp"
-#include "rclcpp/node_interfaces/node_services_interface.hpp"
 #include "rclcpp/node_interfaces/detail/node_interfaces_helpers.hpp"
 #include "rclcpp/visibility_control.hpp"
 
@@ -55,13 +54,6 @@ public:
   virtual
   const char *
   get_logger_name() const = 0;
-
-  /// create logger services
-  RCLCPP_PUBLIC
-  virtual
-  void
-  create_logger_services(
-    node_interfaces::NodeServicesInterface::SharedPtr node_services) = 0;
 };
 
 }  // namespace node_interfaces

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_interfaces/node_type_descriptions.hpp

@@ -1,63 +0,0 @@
-// Copyright 2023 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef RCLCPP__NODE_INTERFACES__NODE_TYPE_DESCRIPTIONS_HPP_
-#define RCLCPP__NODE_INTERFACES__NODE_TYPE_DESCRIPTIONS_HPP_
-
-#include <memory>
-
-#include "rclcpp/macros.hpp"
-#include "rclcpp/node_interfaces/node_base_interface.hpp"
-#include "rclcpp/node_interfaces/node_logging_interface.hpp"
-#include "rclcpp/node_interfaces/node_parameters_interface.hpp"
-#include "rclcpp/node_interfaces/node_services_interface.hpp"
-#include "rclcpp/node_interfaces/node_topics_interface.hpp"
-#include "rclcpp/node_interfaces/node_type_descriptions_interface.hpp"
-#include "rclcpp/visibility_control.hpp"
-
-namespace rclcpp
-{
-namespace node_interfaces
-{
-
-/// Implementation of the NodeTypeDescriptions part of the Node API.
-class NodeTypeDescriptions : public NodeTypeDescriptionsInterface
-{
-public:
-  RCLCPP_SMART_PTR_ALIASES_ONLY(NodeTypeDescriptions)
-
-  RCLCPP_PUBLIC
-  explicit NodeTypeDescriptions(
-    NodeBaseInterface::SharedPtr node_base,
-    NodeLoggingInterface::SharedPtr node_logging,
-    NodeParametersInterface::SharedPtr node_parameters,
-    NodeServicesInterface::SharedPtr node_services);
-
-  RCLCPP_PUBLIC
-  virtual
-  ~NodeTypeDescriptions();
-
-private:
-  RCLCPP_DISABLE_COPY(NodeTypeDescriptions)
-
-  // Pimpl hides helper types and functions used for wrapping a C service, which would be
-  // awkward to expose in this header.
-  class NodeTypeDescriptionsImpl;
-  std::unique_ptr<NodeTypeDescriptionsImpl> impl_;
-};
-
-}  // namespace node_interfaces
-}  // namespace rclcpp
-
-#endif  // RCLCPP__NODE_INTERFACES__NODE_TYPE_DESCRIPTIONS_HPP_

rclcpp/include/rclcpp/node_interfaces/node_type_descriptions_interface.hpp

@@ -1,44 +0,0 @@
-// Copyright 2023 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef RCLCPP__NODE_INTERFACES__NODE_TYPE_DESCRIPTIONS_INTERFACE_HPP_
-#define RCLCPP__NODE_INTERFACES__NODE_TYPE_DESCRIPTIONS_INTERFACE_HPP_
-
-#include "rclcpp/macros.hpp"
-#include "rclcpp/node_interfaces/detail/node_interfaces_helpers.hpp"
-#include "rclcpp/visibility_control.hpp"
-
-namespace rclcpp
-{
-namespace node_interfaces
-{
-
-/// Pure virtual interface class for the NodeTypeDescriptions part of the Node API.
-class NodeTypeDescriptionsInterface
-{
-public:
-  RCLCPP_SMART_PTR_ALIASES_ONLY(NodeTypeDescriptionsInterface)
-
-  RCLCPP_PUBLIC
-  virtual
-  ~NodeTypeDescriptionsInterface() = default;
-};
-
-}  // namespace node_interfaces
-}  // namespace rclcpp
-
-RCLCPP_NODE_INTERFACE_HELPERS_SUPPORT(
-  rclcpp::node_interfaces::NodeTypeDescriptionsInterface, type_descriptions)
-
-#endif  // RCLCPP__NODE_INTERFACES__NODE_TYPE_DESCRIPTIONS_INTERFACE_HPP_

rclcpp/include/rclcpp/node_options.hpp

@@ -43,7 +43,6 @@ public:
    *   - arguments = {}
    *   - parameter_overrides = {}
    *   - use_global_arguments = true
-   *   - enable_rosout = true
    *   - use_intra_process_comms = false
    *   - enable_topic_statistics = false
    *   - start_parameter_services = true
@@ -51,7 +50,6 @@ public:
    *   - clock_type = RCL_ROS_TIME
    *   - clock_qos = rclcpp::ClockQoS()
    *   - use_clock_thread = true
-   *   - enable_logger_service = false
    *   - rosout_qos = rclcpp::RosoutQoS()
    *   - parameter_event_qos = rclcpp::ParameterEventQoS
    *     - with history setting and depth from rmw_qos_profile_parameter_events
@@ -234,24 +232,6 @@ public:
   NodeOptions &
   start_parameter_services(bool start_parameter_services);
 
-  /// Return the enable_logger_service flag.
-  RCLCPP_PUBLIC
-  bool
-  enable_logger_service() const;
-
-  /// Set the enable_logger_service flag, return this for logger idiom.
-  /**
-   * If true, ROS services are created to allow external nodes to get
-   * and set logger levels of this node.
-   *
-   * If false, loggers will still be configured and set logger levels locally,
-   * but logger levels cannot be changed remotely .
-   *
-   */
-  RCLCPP_PUBLIC
-  NodeOptions &
-  enable_logger_service(bool enable_log_service);
-
   /// Return the start_parameter_event_publisher flag.
   RCLCPP_PUBLIC
   bool
@@ -441,8 +421,6 @@ private:
 
   bool use_clock_thread_ {true};
 
-  bool enable_logger_service_ {false};
-
   rclcpp::QoS parameter_event_qos_ = rclcpp::ParameterEventsQoS(
     rclcpp::QoSInitialization::from_rmw(rmw_qos_profile_parameter_events)
   );

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,11 +45,10 @@ 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:
    *
-   * If you have received a parameter event and are only interested in parameters foo and
+   * If you have recieved a parameter event and are only interested in parameters foo and
    * bar being added or changed but don't care about deletion.
    *
    * ```cpp

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

@@ -24,7 +24,6 @@
 
 #include "rcl_interfaces/msg/parameter_type.hpp"
 #include "rcl_interfaces/msg/parameter_value.hpp"
-#include "rclcpp/exceptions/exceptions.hpp"
 #include "rclcpp/visibility_control.hpp"
 
 namespace rclcpp
@@ -359,7 +358,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

@@ -32,9 +32,6 @@
 #include "rclcpp/allocator/allocator_common.hpp"
 #include "rclcpp/allocator/allocator_deleter.hpp"
 #include "rclcpp/detail/resolve_use_intra_process.hpp"
-#include "rclcpp/detail/resolve_intra_process_buffer_type.hpp"
-#include "rclcpp/experimental/buffers/intra_process_buffer.hpp"
-#include "rclcpp/experimental/create_intra_process_buffer.hpp"
 #include "rclcpp/experimental/intra_process_manager.hpp"
 #include "rclcpp/get_message_type_support_handle.hpp"
 #include "rclcpp/is_ros_compatible_type.hpp"
@@ -96,11 +93,21 @@ public:
   using ROSMessageTypeAllocator = typename ROSMessageTypeAllocatorTraits::allocator_type;
   using ROSMessageTypeDeleter = allocator::Deleter<ROSMessageTypeAllocator, ROSMessageType>;
 
-  using BufferSharedPtr = typename rclcpp::experimental::buffers::IntraProcessBuffer<
-    ROSMessageType,
-    ROSMessageTypeAllocator,
-    ROSMessageTypeDeleter
-    >::SharedPtr;
+  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>;
 
   RCLCPP_SMART_PTR_DEFINITIONS(Publisher<MessageT, AllocatorT>)
 
@@ -112,8 +119,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,35 +150,32 @@ 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) {
-        throw std::invalid_argument(
-                "intraprocess communication on topic '" + topic +
-                "' allowed only with keep last history qos policy");
-      }
-      if (qos_profile.depth() == 0) {
-        throw std::invalid_argument(
-                "intraprocess communication on topic '" + topic +
-                "' is not allowed with a zero qos history depth value");
-      }
-      if (qos_profile.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,
-          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_);
+      if (qos.history() != rclcpp::HistoryPolicy::KeepLast) {
+        throw std::invalid_argument(
+                "intraprocess communication allowed only with keep last history qos policy");
+      }
+      if (qos.depth() == 0) {
+        throw std::invalid_argument(
+                "intraprocess communication is not allowed with a zero qos history depth value");
+      }
+      if (qos.durability() != rclcpp::DurabilityPolicy::Volatile) {
+        throw std::invalid_argument(
+                "intraprocess communication allowed only with volatile durability");
+      }
+      uint64_t intra_process_publisher_id = ipm->add_publisher(this->shared_from_this());
       this->setup_intra_process(
         intra_process_publisher_id,
         ipm);
@@ -187,7 +191,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,28 +236,15 @@ 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 =
         this->do_intra_process_ros_message_publish_and_return_shared(std::move(msg));
-      if (buffer_) {
-        buffer_->add_shared(shared_msg);
-      }
       this->do_inter_process_publish(*shared_msg);
     } else {
-      if (buffer_) {
-        auto shared_msg =
-          this->do_intra_process_ros_message_publish_and_return_shared(std::move(msg));
-        buffer_->add_shared(shared_msg);
-      } else {
-        this->do_intra_process_ros_message_publish(std::move(msg));
-      }
+      this->do_intra_process_ros_message_publish(std::move(msg));
     }
   }
 
@@ -278,8 +269,8 @@ public:
   {
     // Avoid allocating when not using intra process.
     if (!intra_process_is_enabled_) {
-      this->do_inter_process_publish(msg);
-      return;
+      // In this case we're not using intra process.
+      return this->do_inter_process_publish(msg);
     }
     // Otherwise we have to allocate memory in a unique_ptr and pass it along.
     // As the message is not const, a copy should be made.
@@ -306,34 +297,26 @@ public:
   >
   publish(std::unique_ptr<T, PublishedTypeDeleter> msg)
   {
+    // Avoid allocating when not using intra process.
     if (!intra_process_is_enabled_) {
       // In this case we're not using intra process.
-      auto ros_msg_ptr = std::make_unique<ROSMessageType>();
-      rclcpp::TypeAdapter<MessageT>::convert_to_ros_message(*msg, *ros_msg_ptr);
-      this->do_inter_process_publish(*ros_msg_ptr);
-      return;
+      ROSMessageType ros_msg;
+      rclcpp::TypeAdapter<MessageT>::convert_to_ros_message(*msg, ros_msg);
+      return this->do_inter_process_publish(ros_msg);
     }
 
-    // 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>();
-      rclcpp::TypeAdapter<MessageT>::convert_to_ros_message(*msg, *ros_msg_ptr);
+      ROSMessageType ros_msg;
+      // TODO(clalancette): This is unnecessarily doing an additional conversion
+      // that may have already been done in do_intra_process_publish_and_return_shared().
+      // We should just reuse that effort.
+      rclcpp::TypeAdapter<MessageT>::convert_to_ros_message(*msg, ros_msg);
       this->do_intra_process_publish(std::move(msg));
-      this->do_inter_process_publish(*ros_msg_ptr);
-      if (buffer_) {
-        buffer_->add_shared(ros_msg_ptr);
-      }
+      this->do_inter_process_publish(ros_msg);
     } else {
-      if (buffer_) {
-        auto ros_msg_ptr = std::make_shared<ROSMessageType>();
-        rclcpp::TypeAdapter<MessageT>::convert_to_ros_message(*msg, *ros_msg_ptr);
-        buffer_->add_shared(ros_msg_ptr);
-      }
       this->do_intra_process_publish(std::move(msg));
     }
   }
@@ -356,12 +339,13 @@ public:
   >
   publish(const T & msg)
   {
+    // Avoid double allocating when not using intra process.
     if (!intra_process_is_enabled_) {
       // Convert to the ROS message equivalent and publish it.
-      auto ros_msg_ptr = std::make_unique<ROSMessageType>();
-      rclcpp::TypeAdapter<MessageT>::convert_to_ros_message(msg, *ros_msg_ptr);
-      this->do_inter_process_publish(*ros_msg_ptr);
-      return;
+      ROSMessageType ros_msg;
+      rclcpp::TypeAdapter<MessageT>::convert_to_ros_message(msg, ros_msg);
+      // In this case we're not using intra process.
+      return this->do_inter_process_publish(ros_msg);
     }
 
     // Otherwise we have to allocate memory in a unique_ptr and pass it along.
@@ -406,7 +390,7 @@ public:
     if (this->can_loan_messages()) {
       // we release the ownership from the rclpp::LoanedMessage instance
       // and let the middleware clean up the memory.
-      this->do_loaned_message_publish(loaned_msg.release());
+      this->do_loaned_message_publish(std::move(loaned_msg.release()));
     } else {
       // we don't release the ownership, let the middleware copy the ros message
       // and thus the destructor of rclcpp::LoanedMessage cleans up the memory.
@@ -414,6 +398,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
   {
@@ -430,7 +421,7 @@ protected:
   void
   do_inter_process_publish(const ROSMessageType & msg)
   {
-    TRACETOOLS_TRACEPOINT(rclcpp_publish, nullptr, static_cast<const void *>(&msg));
+    TRACEPOINT(rclcpp_publish, nullptr, static_cast<const void *>(&msg));
     auto status = rcl_publish(publisher_handle_.get(), &msg, nullptr);
 
     if (RCL_RET_PUBLISHER_INVALID == status) {
@@ -465,7 +456,6 @@ protected:
   do_loaned_message_publish(
     std::unique_ptr<ROSMessageType, std::function<void(ROSMessageType *)>> msg)
   {
-    TRACETOOLS_TRACEPOINT(rclcpp_publish, nullptr, static_cast<const void *>(msg.get()));
     auto status = rcl_publish_loaned_message(publisher_handle_.get(), msg.get(), nullptr);
 
     if (RCL_RET_PUBLISHER_INVALID == status) {
@@ -494,7 +484,7 @@ protected:
     if (!msg) {
       throw std::runtime_error("cannot publish msg which is a null pointer");
     }
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_intra_publish,
       static_cast<const void *>(publisher_handle_.get()),
       msg.get());
@@ -516,7 +506,7 @@ protected:
     if (!msg) {
       throw std::runtime_error("cannot publish msg which is a null pointer");
     }
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_intra_publish,
       static_cast<const void *>(publisher_handle_.get()),
       msg.get());
@@ -539,7 +529,7 @@ protected:
     if (!msg) {
       throw std::runtime_error("cannot publish msg which is a null pointer");
     }
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_intra_publish,
       static_cast<const void *>(publisher_handle_.get()),
       msg.get());
@@ -590,8 +580,6 @@ protected:
   PublishedTypeDeleter published_type_deleter_;
   ROSMessageTypeAllocator ros_message_type_allocator_;
   ROSMessageTypeDeleter ros_message_type_deleter_;
-
-  BufferSharedPtr buffer_{nullptr};
 };
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/publisher_base.hpp

@@ -139,12 +139,6 @@ public:
   size_t
   get_intra_process_subscription_count() const;
 
-  /// Get if durability is transient local
-  /** \return If durability is transient local*/
-  RCLCPP_PUBLIC
-  bool
-  is_durability_transient_local() const;
-
   /// Manually assert that this Publisher is alive (for RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC).
   /**
    * If the rmw Liveliness policy is set to RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC, the creator
@@ -221,17 +215,6 @@ public:
   std::vector<rclcpp::NetworkFlowEndpoint>
   get_network_flow_endpoints() const;
 
-  /// Return the lowest available capacity for all subscription buffers.
-  /**
-   * For intraprocess communication return the lowest buffer capacity for all subscriptions.
-   * If intraprocess is disabled or no intraprocess subscriptions present, return maximum of size_t.
-   * On failure return 0.
-   * \return lowest buffer capacity for all subscriptions
-   */
-  RCLCPP_PUBLIC
-  size_t
-  lowest_available_ipm_capacity() const;
-
   /// Wait until all published messages are acknowledged or until the specified timeout elapses.
   /**
    * This method waits until all published messages are acknowledged by all matching

rclcpp/include/rclcpp/publisher_options.hpp

@@ -24,7 +24,6 @@
 
 #include "rclcpp/allocator/allocator_common.hpp"
 #include "rclcpp/detail/rmw_implementation_specific_publisher_payload.hpp"
-#include "rclcpp/intra_process_buffer_type.hpp"
 #include "rclcpp/intra_process_setting.hpp"
 #include "rclcpp/qos.hpp"
 #include "rclcpp/event_handler.hpp"
@@ -41,9 +40,6 @@ struct PublisherOptionsBase
   /// Setting to explicitly set intraprocess communications.
   IntraProcessSetting use_intra_process_comm = IntraProcessSetting::NodeDefault;
 
-  /// Setting the data-type stored in the intraprocess buffer
-  IntraProcessBufferType intra_process_buffer_type = IntraProcessBufferType::SharedPtr;
-
   /// Callbacks for various events related to publishers.
   PublisherEventCallbacks event_callbacks;
 

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/qos_event.hpp

@@ -0,0 +1,22 @@
+// Copyright 2019 Open Source Robotics Foundation, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef RCLCPP__QOS_EVENT_HPP_
+#define RCLCPP__QOS_EVENT_HPP_
+
+#warning This header is obsolete, please include rclcpp/event_handler.hpp instead
+
+#include "rclcpp/event_handler.hpp"
+
+#endif  // RCLCPP__QOS_EVENT_HPP_

rclcpp/include/rclcpp/rate.hpp

@@ -19,8 +19,6 @@
 #include <memory>
 #include <thread>
 
-#include "rclcpp/clock.hpp"
-#include "rclcpp/duration.hpp"
 #include "rclcpp/macros.hpp"
 #include "rclcpp/utilities.hpp"
 #include "rclcpp/visibility_control.hpp"
@@ -33,16 +31,9 @@ class RateBase
 public:
   RCLCPP_SMART_PTR_DEFINITIONS_NOT_COPYABLE(RateBase)
 
-  RCLCPP_PUBLIC
   virtual ~RateBase() {}
-
-  RCLCPP_PUBLIC
   virtual bool sleep() = 0;
-
-  RCLCPP_PUBLIC
-  virtual rcl_clock_type_t get_type() const = 0;
-
-  RCLCPP_PUBLIC
+  virtual bool is_steady() const = 0;
   virtual void reset() = 0;
 };
 
@@ -50,54 +41,79 @@ using std::chrono::duration;
 using std::chrono::duration_cast;
 using std::chrono::nanoseconds;
 
-class Rate : public RateBase
+template<class Clock = std::chrono::high_resolution_clock>
+class GenericRate : public RateBase
 {
 public:
-  RCLCPP_SMART_PTR_DEFINITIONS(Rate)
+  RCLCPP_SMART_PTR_DEFINITIONS(GenericRate)
 
-  RCLCPP_PUBLIC
-  explicit Rate(
-    const double rate,
-    Clock::SharedPtr clock = std::make_shared<Clock>(RCL_SYSTEM_TIME));
+  explicit GenericRate(double rate)
+  : GenericRate<Clock>(
+      duration_cast<nanoseconds>(duration<double>(1.0 / rate)))
+  {}
+  explicit GenericRate(std::chrono::nanoseconds period)
+  : period_(period), last_interval_(Clock::now())
+  {}
 
-  RCLCPP_PUBLIC
-  explicit Rate(
-    const Duration & period,
-    Clock::SharedPtr clock = std::make_shared<Clock>(RCL_SYSTEM_TIME));
-
-  RCLCPP_PUBLIC
   virtual bool
-  sleep();
+  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;
+  }
 
-  RCLCPP_PUBLIC
-  virtual rcl_clock_type_t
-  get_type() const;
+  virtual bool
+  is_steady() const
+  {
+    return Clock::is_steady;
+  }
 
-  RCLCPP_PUBLIC
   virtual void
-  reset();
+  reset()
+  {
+    last_interval_ = Clock::now();
+  }
 
-  RCLCPP_PUBLIC
-  std::chrono::nanoseconds
-  period() const;
+  std::chrono::nanoseconds period() const
+  {
+    return period_;
+  }
 
 private:
-  RCLCPP_DISABLE_COPY(Rate)
+  RCLCPP_DISABLE_COPY(GenericRate)
 
-  Clock::SharedPtr clock_;
-  Duration period_;
-  Time last_interval_;
+  std::chrono::nanoseconds period_;
+  using ClockDurationNano = std::chrono::duration<typename Clock::rep, std::nano>;
+  std::chrono::time_point<Clock, ClockDurationNano> last_interval_;
 };
 
-class WallRate : public Rate
-{
-public:
-  RCLCPP_PUBLIC
-  explicit WallRate(const double rate);
-
-  RCLCPP_PUBLIC
-  explicit WallRate(const Duration & period);
-};
+using Rate = GenericRate<std::chrono::system_clock>;
+using WallRate = GenericRate<std::chrono::steady_clock>;
 
 }  // namespace rclcpp
 

rclcpp/include/rclcpp/rclcpp.hpp

@@ -54,7 +54,6 @@
  *   - rclcpp::ParameterValue
  *   - rclcpp::AsyncParametersClient
  *   - rclcpp::SyncParametersClient
- *   - rclcpp::copy_all_parameter_values()
  *   - rclcpp/parameter.hpp
  *   - rclcpp/parameter_value.hpp
  *   - rclcpp/parameter_client.hpp
@@ -96,9 +95,6 @@
  * - Get the number of publishers or subscribers on a topic:
  *   - rclcpp::Node::count_publishers()
  *   - rclcpp::Node::count_subscribers()
- * - Get the number of clients or servers on a service:
- *   - rclcpp::Node::count_clients()
- *   - rclcpp::Node::count_services()
  *
  * And components related to logging:
  *
@@ -168,7 +164,6 @@
 #include <csignal>
 #include <memory>
 
-#include "rclcpp/copy_all_parameter_values.hpp"
 #include "rclcpp/executors.hpp"
 #include "rclcpp/guard_condition.hpp"
 #include "rclcpp/logging.hpp"

rclcpp/include/rclcpp/service.hpp

@@ -265,19 +265,15 @@ protected:
 
   std::shared_ptr<rcl_node_t> node_handle_;
 
-  std::recursive_mutex callback_mutex_;
-  // It is important to declare on_new_request_callback_ before
-  // service_handle_, so on destruction the service is
-  // destroyed first. Otherwise, the rmw service callback
-  // would point briefly to a destroyed function.
-  std::function<void(size_t)> on_new_request_callback_{nullptr};
-  // Declare service_handle_ after callback
   std::shared_ptr<rcl_service_t> service_handle_;
   bool owns_rcl_handle_ = true;
 
   rclcpp::Logger node_logger_;
 
   std::atomic<bool> in_use_by_wait_set_{false};
+
+  std::recursive_mutex callback_mutex_;
+  std::function<void(size_t)> on_new_request_callback_{nullptr};
 };
 
 template<typename ServiceT>
@@ -307,7 +303,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,
@@ -352,7 +348,7 @@ public:
 
       rclcpp::exceptions::throw_from_rcl_error(ret, "could not create service");
     }
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_service_callback_added,
       static_cast<const void *>(get_service_handle().get()),
       static_cast<const void *>(&any_callback_));
@@ -387,7 +383,7 @@ public:
     }
 
     service_handle_ = service_handle;
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_service_callback_added,
       static_cast<const void *>(get_service_handle().get()),
       static_cast<const void *>(&any_callback_));
@@ -424,7 +420,7 @@ public:
     // In this case, rcl owns the service handle memory
     service_handle_ = std::shared_ptr<rcl_service_t>(new rcl_service_t);
     service_handle_->impl = service_handle->impl;
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_service_callback_added,
       static_cast<const void *>(get_service_handle().get()),
       static_cast<const void *>(&any_callback_));
@@ -486,27 +482,16 @@ public:
   {
     rcl_ret_t ret = rcl_send_response(get_service_handle().get(), &req_id, &response);
 
-    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");
     }
   }
 
-  /// Configure service introspection.
+  /// Configure client introspection.
   /**
    * \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

@@ -17,6 +17,7 @@
 
 #include <memory>
 #include <vector>
+#include <utility>
 
 #include "rcl/allocator.h"
 
@@ -120,8 +121,8 @@ public:
       }
     }
     for (size_t i = 0; i < waitable_handles_.size(); ++i) {
-      if (!waitable_handles_[i]->is_ready(*wait_set)) {
-        waitable_handles_[i].reset();
+      if (waitable_handles_[i]->is_ready(wait_set)) {
+        waitable_triggered_handles_.emplace_back(std::move(waitable_handles_[i]));
       }
     }
 
@@ -145,10 +146,7 @@ public:
       timer_handles_.end()
     );
 
-    waitable_handles_.erase(
-      std::remove(waitable_handles_.begin(), waitable_handles_.end(), nullptr),
-      waitable_handles_.end()
-    );
+    waitable_handles_.clear();
   }
 
   bool collect_entities(const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes) override
@@ -201,7 +199,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 +208,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 +217,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 +226,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;
       }
     }
@@ -241,7 +235,7 @@ public:
     }
 
     for (const std::shared_ptr<Waitable> & waitable : waitable_handles_) {
-      waitable->add_to_wait_set(*wait_set);
+      waitable->add_to_wait_set(wait_set);
     }
     return true;
   }
@@ -374,8 +368,7 @@ public:
           ++it;
           continue;
         }
-        auto data = timer->call();
-        if (!data) {
+        if (!timer->call()) {
           // timer was cancelled, skip it.
           ++it;
           continue;
@@ -384,7 +377,6 @@ public:
         any_exec.timer = timer;
         any_exec.callback_group = group;
         any_exec.node_base = get_node_by_group(group, weak_groups_to_nodes);
-        any_exec.data = data;
         timer_handles_.erase(it);
         return;
       }
@@ -398,8 +390,9 @@ public:
     rclcpp::AnyExecutable & any_exec,
     const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes) override
   {
-    auto it = waitable_handles_.begin();
-    while (it != waitable_handles_.end()) {
+    auto & waitable_handles = waitable_triggered_handles_;
+    auto it = waitable_handles.begin();
+    while (it != waitable_handles.end()) {
       std::shared_ptr<Waitable> & waitable = *it;
       if (waitable) {
         // Find the group for this handle and see if it can be serviced
@@ -407,7 +400,7 @@ public:
         if (!group) {
           // Group was not found, meaning the waitable is not valid...
           // Remove it from the ready list and continue looking
-          it = waitable_handles_.erase(it);
+          it = waitable_handles.erase(it);
           continue;
         }
         if (!group->can_be_taken_from().load()) {
@@ -420,11 +413,11 @@ public:
         any_exec.waitable = waitable;
         any_exec.callback_group = group;
         any_exec.node_base = get_node_by_group(group, weak_groups_to_nodes);
-        waitable_handles_.erase(it);
+        waitable_handles.erase(it);
         return;
       }
       // Else, the waitable is no longer valid, remove it and continue
-      it = waitable_handles_.erase(it);
+      it = waitable_handles.erase(it);
     }
   }
 
@@ -505,6 +498,8 @@ private:
   VectorRebind<std::shared_ptr<const rcl_timer_t>> timer_handles_;
   VectorRebind<std::shared_ptr<Waitable>> waitable_handles_;
 
+  VectorRebind<std::shared_ptr<Waitable>> waitable_triggered_handles_;
+
   std::shared_ptr<VoidAlloc> allocator_;
 };
 

rclcpp/include/rclcpp/strategies/message_pool_memory_strategy.hpp

@@ -15,17 +15,10 @@
 #ifndef RCLCPP__STRATEGIES__MESSAGE_POOL_MEMORY_STRATEGY_HPP_
 #define RCLCPP__STRATEGIES__MESSAGE_POOL_MEMORY_STRATEGY_HPP_
 
-#include <array>
-#include <cstring>
 #include <memory>
-#include <mutex>
-#include <stdexcept>
-#include <type_traits>
 
 #include "rosidl_runtime_cpp/traits.hpp"
 
-#include "rclcpp/logger.hpp"
-#include "rclcpp/logging.hpp"
 #include "rclcpp/macros.hpp"
 #include "rclcpp/message_memory_strategy.hpp"
 #include "rclcpp/visibility_control.hpp"
@@ -57,24 +50,13 @@ class MessagePoolMemoryStrategy
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(MessagePoolMemoryStrategy)
 
+  /// Default constructor
   MessagePoolMemoryStrategy()
+  : next_array_index_(0)
   {
-    pool_mutex_ = std::make_shared<std::mutex>();
-
-    pool_ = std::shared_ptr<std::array<MessageT *, Size>>(
-      new std::array<MessageT *, Size>,
-      [](std::array<MessageT *, Size> * arr) {
-        for (size_t i = 0; i < Size; ++i) {
-          free((*arr)[i]);
-        }
-        delete arr;
-      });
-
-    free_list_ = std::make_shared<CircularArray<Size>>();
-
     for (size_t i = 0; i < Size; ++i) {
-      (*pool_)[i] = static_cast<MessageT *>(malloc(sizeof(MessageT)));
-      free_list_->push_back(i);
+      pool_[i].msg_ptr_ = std::make_shared<MessageT>();
+      pool_[i].used = false;
     }
   }
 
@@ -86,85 +68,43 @@ public:
    */
   std::shared_ptr<MessageT> borrow_message()
   {
-    std::lock_guard<std::mutex> lock(*pool_mutex_);
-    if (free_list_->size() == 0) {
-      throw std::runtime_error("No more free slots in the pool");
+    size_t current_index = next_array_index_;
+    next_array_index_ = (next_array_index_ + 1) % Size;
+    if (pool_[current_index].used) {
+      throw std::runtime_error("Tried to access message that was still in use! Abort.");
     }
+    pool_[current_index].msg_ptr_->~MessageT();
+    new (pool_[current_index].msg_ptr_.get())MessageT;
 
-    size_t current_index = free_list_->pop_front();
-
-    return std::shared_ptr<MessageT>(
-      new((*pool_)[current_index]) MessageT(),
-      [pool = this->pool_, pool_mutex = this->pool_mutex_,
-      free_list = this->free_list_](MessageT * p) {
-        std::lock_guard<std::mutex> lock(*pool_mutex);
-        for (size_t i = 0; i < Size; ++i) {
-          if ((*pool)[i] == p) {
-            p->~MessageT();
-            free_list->push_back(i);
-            break;
-          }
-        }
-      });
+    pool_[current_index].used = true;
+    return pool_[current_index].msg_ptr_;
   }
 
   /// Return a message to the message pool.
   /**
-   * This does nothing since the message isn't returned to the pool until the user has dropped
-   * all references.
+   * Manage metadata in the message pool ring buffer to release the message.
    * \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.
+    for (size_t i = 0; i < Size; ++i) {
+      if (pool_[i].msg_ptr_ == msg) {
+        pool_[i].used = false;
+        return;
+      }
+    }
+    throw std::runtime_error("Unrecognized message ptr in return_message.");
   }
 
 protected:
-  template<size_t N>
-  class CircularArray
+  struct PoolMember
   {
-public:
-    void push_back(const size_t v)
-    {
-      if (size_ + 1 > N) {
-        throw std::runtime_error("Tried to push too many items into the array");
-      }
-      array_[(front_ + size_) % N] = v;
-      ++size_;
-    }
-
-    size_t pop_front()
-    {
-      if (size_ < 1) {
-        throw std::runtime_error("Tried to pop item from empty array");
-      }
-
-      size_t val = array_[front_];
-
-      front_ = (front_ + 1) % N;
-      --size_;
-
-      return val;
-    }
-
-    size_t size() const
-    {
-      return size_;
-    }
-
-private:
-    size_t front_ = 0;
-    size_t size_ = 0;
-    std::array<size_t, N> array_;
+    std::shared_ptr<MessageT> msg_ptr_;
+    bool used;
   };
 
-  // It's very important that these are shared_ptrs, since users of this class might hold a
-  // reference to a pool item longer than the lifetime of the class.  In that scenario, the
-  // shared_ptr ensures that the lifetime of these variables outlives this class, and hence ensures
-  // the custom destructor for each pool item can successfully run.
-  std::shared_ptr<std::mutex> pool_mutex_;
-  std::shared_ptr<std::array<MessageT *, Size>> pool_;
-  std::shared_ptr<CircularArray<Size>> free_list_;
+  std::array<PoolMember, Size> pool_;
+  size_t next_array_index_;
 };
 
 }  // namespace message_pool_memory_strategy

rclcpp/include/rclcpp/subscription.hpp

@@ -90,9 +90,21 @@ 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>;
+    std::shared_ptr<rclcpp::topic_statistics::SubscriptionTopicStatistics<ROSMessageType>>;
 
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(Subscription)
@@ -115,7 +127,6 @@ public:
    *   of the following conditions are true: qos_profile.history == RMW_QOS_POLICY_HISTORY_KEEP_ALL,
    *   qos_profile.depth == 0 or qos_profile.durability != RMW_QOS_POLICY_DURABILITY_VOLATILE).
    */
-  // *INDENT-OFF*
   Subscription(
     rclcpp::node_interfaces::NodeBaseInterface * node_base,
     const rosidl_message_type_support_t & type_support_handle,
@@ -137,7 +148,6 @@ public:
     any_callback_(callback),
     options_(options),
     message_memory_strategy_(message_memory_strategy)
-  // *INDENT-ON*
   {
     // Setup intra process publishing if requested.
     if (rclcpp::detail::resolve_use_intra_process(options_, *node_base)) {
@@ -147,13 +157,15 @@ 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");
+      }
+      if (qos_profile.durability() != rclcpp::DurabilityPolicy::Volatile) {
+        throw std::invalid_argument(
+                "intraprocess communication allowed only with volatile durability");
       }
 
       using SubscriptionIntraProcessT = rclcpp::experimental::SubscriptionIntraProcess<
@@ -173,7 +185,7 @@ public:
         this->get_topic_name(),  // important to get like this, as it has the fully-qualified name
         qos_profile,
         resolve_intra_process_buffer_type(options_.intra_process_buffer_type, callback));
-      TRACETOOLS_TRACEPOINT(
+      TRACEPOINT(
         rclcpp_subscription_init,
         static_cast<const void *>(get_subscription_handle().get()),
         static_cast<const void *>(subscription_intra_process_.get()));
@@ -181,8 +193,7 @@ public:
       // Add it to the intra process manager.
       using rclcpp::experimental::IntraProcessManager;
       auto ipm = context->get_sub_context<IntraProcessManager>();
-      uint64_t intra_process_subscription_id = ipm->template add_subscription<
-        ROSMessageType, ROSMessageTypeAllocator>(subscription_intra_process_);
+      uint64_t intra_process_subscription_id = ipm->add_subscription(subscription_intra_process_);
       this->setup_intra_process(intra_process_subscription_id, ipm);
     }
 
@@ -190,11 +201,11 @@ public:
       this->subscription_topic_statistics_ = std::move(subscription_topic_statistics);
     }
 
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_subscription_init,
       static_cast<const void *>(get_subscription_handle().get()),
       static_cast<const void *>(this));
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_subscription_callback_added,
       static_cast<const void *>(this),
       static_cast<const void *>(&any_callback_));
@@ -209,11 +220,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.
@@ -303,7 +316,7 @@ public:
     if (subscription_topic_statistics_) {
       const auto nanos = std::chrono::time_point_cast<std::chrono::nanoseconds>(now);
       const auto time = rclcpp::Time(nanos.time_since_epoch().count());
-      subscription_topic_statistics_->handle_message(message_info.get_rmw_message_info(), time);
+      subscription_topic_statistics_->handle_message(*typed_message, time);
     }
   }
 
@@ -312,20 +325,8 @@ public:
     const std::shared_ptr<rclcpp::SerializedMessage> & serialized_message,
     const rclcpp::MessageInfo & message_info) override
   {
-    std::chrono::time_point<std::chrono::system_clock> now;
-    if (subscription_topic_statistics_) {
-      // get current time before executing callback to
-      // exclude callback duration from topic statistics result.
-      now = std::chrono::system_clock::now();
-    }
-
+    // TODO(wjwwood): enable topic statistics for serialized messages
     any_callback_.dispatch(serialized_message, message_info);
-
-    if (subscription_topic_statistics_) {
-      const auto nanos = std::chrono::time_point_cast<std::chrono::nanoseconds>(now);
-      const auto time = rclcpp::Time(nanos.time_since_epoch().count());
-      subscription_topic_statistics_->handle_message(message_info.get_rmw_message_info(), time);
-    }
   }
 
   void
@@ -356,7 +357,7 @@ public:
     if (subscription_topic_statistics_) {
       const auto nanos = std::chrono::time_point_cast<std::chrono::nanoseconds>(now);
       const auto time = rclcpp::Time(nanos.time_since_epoch().count());
-      subscription_topic_statistics_->handle_message(message_info.get_rmw_message_info(), time);
+      subscription_topic_statistics_->handle_message(*typed_message, time);
     }
   }
 
@@ -420,17 +421,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"
@@ -260,13 +260,13 @@ public:
   bool
   is_serialized() const;
 
-  /// Return the delivered message kind.
+  /// Return the type of the subscription.
   /**
    * \return `DeliveredMessageKind`, which adjusts how messages are received and delivered.
    */
   RCLCPP_PUBLIC
   DeliveredMessageKind
-  get_delivered_message_kind() const;
+  get_subscription_type() const;
 
   /// Get matching publisher count.
   /** \return The number of publishers on this topic. */
@@ -645,14 +645,6 @@ protected:
   rclcpp::node_interfaces::NodeBaseInterface * const node_base_;
 
   std::shared_ptr<rcl_node_t> node_handle_;
-
-  std::recursive_mutex callback_mutex_;
-  // It is important to declare on_new_message_callback_ before
-  // subscription_handle_, so on destruction the subscription is
-  // destroyed first. Otherwise, the rmw subscription callback
-  // would point briefly to a destroyed function.
-  std::function<void(size_t)> on_new_message_callback_{nullptr};
-  // Declare subscription_handle_ after callback
   std::shared_ptr<rcl_subscription_t> subscription_handle_;
   std::shared_ptr<rcl_subscription_t> intra_process_subscription_handle_;
   rclcpp::Logger node_logger_;
@@ -671,12 +663,15 @@ private:
   RCLCPP_DISABLE_COPY(SubscriptionBase)
 
   rosidl_message_type_support_t type_support_;
-  DeliveredMessageKind delivered_message_kind_;
+  DeliveredMessageKind delivered_message_type_;
 
   std::atomic<bool> subscription_in_use_by_wait_set_{false};
   std::atomic<bool> intra_process_subscription_waitable_in_use_by_wait_set_{false};
   std::unordered_map<rclcpp::EventHandlerBase *,
     std::atomic<bool>> qos_events_in_use_by_wait_set_;
+
+  std::recursive_mutex callback_mutex_;
+  std::function<void(size_t)> on_new_message_callback_{nullptr};
 };
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/subscription_factory.hpp

@@ -75,14 +75,15 @@ template<
   typename CallbackT,
   typename AllocatorT,
   typename SubscriptionT = rclcpp::Subscription<MessageT, AllocatorT>,
-  typename MessageMemoryStrategyT = typename SubscriptionT::MessageMemoryStrategyType
+  typename MessageMemoryStrategyT = typename SubscriptionT::MessageMemoryStrategyType,
+  typename ROSMessageType = typename SubscriptionT::ROSMessageType
 >
 SubscriptionFactory
 create_subscription_factory(
   CallbackT && callback,
   const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options,
   typename MessageMemoryStrategyT::SharedPtr msg_mem_strat,
-  std::shared_ptr<rclcpp::topic_statistics::SubscriptionTopicStatistics>
+  std::shared_ptr<rclcpp::topic_statistics::SubscriptionTopicStatistics<ROSMessageType>>
   subscription_topic_stats = nullptr
 )
 {

rclcpp/include/rclcpp/subscription_options.hpp

@@ -77,11 +77,6 @@ struct SubscriptionOptionsBase
     // Topic statistics publication period in ms. Defaults to one second.
     // Only values greater than zero are allowed.
     std::chrono::milliseconds publish_period{std::chrono::seconds(1)};
-
-    // 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);
   };
 
   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);
@@ -58,10 +57,6 @@ public:
   RCLCPP_PUBLIC
   Time(const Time & rhs);
 
-  /// Move constructor
-  RCLCPP_PUBLIC
-  Time(Time && rhs) noexcept;
-
   /// Time constructor
   /**
    * \param time_msg builtin_interfaces time message to copy
@@ -89,7 +84,6 @@ public:
   operator builtin_interfaces::msg::Time() const;
 
   /**
-   * Copy assignment operator
    * \throws std::runtime_error if seconds are negative
    */
   RCLCPP_PUBLIC
@@ -106,13 +100,6 @@ public:
   Time &
   operator=(const builtin_interfaces::msg::Time & time_msg);
 
-  /**
-   * Move assignment operator
-   */
-  RCLCPP_PUBLIC
-  Time &
-  operator=(Time && rhs) noexcept;
-
   /**
    * \throws std::runtime_error if the time sources are different
    */
@@ -202,7 +189,7 @@ public:
    */
   RCLCPP_PUBLIC
   static Time
-  max(rcl_clock_type_t clock_type = RCL_SYSTEM_TIME);  // NOLINT
+  max();
 
   /// Get the seconds since epoch
   /**
@@ -235,15 +222,6 @@ RCLCPP_PUBLIC
 Time
 operator+(const rclcpp::Duration & lhs, const rclcpp::Time & rhs);
 
-/// Convert rcl_time_point_value_t to builtin_interfaces::msg::Time
-/**
- * \param[in] time_point is a rcl_time_point_value_t
- * \return the builtin_interfaces::msg::Time from the time_point
- */
-RCLCPP_PUBLIC
-builtin_interfaces::msg::Time
-convert_rcl_time_to_sec_nanos(const rcl_time_point_value_t & time_point);
-
 }  // namespace rclcpp
 
 #endif  // RCLCPP__TIME_HPP_

rclcpp/include/rclcpp/timer.hpp

@@ -18,7 +18,6 @@
 #include <atomic>
 #include <chrono>
 #include <functional>
-#include <optional>
 #include <memory>
 #include <sstream>
 #include <thread>
@@ -44,12 +43,6 @@
 namespace rclcpp
 {
 
-struct TimerInfo
-{
-  Time expected_call_time;
-  Time actual_call_time;
-};
-
 class TimerBase
 {
 public:
@@ -60,17 +53,12 @@ public:
    * \param clock A clock to use for time and sleeping
    * \param period The interval at which the timer fires
    * \param context node context
-   * \param autostart timer state on initialization
-   *
-   * In order to activate a timer that is not started on initialization,
-   * user should call the reset() method.
    */
   RCLCPP_PUBLIC
   explicit TimerBase(
     Clock::SharedPtr clock,
     std::chrono::nanoseconds period,
-    rclcpp::Context::SharedPtr context,
-    bool autostart = true);
+    rclcpp::Context::SharedPtr context);
 
   /// TimerBase destructor
   RCLCPP_PUBLIC
@@ -108,20 +96,16 @@ public:
    * The multithreaded executor takes advantage of this to avoid scheduling
    * the callback multiple times.
    *
-   * \return a valid shared_ptr if the callback should be executed,
-   *         an invalid shared_ptr (nullptr) if the timer was canceled.
+   * \return `true` if the callback should be executed, `false` if the timer was canceled.
    */
   RCLCPP_PUBLIC
-  virtual std::shared_ptr<void>
+  virtual bool
   call() = 0;
 
   /// Call the callback function when the timer signal is emitted.
-  /**
-   * \param[in] data the pointer returned by the call function
-   */
   RCLCPP_PUBLIC
   virtual void
-  execute_callback(const std::shared_ptr<void> & data) = 0;
+  execute_callback() = 0;
 
   RCLCPP_PUBLIC
   std::shared_ptr<const rcl_timer_t>
@@ -209,17 +193,16 @@ protected:
   set_on_reset_callback(rcl_event_callback_t callback, const void * user_data);
 };
 
+
 using VoidCallbackType = std::function<void ()>;
 using TimerCallbackType = std::function<void (TimerBase &)>;
-using TimerInfoCallbackType = std::function<void (const TimerInfo &)>;
 
 /// Generic timer. Periodically executes a user-specified callback.
 template<
   typename FunctorT,
   typename std::enable_if<
     rclcpp::function_traits::same_arguments<FunctorT, VoidCallbackType>::value ||
-    rclcpp::function_traits::same_arguments<FunctorT, TimerCallbackType>::value ||
-    rclcpp::function_traits::same_arguments<FunctorT, TimerInfoCallbackType>::value
+    rclcpp::function_traits::same_arguments<FunctorT, TimerCallbackType>::value
   >::type * = nullptr
 >
 class GenericTimer : public TimerBase
@@ -233,22 +216,21 @@ public:
    * \param[in] period The interval at which the timer fires.
    * \param[in] callback User-specified callback function.
    * \param[in] context custom context to be used.
-   * \param autostart timer state on initialization
    */
   explicit GenericTimer(
     Clock::SharedPtr clock, std::chrono::nanoseconds period, FunctorT && callback,
-    rclcpp::Context::SharedPtr context, bool autostart = true
+    rclcpp::Context::SharedPtr context
   )
-  : TimerBase(clock, period, context, autostart), callback_(std::forward<FunctorT>(callback))
+  : TimerBase(clock, period, context), callback_(std::forward<FunctorT>(callback))
   {
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_timer_callback_added,
       static_cast<const void *>(get_timer_handle().get()),
       reinterpret_cast<const void *>(&callback_));
 #ifndef TRACETOOLS_DISABLED
-    if (TRACETOOLS_TRACEPOINT_ENABLED(rclcpp_callback_register)) {
+    if (TRACEPOINT_ENABLED(rclcpp_callback_register)) {
       char * symbol = tracetools::get_symbol(callback_);
-      TRACETOOLS_DO_TRACEPOINT(
+      DO_TRACEPOINT(
         rclcpp_callback_register,
         reinterpret_cast<const void *>(&callback_),
         symbol);
@@ -268,29 +250,28 @@ public:
    * \sa rclcpp::TimerBase::call
    * \throws std::runtime_error if it failed to notify timer that callback will occurr
    */
-  std::shared_ptr<void>
+  bool
   call() override
   {
-    auto timer_call_info_ = std::make_shared<rcl_timer_call_info_t>();
-    rcl_ret_t ret = rcl_timer_call_with_info(timer_handle_.get(), timer_call_info_.get());
+    rcl_ret_t ret = rcl_timer_call(timer_handle_.get());
     if (ret == RCL_RET_TIMER_CANCELED) {
-      return nullptr;
+      return false;
     }
     if (ret != RCL_RET_OK) {
       throw std::runtime_error("Failed to notify timer that callback occurred");
     }
-    return timer_call_info_;
+    return true;
   }
 
   /**
    * \sa rclcpp::TimerBase::execute_callback
    */
   void
-  execute_callback(const std::shared_ptr<void> & data) override
+  execute_callback() override
   {
-    TRACETOOLS_TRACEPOINT(callback_start, reinterpret_cast<const void *>(&callback_), false);
-    execute_callback_delegate<>(*static_cast<rcl_timer_call_info_t *>(data.get()));
-    TRACETOOLS_TRACEPOINT(callback_end, reinterpret_cast<const void *>(&callback_));
+    TRACEPOINT(callback_start, reinterpret_cast<const void *>(&callback_), false);
+    execute_callback_delegate<>();
+    TRACEPOINT(callback_end, reinterpret_cast<const void *>(&callback_));
   }
 
   // void specialization
@@ -301,7 +282,7 @@ public:
     >::type * = nullptr
   >
   void
-  execute_callback_delegate(const rcl_timer_call_info_t &)
+  execute_callback_delegate()
   {
     callback_();
   }
@@ -313,26 +294,11 @@ public:
     >::type * = nullptr
   >
   void
-  execute_callback_delegate(const rcl_timer_call_info_t &)
+  execute_callback_delegate()
   {
     callback_(*this);
   }
 
-
-  template<
-    typename CallbackT = FunctorT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<CallbackT, TimerInfoCallbackType>::value
-    >::type * = nullptr
-  >
-  void
-  execute_callback_delegate(const rcl_timer_call_info_t & timer_call_info)
-  {
-    const TimerInfo info{Time{timer_call_info.expected_call_time, clock_->get_clock_type()},
-      Time{timer_call_info.actual_call_time, clock_->get_clock_type()}};
-    callback_(info);
-  }
-
   /// Is the clock steady (i.e. is the time between ticks constant?)
   /** \return True if the clock used by this timer is steady. */
   bool
@@ -351,8 +317,7 @@ template<
   typename FunctorT,
   typename std::enable_if<
     rclcpp::function_traits::same_arguments<FunctorT, VoidCallbackType>::value ||
-    rclcpp::function_traits::same_arguments<FunctorT, TimerCallbackType>::value ||
-    rclcpp::function_traits::same_arguments<FunctorT, TimerInfoCallbackType>::value
+    rclcpp::function_traits::same_arguments<FunctorT, TimerCallbackType>::value
   >::type * = nullptr
 >
 class WallTimer : public GenericTimer<FunctorT>
@@ -365,15 +330,13 @@ public:
    * \param period The interval at which the timer fires
    * \param callback The callback function to execute every interval
    * \param context node context
-   * \param autostart timer state on initialization
    */
   WallTimer(
     std::chrono::nanoseconds period,
     FunctorT && callback,
-    rclcpp::Context::SharedPtr context,
-    bool autostart = true)
+    rclcpp::Context::SharedPtr context)
   : GenericTimer<FunctorT>(
-      std::make_shared<Clock>(RCL_STEADY_TIME), period, std::move(callback), context, autostart)
+      std::make_shared<Clock>(RCL_STEADY_TIME), period, std::move(callback), context)
   {}
 
 protected:

rclcpp/include/rclcpp/topic_statistics/subscription_topic_statistics.hpp

@@ -48,12 +48,21 @@ using libstatistics_collector::moving_average_statistics::StatisticData;
 /**
  * Class used to collect, measure, and publish topic statistics data. Current statistics
  * supported for subscribers are received message age and received message period.
-  */
+ *
+ * \tparam CallbackMessageT the subscribed message type
+ */
+template<typename CallbackMessageT>
 class SubscriptionTopicStatistics
 {
-  using TopicStatsCollector = libstatistics_collector::TopicStatisticsCollector;
-  using ReceivedMessageAge = libstatistics_collector::ReceivedMessageAgeCollector;
-  using ReceivedMessagePeriod = libstatistics_collector::ReceivedMessagePeriodCollector;
+  using TopicStatsCollector =
+    libstatistics_collector::topic_statistics_collector::TopicStatisticsCollector<
+    CallbackMessageT>;
+  using ReceivedMessageAge =
+    libstatistics_collector::topic_statistics_collector::ReceivedMessageAgeCollector<
+    CallbackMessageT>;
+  using ReceivedMessagePeriod =
+    libstatistics_collector::topic_statistics_collector::ReceivedMessagePeriodCollector<
+    CallbackMessageT>;
 
 public:
   /// Construct a SubscriptionTopicStatistics object.
@@ -92,16 +101,16 @@ public:
   /**
    * This method acquires a lock to prevent race conditions to collectors list.
    *
-   * \param message_info the message info corresponding to the received message
+   * \param received_message the message received by the subscription
    * \param now_nanoseconds current time in nanoseconds
    */
   virtual void handle_message(
-    const rmw_message_info_t & message_info,
+    const CallbackMessageT & received_message,
     const rclcpp::Time now_nanoseconds) const
   {
     std::lock_guard<std::mutex> lock(mutex_);
     for (const auto & collector : subscriber_statistics_collectors_) {
-      collector->OnMessageReceived(message_info, now_nanoseconds.nanoseconds());
+      collector->OnMessageReceived(received_message, now_nanoseconds.nanoseconds());
     }
   }
 
@@ -172,11 +181,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,9 +21,7 @@
 #include <tuple>
 
 #include "rcpputils/shared_library.hpp"
-#include "rosidl_runtime_cpp/action_type_support_decl.hpp"
 #include "rosidl_runtime_cpp/message_type_support_decl.hpp"
-#include "rosidl_runtime_cpp/service_type_support_decl.hpp"
 
 #include "rclcpp/visibility_control.hpp"
 
@@ -39,54 +37,17 @@ RCLCPP_PUBLIC
 std::shared_ptr<rcpputils::SharedLibrary>
 get_typesupport_library(const std::string & type, const std::string & typesupport_identifier);
 
-/// Extract the message type support handle from the library.
+/// 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.
- *
  * \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
+ * \return A type support handle
  */
 RCLCPP_PUBLIC
 const rosidl_message_type_support_t *
-get_message_typesupport_handle(
-  const std::string & type,
-  const std::string & typesupport_identifier,
-  rcpputils::SharedLibrary & library);
-
-/// Extract the service type support handle from the library.
-/**
- * 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
- */
-RCLCPP_PUBLIC
-const rosidl_service_type_support_t *
-get_service_typesupport_handle(
-  const std::string & type,
-  const std::string & typesupport_identifier,
-  rcpputils::SharedLibrary & library);
-
-/// Extract the action type support handle from the library.
-/**
- * The library needs to match the action type. The shared library must stay loaded for the lifetime
- * of the result.
- *
- * \param[in] type The action type, e.g. "example_interfaces/action/Fibonacci"
- * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
- * \param[in] library The shared type support library
- * \throws std::runtime_error if the symbol of type not found in the library.
- * \return A action type support handle
- */
-RCLCPP_PUBLIC
-const rosidl_action_type_support_t *
-get_action_typesupport_handle(
+get_typesupport_handle(
   const std::string & type,
   const std::string & typesupport_identifier,
   rcpputils::SharedLibrary & library);

rclcpp/include/rclcpp/wait_result.hpp

@@ -17,21 +17,13 @@
 
 #include <cassert>
 #include <functional>
-#include <iostream>
-#include <memory>
 #include <stdexcept>
-#include <utility>
 
 #include "rcl/wait.h"
 
 #include "rclcpp/macros.hpp"
 #include "rclcpp/wait_result_kind.hpp"
 
-#include "rclcpp/client.hpp"
-#include "rclcpp/service.hpp"
-#include "rclcpp/subscription_base.hpp"
-#include "rclcpp/timer.hpp"
-
 namespace rclcpp
 {
 
@@ -142,159 +134,6 @@ public:
     }
   }
 
-  /// Get the next ready timer and its index in the wait result, but do not clear it.
-  /**
-   * The returned timer is not cleared automatically, as it the case with the
-   * other next_ready_*()-like functions.
-   * Instead, this function returns the timer and the index that identifies it
-   * in the wait result, so that it can be cleared (marked as taken or used)
-   * in a separate step with clear_timer_with_index().
-   * This is necessary in some multi-threaded executor implementations.
-   *
-   * If the timer is not cleared using the index, subsequent calls to this
-   * function will return the same timer.
-   *
-   * If there is no ready timer, then nullptr will be returned and the index
-   * will be invalid and should not be used.
-   *
-   * \param[in] start_index index at which to start searching for the next ready
-   *   timer in the wait result. If the start_index is out of bounds for the
-   *   list of timers in the wait result, then {nullptr, start_index} will be
-   *   returned. Defaults to 0.
-   * \return next ready timer pointer and its index in the wait result, or
-   *   {nullptr, start_index} if none was found.
-   */
-  std::pair<std::shared_ptr<rclcpp::TimerBase>, size_t>
-  peek_next_ready_timer(size_t start_index = 0)
-  {
-    check_wait_result_dirty();
-    auto ret = std::shared_ptr<rclcpp::TimerBase>{nullptr};
-    size_t ii = start_index;
-    if (this->kind() == WaitResultKind::Ready) {
-      auto & wait_set = this->get_wait_set();
-      auto & rcl_wait_set = wait_set.storage_get_rcl_wait_set();
-      for (; ii < wait_set.size_of_timers(); ++ii) {
-        if (rcl_wait_set.timers[ii] != nullptr) {
-          ret = wait_set.timers(ii);
-          if (ret) {
-            break;
-          }
-        }
-      }
-    }
-    return {ret, ii};
-  }
-
-  /// Clear the timer at the given index.
-  /**
-   * Clearing a timer from the wait result prevents it from being returned by
-   * the peek_next_ready_timer() on subsequent calls.
-   *
-   * The index should come from the peek_next_ready_timer() function, and
-   * should only be used with this function if the timer pointer was valid.
-   *
-   * \throws std::out_of_range if the given index is out of range
-   */
-  void
-  clear_timer_with_index(size_t index)
-  {
-    auto & wait_set = this->get_wait_set();
-    auto & rcl_wait_set = wait_set.storage_get_rcl_wait_set();
-    if (index >= wait_set.size_of_timers()) {
-      throw std::out_of_range("given timer index is out of range");
-    }
-    rcl_wait_set.timers[index] = nullptr;
-  }
-
-  /// Get the next ready subscription, clearing it from the wait result.
-  std::shared_ptr<rclcpp::SubscriptionBase>
-  next_ready_subscription()
-  {
-    check_wait_result_dirty();
-    auto ret = std::shared_ptr<rclcpp::SubscriptionBase>{nullptr};
-    if (this->kind() == WaitResultKind::Ready) {
-      auto & wait_set = this->get_wait_set();
-      auto & rcl_wait_set = wait_set.storage_get_rcl_wait_set();
-      for (size_t ii = 0; ii < wait_set.size_of_subscriptions(); ++ii) {
-        if (rcl_wait_set.subscriptions[ii] != nullptr) {
-          ret = wait_set.subscriptions(ii);
-          rcl_wait_set.subscriptions[ii] = nullptr;
-          if (ret) {
-            break;
-          }
-        }
-      }
-    }
-    return ret;
-  }
-
-  /// Get the next ready service, clearing it from the wait result.
-  std::shared_ptr<rclcpp::ServiceBase>
-  next_ready_service()
-  {
-    check_wait_result_dirty();
-    auto ret = std::shared_ptr<rclcpp::ServiceBase>{nullptr};
-    if (this->kind() == WaitResultKind::Ready) {
-      auto & wait_set = this->get_wait_set();
-      auto & rcl_wait_set = wait_set.storage_get_rcl_wait_set();
-      for (size_t ii = 0; ii < wait_set.size_of_services(); ++ii) {
-        if (rcl_wait_set.services[ii] != nullptr) {
-          ret = wait_set.services(ii);
-          rcl_wait_set.services[ii] = nullptr;
-          if (ret) {
-            break;
-          }
-        }
-      }
-    }
-    return ret;
-  }
-
-  /// Get the next ready client, clearing it from the wait result.
-  std::shared_ptr<rclcpp::ClientBase>
-  next_ready_client()
-  {
-    check_wait_result_dirty();
-    auto ret = std::shared_ptr<rclcpp::ClientBase>{nullptr};
-    if (this->kind() == WaitResultKind::Ready) {
-      auto & wait_set = this->get_wait_set();
-      auto & rcl_wait_set = wait_set.storage_get_rcl_wait_set();
-      for (size_t ii = 0; ii < wait_set.size_of_clients(); ++ii) {
-        if (rcl_wait_set.clients[ii] != nullptr) {
-          ret = wait_set.clients(ii);
-          rcl_wait_set.clients[ii] = nullptr;
-          if (ret) {
-            break;
-          }
-        }
-      }
-    }
-    return ret;
-  }
-
-  /// Get the next ready waitable, clearing it from the wait result.
-  std::shared_ptr<rclcpp::Waitable>
-  next_ready_waitable()
-  {
-    check_wait_result_dirty();
-    auto waitable = std::shared_ptr<rclcpp::Waitable>{nullptr};
-    auto data = std::shared_ptr<void>{nullptr};
-
-    if (this->kind() == WaitResultKind::Ready) {
-      auto & wait_set = this->get_wait_set();
-      auto & rcl_wait_set = wait_set.get_rcl_wait_set();
-      while (next_waitable_index_ < wait_set.size_of_waitables()) {
-        auto cur_waitable = wait_set.waitables(next_waitable_index_++);
-        if (cur_waitable != nullptr && cur_waitable->is_ready(rcl_wait_set)) {
-          waitable = cur_waitable;
-          break;
-        }
-      }
-    }
-
-    return waitable;
-  }
-
 private:
   RCLCPP_DISABLE_COPY(WaitResult)
 
@@ -312,25 +151,12 @@ private:
     // Should be enforced by the static factory methods on this class.
     assert(WaitResultKind::Ready == wait_result_kind);
     // Secure thread-safety (if provided) and shared ownership (if needed).
-    this->get_wait_set().wait_result_acquire();
+    wait_set_pointer_->wait_result_acquire();
   }
 
-  /// Check if the wait result is invalid because the wait set was modified.
-  void
-  check_wait_result_dirty()
-  {
-    // In the case that the wait set was modified while the result was out,
-    // we must mark the wait result as no longer valid
-    if (wait_set_pointer_ && this->get_wait_set().wait_result_dirty_) {
-      this->wait_result_kind_ = WaitResultKind::Invalid;
-    }
-  }
-
-  WaitResultKind wait_result_kind_;
+  const WaitResultKind wait_result_kind_;
 
   WaitSetT * wait_set_pointer_ = nullptr;
-
-  size_t next_waitable_index_ = 0;
 };
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/wait_result_kind.hpp

@@ -26,7 +26,6 @@ enum RCLCPP_PUBLIC WaitResultKind
   Ready,  //<! Kind used when something in the wait set was ready.
   Timeout,  //<! Kind used when the wait resulted in a timeout.
   Empty,  //<! Kind used when trying to wait on an empty wait set.
-  Invalid,  //<! Kind used when wait result has been invalidated.
 };
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/wait_set_policies/detail/storage_policy_common.hpp

@@ -203,13 +203,13 @@ protected:
           needs_pruning_ = true;
           continue;
         }
-        auto & waitable = *waitable_entry.waitable;
-        subscriptions_from_waitables += waitable.get_number_of_ready_subscriptions();
-        guard_conditions_from_waitables += waitable.get_number_of_ready_guard_conditions();
-        timers_from_waitables += waitable.get_number_of_ready_timers();
-        clients_from_waitables += waitable.get_number_of_ready_clients();
-        services_from_waitables += waitable.get_number_of_ready_services();
-        events_from_waitables += waitable.get_number_of_ready_events();
+        const auto & waitable = waitable_entry.waitable;
+        subscriptions_from_waitables += waitable->get_number_of_ready_subscriptions();
+        guard_conditions_from_waitables += waitable->get_number_of_ready_guard_conditions();
+        timers_from_waitables += waitable->get_number_of_ready_timers();
+        clients_from_waitables += waitable->get_number_of_ready_clients();
+        services_from_waitables += waitable->get_number_of_ready_services();
+        events_from_waitables += waitable->get_number_of_ready_events();
       }
       rcl_ret_t ret = rcl_wait_set_resize(
         &rcl_wait_set_,
@@ -340,6 +340,7 @@ protected:
       }
     }
 
+
     // Add services.
     for (const auto & service : services) {
       if (!service) {
@@ -375,7 +376,7 @@ protected:
         needs_pruning_ = true;
         continue;
       }
-      waitable_entry.waitable->add_to_wait_set(rcl_wait_set_);
+      waitable_entry.waitable->add_to_wait_set(&rcl_wait_set_);
     }
   }
 
@@ -397,32 +398,6 @@ protected:
     needs_resize_ = true;
   }
 
-  size_t size_of_subscriptions() const {return 0;}
-  size_t size_of_timers() const {return 0;}
-  size_t size_of_clients() const {return 0;}
-  size_t size_of_services() const {return 0;}
-  size_t size_of_waitables() const {return 0;}
-
-  template<class SubscriptionsIterable>
-  typename SubscriptionsIterable::value_type
-  subscriptions(size_t) const {return nullptr;}
-
-  template<class TimersIterable>
-  typename TimersIterable::value_type
-  timers(size_t) const {return nullptr;}
-
-  template<class ClientsIterable>
-  typename ClientsIterable::value_type
-  clients(size_t) const {return nullptr;}
-
-  template<class ServicesIterable>
-  typename ServicesIterable::value_type
-  services(size_t) const {return nullptr;}
-
-  template<class WaitablesIterable>
-  typename WaitablesIterable::value_type
-  waitables(size_t) const {return nullptr;}
-
   rcl_wait_set_t rcl_wait_set_;
   rclcpp::Context::SharedPtr context_;
 

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();
   }
 
@@ -391,8 +386,6 @@ public:
         return weak_ptr.expired();
       };
     // remove guard conditions which have been deleted
-    subscriptions_.erase(
-      std::remove_if(subscriptions_.begin(), subscriptions_.end(), p), subscriptions_.end());
     guard_conditions_.erase(
       std::remove_if(guard_conditions_.begin(), guard_conditions_.end(), p),
       guard_conditions_.end());
@@ -458,62 +451,6 @@ public:
     reset_all(shared_waitables_);
   }
 
-  size_t size_of_subscriptions() const
-  {
-    return subscriptions_.size();
-  }
-
-  size_t size_of_timers() const
-  {
-    return timers_.size();
-  }
-
-  size_t size_of_clients() const
-  {
-    return clients_.size();
-  }
-
-  size_t size_of_services() const
-  {
-    return services_.size();
-  }
-
-  size_t size_of_waitables() const
-  {
-    return waitables_.size();
-  }
-
-  std::shared_ptr<rclcpp::SubscriptionBase>
-  subscriptions(size_t ii) const
-  {
-    return subscriptions_[ii].lock();
-  }
-
-  std::shared_ptr<rclcpp::TimerBase>
-  timers(size_t ii) const
-  {
-    return timers_[ii].lock();
-  }
-
-  std::shared_ptr<rclcpp::ClientBase>
-  clients(size_t ii) const
-  {
-    return clients_[ii].lock();
-  }
-
-  std::shared_ptr<rclcpp::ServiceBase>
-  services(size_t ii) const
-  {
-    return services_[ii].lock();
-  }
-
-  std::shared_ptr<rclcpp::Waitable>
-  waitables(size_t ii) const
-  {
-    return waitables_[ii].lock();
-  }
-
-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
@@ -197,61 +188,6 @@ public:
     // Explicitly do nothing.
   }
 
-  size_t size_of_subscriptions() const
-  {
-    return subscriptions_.size();
-  }
-
-  size_t size_of_timers() const
-  {
-    return timers_.size();
-  }
-
-  size_t size_of_clients() const
-  {
-    return clients_.size();
-  }
-
-  size_t size_of_services() const
-  {
-    return services_.size();
-  }
-
-  size_t size_of_waitables() const
-  {
-    return waitables_.size();
-  }
-
-  typename ArrayOfSubscriptions::value_type
-  subscriptions(size_t ii) const
-  {
-    return subscriptions_[ii];
-  }
-
-  typename ArrayOfTimers::value_type
-  timers(size_t ii) const
-  {
-    return timers_[ii];
-  }
-
-  typename ArrayOfClients::value_type
-  clients(size_t ii) const
-  {
-    return clients_[ii];
-  }
-
-  typename ArrayOfServices::value_type
-  services(size_t ii) const
-  {
-    return services_[ii];
-  }
-
-  typename ArrayOfWaitables::value_type
-  waitables(size_t ii) const
-  {
-    return waitables_[ii];
-  }
-
   const ArrayOfSubscriptions subscriptions_;
   const ArrayOfGuardConditions guard_conditions_;
   const ArrayOfTimers timers_;

rclcpp/include/rclcpp/wait_set_template.hpp

@@ -153,7 +153,6 @@ public:
             throw std::runtime_error("subscription already associated with a wait set");
           }
           this->storage_add_subscription(std::move(local_subscription));
-          if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
         }
         if (mask.include_events) {
           for (auto key_event_pair : inner_subscription->get_event_handlers()) {
@@ -165,7 +164,6 @@ public:
               throw std::runtime_error("subscription event already associated with a wait set");
             }
             this->storage_add_waitable(std::move(event), std::move(local_subscription));
-            if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
           }
         }
         if (mask.include_intra_process_waitable) {
@@ -182,7 +180,6 @@ public:
             this->storage_add_waitable(
               std::move(inner_subscription->get_intra_process_waitable()),
               std::move(local_subscription));
-            if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
           }
         }
       });
@@ -227,7 +224,6 @@ public:
           auto local_subscription = inner_subscription;
           local_subscription->exchange_in_use_by_wait_set_state(local_subscription.get(), false);
           this->storage_remove_subscription(std::move(local_subscription));
-          if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
         }
         if (mask.include_events) {
           for (auto key_event_pair : inner_subscription->get_event_handlers()) {
@@ -235,7 +231,6 @@ public:
             auto local_subscription = inner_subscription;
             local_subscription->exchange_in_use_by_wait_set_state(event.get(), false);
             this->storage_remove_waitable(std::move(event));
-            if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
           }
         }
         if (mask.include_intra_process_waitable) {
@@ -244,7 +239,6 @@ public:
             // This is the case when intra process is enabled for the subscription.
             inner_subscription->exchange_in_use_by_wait_set_state(local_waitable.get(), false);
             this->storage_remove_waitable(std::move(local_waitable));
-            if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
           }
         }
       });
@@ -295,7 +289,6 @@ public:
         // fixed sized storage policies.
         // It will throw if the guard condition has already been added.
         this->storage_add_guard_condition(std::move(inner_guard_condition));
-        if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
       });
   }
 
@@ -333,7 +326,6 @@ public:
         // fixed sized storage policies.
         // It will throw if the guard condition is not in the wait set.
         this->storage_remove_guard_condition(std::move(inner_guard_condition));
-        if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
       });
   }
 
@@ -365,7 +357,6 @@ public:
         // fixed sized storage policies.
         // It will throw if the timer has already been added.
         this->storage_add_timer(std::move(inner_timer));
-        if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
       });
   }
 
@@ -393,7 +384,6 @@ public:
         // fixed sized storage policies.
         // It will throw if the timer is not in the wait set.
         this->storage_remove_timer(std::move(inner_timer));
-        if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
       });
   }
 
@@ -425,7 +415,6 @@ public:
         // fixed sized storage policies.
         // It will throw if the client has already been added.
         this->storage_add_client(std::move(inner_client));
-        if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
       });
   }
 
@@ -453,7 +442,6 @@ public:
         // fixed sized storage policies.
         // It will throw if the client is not in the wait set.
         this->storage_remove_client(std::move(inner_client));
-        if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
       });
   }
 
@@ -485,7 +473,6 @@ public:
         // fixed sized storage policies.
         // It will throw if the service has already been added.
         this->storage_add_service(std::move(inner_service));
-        if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
       });
   }
 
@@ -513,7 +500,6 @@ public:
         // fixed sized storage policies.
         // It will throw if the service is not in the wait set.
         this->storage_remove_service(std::move(inner_service));
-        if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
       });
   }
 
@@ -565,7 +551,6 @@ public:
         // fixed sized storage policies.
         // It will throw if the waitable has already been added.
         this->storage_add_waitable(std::move(inner_waitable), std::move(associated_entity));
-        if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
       });
   }
 
@@ -593,7 +578,6 @@ public:
         // fixed sized storage policies.
         // It will throw if the waitable is not in the wait set.
         this->storage_remove_waitable(std::move(inner_waitable));
-        if (this->wait_result_holding_) {this->wait_result_dirty_ = true;}
       });
   }
 
@@ -731,9 +715,10 @@ private:
       throw std::runtime_error("wait_result_acquire() called while already holding");
     }
     wait_result_holding_ = true;
-    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.
@@ -749,13 +734,13 @@ private:
       throw std::runtime_error("wait_result_release() called while not holding");
     }
     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();
   }
 
   bool wait_result_holding_ = false;
-  bool wait_result_dirty_ = false;
 };
 
 }  // namespace rclcpp

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:
@@ -112,7 +109,7 @@ 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) = 0;
 
   /// Check if the Waitable is ready.
   /**
@@ -127,7 +124,7 @@ public:
   RCLCPP_PUBLIC
   virtual
   bool
-  is_ready(const rcl_wait_set_t & wait_set) = 0;
+  is_ready(rcl_wait_set_t * wait_set) = 0;
 
   /// Take the data so that it can be consumed with `execute`.
   /**
@@ -179,7 +176,7 @@ 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);
 
   /// Execute data that is passed in.
   /**
@@ -206,7 +203,7 @@ public:
   RCLCPP_PUBLIC
   virtual
   void
-  execute(const std::shared_ptr<void> & data) = 0;
+  execute(std::shared_ptr<void> & data) = 0;
 
   /// Exchange the "in use by wait set" state for this timer.
   /**
@@ -249,7 +246,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 +256,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.6.0</version>
+  <version>20.0.0</version>
   <description>The ROS client library in C++.</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
@@ -22,7 +22,6 @@
   <build_depend>builtin_interfaces</build_depend>
   <build_depend>rcl_interfaces</build_depend>
   <build_depend>rosgraph_msgs</build_depend>
-  <build_depend>rosidl_runtime_c</build_depend>
   <build_depend>rosidl_runtime_cpp</build_depend>
   <build_depend>rosidl_typesupport_c</build_depend>
   <build_depend>rosidl_typesupport_cpp</build_depend>
@@ -30,14 +29,12 @@
   <build_export_depend>builtin_interfaces</build_export_depend>
   <build_export_depend>rcl_interfaces</build_export_depend>
   <build_export_depend>rosgraph_msgs</build_export_depend>
-  <build_export_depend>rosidl_runtime_c</build_export_depend>
   <build_export_depend>rosidl_runtime_cpp</build_export_depend>
   <build_export_depend>rosidl_typesupport_c</build_export_depend>
   <build_export_depend>rosidl_typesupport_cpp</build_export_depend>
 
   <depend>libstatistics_collector</depend>
   <depend>rcl</depend>
-  <depend>rcl_logging_interface</depend>
   <depend>rcl_yaml_param_parser</depend>
   <depend>rcpputils</depend>
   <depend>rcutils</depend>

rclcpp/src/rclcpp/any_executable.cpp

@@ -16,6 +16,7 @@
 
 using rclcpp::AnyExecutable;
 
+RCLCPP_PUBLIC
 AnyExecutable::AnyExecutable()
 : subscription(nullptr),
   timer(nullptr),
@@ -23,7 +24,8 @@ AnyExecutable::AnyExecutable()
   client(nullptr),
   waitable(nullptr),
   callback_group(nullptr),
-  node_base(nullptr)
+  node_base(nullptr),
+  data(nullptr)
 {}
 
 AnyExecutable::~AnyExecutable()

rclcpp/src/rclcpp/callback_group.cpp

@@ -31,12 +31,12 @@ using rclcpp::CallbackGroupType;
 
 CallbackGroup::CallbackGroup(
   CallbackGroupType group_type,
-  rclcpp::Context::WeakPtr context,
+  std::function<rclcpp::Context::SharedPtr(void)> get_context,
   bool automatically_add_to_executor_with_node)
 : type_(group_type), associated_with_executor_(false),
   can_be_taken_from_(true),
   automatically_add_to_executor_with_node_(automatically_add_to_executor_with_node),
-  context_(context)
+  get_context_(get_context)
 {}
 
 CallbackGroup::~CallbackGroup()
@@ -124,12 +124,40 @@ CallbackGroup::automatically_add_to_executor_with_node() const
   return automatically_add_to_executor_with_node_;
 }
 
+// \TODO(mjcarroll) Deprecated, remove on tock
+rclcpp::GuardCondition::SharedPtr
+CallbackGroup::get_notify_guard_condition(const rclcpp::Context::SharedPtr context_ptr)
+{
+  std::lock_guard<std::recursive_mutex> lock(notify_guard_condition_mutex_);
+  if (notify_guard_condition_ && context_ptr != notify_guard_condition_->get_context()) {
+    if (associated_with_executor_) {
+      trigger_notify_guard_condition();
+    }
+    notify_guard_condition_ = nullptr;
+  }
+
+  if (!notify_guard_condition_) {
+    notify_guard_condition_ = std::make_shared<rclcpp::GuardCondition>(context_ptr);
+  }
+
+  return notify_guard_condition_;
+}
+
 rclcpp::GuardCondition::SharedPtr
 CallbackGroup::get_notify_guard_condition()
 {
   std::lock_guard<std::recursive_mutex> lock(notify_guard_condition_mutex_);
-  rclcpp::Context::SharedPtr context_ptr = context_.lock();
+  if (!this->get_context_) {
+    throw std::runtime_error("Callback group was created without context and not passed context");
+  }
+  auto context_ptr = this->get_context_();
   if (context_ptr && context_ptr->is_valid()) {
+    if (notify_guard_condition_ && context_ptr != notify_guard_condition_->get_context()) {
+      if (associated_with_executor_) {
+        trigger_notify_guard_condition();
+      }
+      notify_guard_condition_ = nullptr;
+    }
     if (!notify_guard_condition_) {
       notify_guard_condition_ = std::make_shared<rclcpp::GuardCondition>(context_ptr);
     }

rclcpp/src/rclcpp/client.cpp

@@ -125,6 +125,7 @@ bool
 ClientBase::wait_for_service_nanoseconds(std::chrono::nanoseconds timeout)
 {
   auto start = std::chrono::steady_clock::now();
+  // make an event to reuse, rather than create a new one each time
   auto node_ptr = node_graph_.lock();
   if (!node_ptr) {
     throw InvalidNodeError();
@@ -137,7 +138,6 @@ ClientBase::wait_for_service_nanoseconds(std::chrono::nanoseconds timeout)
     // check was non-blocking, return immediately
     return false;
   }
-  // make an event to reuse, rather than create a new one each time
   auto event = node_ptr->get_graph_event();
   // update the time even on the first loop to account for time spent in the first call
   // to this->server_is_ready()