21.0.8

Signed-off-by: Yadunund <yadunund@gmail.com>

rclcpp/CHANGELOG.rst

@@ -2,180 +2,56 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-28.0.0 (2024-03-28)
+21.0.8 (2024-11-08)
 -------------------
-* 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
+* associated clocks should be protected by mutex. (`#2258 <https://github.com/ros2/rclcpp/issues/2258>`_)
+* Skip client_qos test (`#2658 <https://github.com/ros2/rclcpp/issues/2658>`_)
+* Use the same context for the specified node in rclcpp::spin functions. (`#2618 <https://github.com/ros2/rclcpp/issues/2618>`_)
+* Contributors: Cristóbal Arroyo, Tomoya Fujita
 
-27.0.0 (2024-02-07)
+21.0.7 (2024-07-10)
 -------------------
-* 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
+* Add test creating two content filter topics with the same topic name (`#2550 <https://github.com/ros2/rclcpp/issues/2550>`_)
+* Revise the description of service configure_introspection() (`#2514 <https://github.com/ros2/rclcpp/issues/2514>`_)
+* Contributors: Alejandro Hernández Cordero, Barry Xu
 
-26.0.0 (2024-01-24)
+21.0.6 (2024-04-19)
 -------------------
-* 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
+* address ambiguous auto variable. (`#2486 <https://github.com/ros2/rclcpp/issues/2486>`_)
+* Contributors: Tomoya Fujita
 
-25.0.0 (2023-12-26)
+21.0.5 (2024-02-07)
 -------------------
-* 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
+* Fix data race in EventHandlerBase (`#2387 <https://github.com/ros2/rclcpp/issues/2387>`_)
+* Contributors: mauropasse
 
-24.0.0 (2023-11-06)
+21.0.4 (2023-11-17)
 -------------------
-* 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
+* Disable the loaned messages inside the executor. (`#2365 <https://github.com/ros2/rclcpp/issues/2365>`_)
+* Add missing 'enable_rosout' comments (`#2346 <https://github.com/ros2/rclcpp/issues/2346>`_)
+* Address rate related flaky tests. (`#2341 <https://github.com/ros2/rclcpp/issues/2341>`_)
+* Add missing stdexcept include (`#2333 <https://github.com/ros2/rclcpp/issues/2333>`_)
+* Update SignalHandler get_global_signal_handler to avoid complex types in static memory (`#2322 <https://github.com/ros2/rclcpp/issues/2322>`_)
+* Fix C++20 allocator construct deprecation (`#2318 <https://github.com/ros2/rclcpp/issues/2318>`_)
+* Topic correct typeadapter deduction (`#2298 <https://github.com/ros2/rclcpp/issues/2298>`_)
+* Contributors: AiVerisimilitude, Chen Lihui, Chris Lalancette, Jiaqi Li, Øystein Sture, Tomoya Fujita, William Woodall
 
-23.2.0 (2023-10-09)
+21.0.3 (2023-09-08)
 -------------------
-* 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
+* Do not crash Executor when send_response fails due to client failure. (`#2279 <https://github.com/ros2/rclcpp/issues/2279>`_)
+* Add new node interface TypeDescriptionsInterface to provide GetTypeDescription service (`#2236 <https://github.com/ros2/rclcpp/issues/2236>`_)
+* Contributors: Emerson Knapp, Tomoya Fujita, Zang MingJie
 
-23.1.0 (2023-10-04)
+21.0.2 (2023-07-14)
 -------------------
-* 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
+* Fix warnings related to comparison of integer expressions of different signedness (`#2222 <https://github.com/ros2/rclcpp/issues/2222>`_)
+* Fix race condition in events-executor (`#2191 <https://github.com/ros2/rclcpp/issues/2191>`_)
+* Contributors: Alberto Soragna, Tomoya Fujita
 
-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.1 (2023-05-11)
 -------------------
+* Fix delivered message kind (`#2175 <https://github.com/ros2/rclcpp/issues/2175>`_) (`#2178 <https://github.com/ros2/rclcpp/issues/2178>`_)
+* Contributors: mergify[bot]
 
 21.0.0 (2023-04-18)
 -------------------

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
@@ -75,7 +70,6 @@ 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_subscription.cpp
   src/rclcpp/graph_listener.cpp
@@ -112,7 +106,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
@@ -129,21 +122,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
@@ -222,28 +200,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,
@@ -265,23 +237,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)
@@ -299,7 +268,7 @@ install(
 
 if(TEST cppcheck)
   # must set the property after ament_package()
-  set_tests_properties(cppcheck PROPERTIES TIMEOUT 600)
+  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, at the [ROS Index](https://index.ros.org/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/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.
@@ -182,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;
   }
 
@@ -191,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

@@ -129,7 +129,8 @@ 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] 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.
@@ -137,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.
@@ -227,6 +228,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.
@@ -286,7 +297,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"
@@ -115,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
@@ -386,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>
@@ -794,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.
@@ -864,7 +845,7 @@ protected:
         "Received invalid sequence number. Ignoring...");
       return std::nullopt;
     }
-    auto value = std::move(it->second.second);
+    std::optional<CallbackInfoVariant> value = std::move(it->second.second);
     this->pending_requests_.erase(request_number);
     return value;
   }

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_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_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/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/exceptions/exceptions.hpp

@@ -206,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
 {
@@ -230,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

@@ -282,43 +282,21 @@ public:
   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.
-   *
-   * 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
-  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
-  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

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,7 +108,9 @@ spin_until_future_complete(
   const FutureT & future,
   std::chrono::duration<TimeRepT, TimeT> timeout = std::chrono::duration<TimeRepT, TimeT>(-1))
 {
-  rclcpp::executors::SingleThreadedExecutor executor;
+  rclcpp::ExecutorOptions options;
+  options.context = node_ptr->get_context();
+  rclcpp::executors::SingleThreadedExecutor executor(options);
   return executors::spin_node_until_future_complete<FutureT>(executor, node_ptr, future, timeout);
 }
 

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,7 +15,6 @@
 #ifndef RCLCPP__EXPERIMENTAL__BUFFERS__RING_BUFFER_IMPLEMENTATION_HPP_
 #define RCLCPP__EXPERIMENTAL__BUFFERS__RING_BUFFER_IMPLEMENTATION_HPP_
 
-#include <memory>
 #include <mutex>
 #include <stdexcept>
 #include <utility>
@@ -53,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() {}
@@ -67,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::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_,
@@ -93,7 +89,7 @@ public:
    *
    * \return the element that is being removed from the ring buffer
    */
-  BufferT dequeue() override
+  BufferT dequeue()
   {
     std::lock_guard<std::mutex> lock(mutex_);
 
@@ -102,7 +98,7 @@ public:
     }
 
     auto request = std::move(ring_buffer_[read_index_]);
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_ring_buffer_dequeue,
       static_cast<const void *>(this),
       read_index_,
@@ -114,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.
@@ -144,7 +129,7 @@ public:
    *
    * \return `true` if there is data and `false` otherwise
    */
-  inline bool has_data() const override
+  inline bool has_data() const
   {
     std::lock_guard<std::mutex> lock(mutex_);
     return has_data_();
@@ -163,21 +148,9 @@ public:
     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::lock_guard<std::mutex> lock(mutex_);
-    return available_capacity_();
-  }
-
-  void clear() override
-  {
-    TRACETOOLS_TRACEPOINT(rclcpp_ring_buffer_clear, static_cast<const void *>(this));
+    TRACEPOINT(rclcpp_ring_buffer_clear, static_cast<const void *>(this));
   }
 
 private:
@@ -216,82 +189,6 @@ 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_;
-  }
-
-  /// 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::lock_guard<std::mutex> 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::lock_guard<std::mutex> 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 {};
-  }
-
   size_t capacity_;
 
   std::vector<BufferT> ring_buffer_;

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

@@ -274,11 +274,8 @@ private:
   rclcpp::experimental::executors::EventsQueue::UniquePtr events_queue_;
 
   std::shared_ptr<rclcpp::executors::ExecutorEntitiesCollector> entities_collector_;
-  std::shared_ptr<rclcpp::executors::ExecutorNotifyWaitable> notify_waitable_;
-
-  /// Mutex to protect the current_entities_collection_
-  std::recursive_mutex collection_mutex_;
   std::shared_ptr<rclcpp::executors::ExecutorEntitiesCollection> current_entities_collection_;
+  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};

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.
   /**
@@ -331,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
@@ -373,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
   {
@@ -391,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>;
 
@@ -412,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,
@@ -585,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;
@@ -628,7 +505,7 @@ private:
             MessageAllocTraits::construct(allocator, ptr, *message);
 
             ros_message_subscription->provide_intra_process_message(
-              MessageUniquePtr(ptr, deleter));
+              std::move(MessageUniquePtr(ptr, deleter)));
           }
         }
       }
@@ -638,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_));

rclcpp/include/rclcpp/experimental/subscription_intra_process_base.hpp

@@ -62,15 +62,6 @@ 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;
-
   bool
   is_ready(rcl_wait_set_t * wait_set) override = 0;
 

rclcpp/include/rclcpp/experimental/subscription_intra_process_buffer.hpp

@@ -93,7 +93,7 @@ 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));
@@ -169,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"
 
@@ -172,14 +172,13 @@ public:
    * @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)
@@ -513,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
@@ -529,7 +527,7 @@ private:
   void execute_ready_timers_unsafe();
 
   // Callback to be called when timer is ready
-  std::function<void(const rclcpp::TimerBase *)> on_ready_callback_;
+  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,207 +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 <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 *;   // Serialized data pointer of request message
-  using Response = void *;  // Serialized 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>;
-
-  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;
-  };
-
-  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 `Client` instance to use more memory each time a response is not
-   * received from the service server.
-   *
-   * ```cpp
-   * auto future = client->async_send_request(my_request);
-   * if (
-   *   rclcpp::FutureReturnCode::TIMEOUT ==
-   *   executor->spin_until_future_complete(future, timeout))
-   * {
-   *   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);
-
-  /// 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);
-  }
-
-  RCLCPP_PUBLIC
-  size_t
-  prune_pending_requests();
-
-  RCLCPP_PUBLIC
-  bool
-  remove_pending_request(
-    int64_t request_id);
-
-  /// 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 CallbackInfoVariant = std::variant<
-    std::promise<SharedResponse>>;  // Use variant for extension
-
-  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_subscription.hpp

@@ -74,21 +74,18 @@ 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),
-    callback_([callback](
-        std::shared_ptr<const rclcpp::SerializedMessage> serialized_message,
-        const rclcpp::MessageInfo & message_info) mutable {
-        callback.dispatch(serialized_message, message_info);
-      }),
+    callback_(callback),
     ts_lib_(ts_lib)
   {}
 
@@ -154,9 +151,7 @@ public:
 private:
   RCLCPP_DISABLE_COPY(GenericSubscription)
 
-  std::function<void(
-      std::shared_ptr<const rclcpp::SerializedMessage>,
-      const rclcpp::MessageInfo)> 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 &
@@ -123,6 +128,7 @@ 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_;

rclcpp/include/rclcpp/logger.hpp

@@ -126,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,7 +42,6 @@
 #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_subscription.hpp"
 #include "rclcpp/logger.hpp"
@@ -234,15 +233,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.
   /**
@@ -321,22 +318,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 GenericPublisher.
   /**
    * The returned pointer will never be empty, but this function can throw various exceptions, for
@@ -375,14 +356,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>()
     )
@@ -991,16 +970,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
@@ -1333,26 +1303,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
@@ -1642,18 +1592,16 @@ 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};
+  /// Static map(s) containing extra member variables for Node without changing its ABI.
+  // See node.cpp for more details.
+  class BackportMembers;
+  static BackportMembers backport_members_;
 };
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/node_impl.hpp

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

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

@@ -127,9 +127,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/parameter_events_filter.hpp

@@ -48,7 +48,7 @@ public:
    *
    * 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_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

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"
@@ -112,12 +109,6 @@ public:
   [[deprecated("use std::shared_ptr<const PublishedType>")]] =
     std::shared_ptr<const PublishedType>;
 
-  using BufferSharedPtr = typename rclcpp::experimental::buffers::IntraProcessBuffer<
-    ROSMessageType,
-    ROSMessageTypeAllocator,
-    ROSMessageTypeDeleter
-    >::SharedPtr;
-
   RCLCPP_SMART_PTR_DEFINITIONS(Publisher<MessageT, AllocatorT>)
 
   /// Default constructor.
@@ -180,14 +171,11 @@ public:
         throw std::invalid_argument(
                 "intraprocess communication is not allowed with a zero qos history depth value");
       }
-      if (qos.durability() == rclcpp::DurabilityPolicy::TransientLocal) {
-        buffer_ = rclcpp::experimental::create_intra_process_buffer<
-          ROSMessageType, ROSMessageTypeAllocator, ROSMessageTypeDeleter>(
-          rclcpp::detail::resolve_intra_process_buffer_type(options_.intra_process_buffer_type),
-          qos,
-          std::make_shared<ROSMessageTypeAllocator>(ros_message_type_allocator_));
+      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(), buffer_);
+      uint64_t intra_process_publisher_id = ipm->add_publisher(this->shared_from_this());
       this->setup_intra_process(
         intra_process_publisher_id,
         ipm);
@@ -254,18 +242,9 @@ public:
     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));
     }
   }
 
@@ -290,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.
@@ -318,31 +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);
     }
 
     bool inter_process_publish_needed =
       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));
     }
   }
@@ -365,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.
@@ -415,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.
@@ -446,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) {
@@ -481,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) {
@@ -510,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());
@@ -532,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());
@@ -555,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());
@@ -606,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_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,20 +31,9 @@ class RateBase
 public:
   RCLCPP_SMART_PTR_DEFINITIONS_NOT_COPYABLE(RateBase)
 
-  RCLCPP_PUBLIC
   virtual ~RateBase() {}
-
-  RCLCPP_PUBLIC
   virtual bool sleep() = 0;
-
-  [[deprecated("use get_type() instead")]]
-  RCLCPP_PUBLIC
   virtual bool is_steady() const = 0;
-
-  RCLCPP_PUBLIC
-  virtual rcl_clock_type_t get_type() const = 0;
-
-  RCLCPP_PUBLIC
   virtual void reset() = 0;
 };
 
@@ -55,13 +42,14 @@ using std::chrono::duration_cast;
 using std::chrono::nanoseconds;
 
 template<class Clock = std::chrono::high_resolution_clock>
-class [[deprecated("use rclcpp::Rate class instead of GenericRate")]] GenericRate : public RateBase
+class GenericRate : public RateBase
 {
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(GenericRate)
 
   explicit GenericRate(double rate)
-  : period_(duration_cast<nanoseconds>(duration<double>(1.0 / rate))), last_interval_(Clock::now())
+  : GenericRate<Clock>(
+      duration_cast<nanoseconds>(duration<double>(1.0 / rate)))
   {}
   explicit GenericRate(std::chrono::nanoseconds period)
   : period_(period), last_interval_(Clock::now())
@@ -99,18 +87,12 @@ public:
     return true;
   }
 
-  [[deprecated("use get_type() instead")]]
   virtual bool
   is_steady() const
   {
     return Clock::is_steady;
   }
 
-  virtual rcl_clock_type_t get_type() const
-  {
-    return Clock::is_steady ? RCL_STEADY_TIME : RCL_SYSTEM_TIME;
-  }
-
   virtual void
   reset()
   {
@@ -130,59 +112,8 @@ private:
   std::chrono::time_point<Clock, ClockDurationNano> last_interval_;
 };
 
-class Rate : public RateBase
-{
-public:
-  RCLCPP_SMART_PTR_DEFINITIONS(Rate)
-
-  RCLCPP_PUBLIC
-  explicit Rate(
-    const double rate,
-    Clock::SharedPtr clock = std::make_shared<Clock>(RCL_SYSTEM_TIME));
-
-  RCLCPP_PUBLIC
-  explicit Rate(
-    const Duration & period,
-    Clock::SharedPtr clock = std::make_shared<Clock>(RCL_SYSTEM_TIME));
-
-  RCLCPP_PUBLIC
-  virtual bool
-  sleep();
-
-  [[deprecated("use get_type() instead")]]
-  RCLCPP_PUBLIC
-  virtual bool
-  is_steady() const;
-
-  RCLCPP_PUBLIC
-  virtual rcl_clock_type_t
-  get_type() const;
-
-  RCLCPP_PUBLIC
-  virtual void
-  reset();
-
-  RCLCPP_PUBLIC
-  std::chrono::nanoseconds
-  period() const;
-
-private:
-  RCLCPP_DISABLE_COPY(Rate)
-
-  Clock::SharedPtr clock_;
-  Duration period_;
-  Time 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>
@@ -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_));
@@ -499,7 +495,7 @@ public:
     }
   }
 
-  /// Configure client introspection.
+  /// Configure service 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

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(std::shared_ptr<MessageT> & msg)
   {
-    (void)msg;
+    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

@@ -104,7 +104,7 @@ public:
 
 private:
   using SubscriptionTopicStatisticsSharedPtr =
-    std::shared_ptr<rclcpp::topic_statistics::SubscriptionTopicStatistics>;
+    std::shared_ptr<rclcpp::topic_statistics::SubscriptionTopicStatistics<ROSMessageType>>;
 
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(Subscription)
@@ -127,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,
@@ -149,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)) {
@@ -165,6 +163,10 @@ public:
         throw std::invalid_argument(
                 "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<
         MessageT,
@@ -183,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()));
@@ -191,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);
     }
 
@@ -200,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_));
@@ -315,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);
     }
   }
 
@@ -324,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
@@ -368,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);
     }
   }
 

rclcpp/include/rclcpp/subscription_base.hpp

@@ -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_;
@@ -677,6 +669,9 @@ private:
   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,10 +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.
-    rclcpp::QoS qos = SystemDefaultsQoS();
   };
 
   TopicStatisticsOptions topic_stats_options;

rclcpp/include/rclcpp/time.hpp

@@ -57,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
@@ -88,7 +84,6 @@ public:
   operator builtin_interfaces::msg::Time() const;
 
   /**
-   * Copy assignment operator
    * \throws std::runtime_error if seconds are negative
    */
   RCLCPP_PUBLIC
@@ -105,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
    */
@@ -201,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
   /**
@@ -234,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

@@ -53,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
@@ -221,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);
@@ -275,9 +269,9 @@ public:
   void
   execute_callback() override
   {
-    TRACETOOLS_TRACEPOINT(callback_start, reinterpret_cast<const void *>(&callback_), false);
+    TRACEPOINT(callback_start, reinterpret_cast<const void *>(&callback_), false);
     execute_callback_delegate<>();
-    TRACETOOLS_TRACEPOINT(callback_end, reinterpret_cast<const void *>(&callback_));
+    TRACEPOINT(callback_end, reinterpret_cast<const void *>(&callback_));
   }
 
   // void specialization
@@ -336,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());
     }
   }
 

rclcpp/include/rclcpp/typesupport_helpers.hpp

@@ -22,7 +22,6 @@
 
 #include "rcpputils/shared_library.hpp"
 #include "rosidl_runtime_cpp/message_type_support_decl.hpp"
-#include "rosidl_runtime_cpp/service_type_support_decl.hpp"
 
 #include "rclcpp/visibility_control.hpp"
 
@@ -41,15 +40,11 @@ get_typesupport_library(const std::string & type, const std::string & typesuppor
 /// Extract the type support handle from the library.
 /**
  * The library needs to match the topic type. The shared library must stay loaded for the lifetime of the result.
- *
- * \deprecated Use get_message_typesupport_handle() instead
- *
  * \param[in] type The topic type, e.g. "std_msgs/msg/String"
  * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
  * \param[in] library The shared type support library
  * \return A type support handle
  */
-[[deprecated("Use `get_message_typesupport_handle` instead")]]
 RCLCPP_PUBLIC
 const rosidl_message_type_support_t *
 get_typesupport_handle(
@@ -57,40 +52,6 @@ get_typesupport_handle(
   const std::string & typesupport_identifier,
   rcpputils::SharedLibrary & library);
 
-/// Extract the message type support handle from the library.
-/**
- * The library needs to match the topic type. The shared library must stay loaded for the lifetime of the result.
- *
- * \param[in] type The topic type, e.g. "std_msgs/msg/String"
- * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
- * \param[in] library The shared type support library
- * \throws std::runtime_error if the symbol of type not found in the library.
- * \return A message type support handle
- */
-RCLCPP_PUBLIC
-const rosidl_message_type_support_t *
-get_message_typesupport_handle(
-  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 topic type. The shared library must stay loaded for the lifetime of the result.
- *
- * \param[in] type The service type, e.g. "std_srvs/srv/Empty"
- * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
- * \param[in] library The shared type support library
- * \throws std::runtime_error if the symbol of type not found in the library.
- * \return A service type support handle
- */
-RCLCPP_PUBLIC
-const rosidl_service_type_support_t *
-get_service_typesupport_handle(
-  const std::string & type,
-  const std::string & typesupport_identifier,
-  rcpputils::SharedLibrary & library);
-
 }  // namespace rclcpp
 
 #endif  // RCLCPP__TYPESUPPORT_HELPERS_HPP_

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>28.0.0</version>
+  <version>21.0.8</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/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()
@@ -123,12 +123,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()

rclcpp/src/rclcpp/context.cpp

@@ -462,7 +462,7 @@ template<Context::ShutdownType shutdown_type>
 std::vector<rclcpp::Context::ShutdownCallback>
 Context::get_shutdown_callback() const
 {
-  const auto get_callback_vector = [](auto & mutex, auto & callback_set) {
+  const auto get_callback_vector = [this](auto & mutex, auto & callback_set) {
       const std::lock_guard<std::mutex> lock(mutex);
       std::vector<rclcpp::Context::ShutdownCallback> callbacks;
       for (auto & callback : callback_set) {

rclcpp/src/rclcpp/create_generic_client.cpp

@@ -1,44 +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.
-
-#include "rclcpp/create_generic_client.hpp"
-#include "rclcpp/generic_client.hpp"
-
-namespace rclcpp
-{
-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::CallbackGroup::SharedPtr group)
-{
-  rcl_client_options_t options = rcl_client_get_default_options();
-  options.qos = qos.get_rmw_qos_profile();
-
-  auto cli = rclcpp::GenericClient::make_shared(
-    node_base.get(),
-    node_graph,
-    service_name,
-    service_type,
-    options);
-
-  auto cli_base_ptr = std::dynamic_pointer_cast<rclcpp::ClientBase>(cli);
-  node_services->add_client(cli_base_ptr, group);
-  return cli;
-}
-}  // namespace rclcpp

rclcpp/src/rclcpp/detail/resolve_intra_process_buffer_type.cpp

@@ -1,37 +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.
-
-#include <rclcpp/detail/resolve_intra_process_buffer_type.hpp>
-
-namespace rclcpp
-{
-
-namespace detail
-{
-rclcpp::IntraProcessBufferType
-resolve_intra_process_buffer_type(
-  const rclcpp::IntraProcessBufferType buffer_type)
-{
-  if (buffer_type == IntraProcessBufferType::CallbackDefault) {
-    throw std::invalid_argument(
-            "IntraProcessBufferType::CallbackDefault is not allowed "
-            "when there is no callback function");
-  }
-
-  return buffer_type;
-}
-
-}  // namespace detail
-
-}  // namespace rclcpp

rclcpp/src/rclcpp/duration.cpp

@@ -28,8 +28,6 @@
 
 #include "rcutils/logging_macros.h"
 
-#include "rclcpp/utilities.hpp"
-
 namespace rclcpp
 {
 
@@ -318,50 +316,4 @@ Duration::from_nanoseconds(rcl_duration_value_t nanoseconds)
   return ret;
 }
 
-builtin_interfaces::msg::Time
-operator+(const builtin_interfaces::msg::Time & lhs, const rclcpp::Duration & rhs)
-{
-  if (lhs.sec < 0) {
-    throw std::runtime_error("message time is negative");
-  }
-
-  rcl_time_point_value_t rcl_time;
-  rcl_time = RCL_S_TO_NS(static_cast<int64_t>(lhs.sec));
-  rcl_time += lhs.nanosec;
-
-  if (rclcpp::add_will_overflow(rcl_time, rhs.nanoseconds())) {
-    throw std::overflow_error("addition leads to int64_t overflow");
-  }
-  if (rclcpp::add_will_underflow(rcl_time, rhs.nanoseconds())) {
-    throw std::underflow_error("addition leads to int64_t underflow");
-  }
-
-  rcl_time += rhs.nanoseconds();
-
-  return convert_rcl_time_to_sec_nanos(rcl_time);
-}
-
-builtin_interfaces::msg::Time
-operator-(const builtin_interfaces::msg::Time & lhs, const rclcpp::Duration & rhs)
-{
-  if (lhs.sec < 0) {
-    throw std::runtime_error("message time is negative");
-  }
-
-  rcl_time_point_value_t rcl_time;
-  rcl_time = RCL_S_TO_NS(static_cast<int64_t>(lhs.sec));
-  rcl_time += lhs.nanosec;
-
-  if (rclcpp::sub_will_overflow(rcl_time, rhs.nanoseconds())) {
-    throw std::overflow_error("addition leads to int64_t overflow");
-  }
-  if (rclcpp::sub_will_underflow(rcl_time, rhs.nanoseconds())) {
-    throw std::underflow_error("addition leads to int64_t underflow");
-  }
-
-  rcl_time -= rhs.nanoseconds();
-
-  return convert_rcl_time_to_sec_nanos(rcl_time);
-}
-
 }  // namespace rclcpp

rclcpp/src/rclcpp/executor.cpp

@@ -95,9 +95,8 @@ Executor::~Executor()
   }
   // Disassociate all nodes.
   std::for_each(
-    weak_nodes_.begin(), weak_nodes_.end(),
-    [](rclcpp::node_interfaces::NodeBaseInterface::WeakPtr weak_node_ptr)
-    {
+    weak_nodes_.begin(), weak_nodes_.end(), []
+      (rclcpp::node_interfaces::NodeBaseInterface::WeakPtr weak_node_ptr) {
       auto shared_node_ptr = weak_node_ptr.lock();
       if (shared_node_ptr) {
         std::atomic_bool & has_executor = shared_node_ptr->get_associated_with_executor_atomic();
@@ -432,22 +431,6 @@ void Executor::spin_some(std::chrono::nanoseconds max_duration)
   return this->spin_some_impl(max_duration, false);
 }
 
-void
-Executor::spin_node_all(
-  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node,
-  std::chrono::nanoseconds max_duration)
-{
-  this->add_node(node, false);
-  spin_all(max_duration);
-  this->remove_node(node, false);
-}
-
-void
-Executor::spin_node_all(std::shared_ptr<rclcpp::Node> node, std::chrono::nanoseconds max_duration)
-{
-  this->spin_node_all(node->get_node_base_interface(), max_duration);
-}
-
 void Executor::spin_all(std::chrono::nanoseconds max_duration)
 {
   if (max_duration < 0ns) {
@@ -542,13 +525,13 @@ Executor::execute_any_executable(AnyExecutable & any_exec)
     return;
   }
   if (any_exec.timer) {
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_executor_execute,
       static_cast<const void *>(any_exec.timer->get_timer_handle().get()));
     execute_timer(any_exec.timer);
   }
   if (any_exec.subscription) {
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_executor_execute,
       static_cast<const void *>(any_exec.subscription->get_subscription_handle().get()));
     execute_subscription(any_exec.subscription);
@@ -748,7 +731,7 @@ Executor::execute_client(
 void
 Executor::wait_for_work(std::chrono::nanoseconds timeout)
 {
-  TRACETOOLS_TRACEPOINT(rclcpp_executor_wait_for_work, timeout.count());
+  TRACEPOINT(rclcpp_executor_wait_for_work, timeout.count());
   {
     std::lock_guard<std::mutex> guard(mutex_);
 
@@ -904,7 +887,7 @@ Executor::get_next_ready_executable_from_map(
   const rclcpp::memory_strategy::MemoryStrategy::WeakCallbackGroupsToNodesMap &
   weak_groups_to_nodes)
 {
-  TRACETOOLS_TRACEPOINT(rclcpp_executor_get_next_ready);
+  TRACEPOINT(rclcpp_executor_get_next_ready);
   bool success = false;
   std::lock_guard<std::mutex> guard{mutex_};
   // Check the timers to see if there are any that are ready

rclcpp/src/rclcpp/executors.cpp

@@ -14,25 +14,12 @@
 
 #include "rclcpp/executors.hpp"
 
-void
-rclcpp::spin_all(
-  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
-  std::chrono::nanoseconds max_duration)
-{
-  rclcpp::executors::SingleThreadedExecutor exec;
-  exec.spin_node_all(node_ptr, max_duration);
-}
-
-void
-rclcpp::spin_all(rclcpp::Node::SharedPtr node_ptr, std::chrono::nanoseconds max_duration)
-{
-  rclcpp::spin_all(node_ptr->get_node_base_interface(), max_duration);
-}
-
 void
 rclcpp::spin_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
 {
-  rclcpp::executors::SingleThreadedExecutor exec;
+  rclcpp::ExecutorOptions options;
+  options.context = node_ptr->get_context();
+  rclcpp::executors::SingleThreadedExecutor exec(options);
   exec.spin_node_some(node_ptr);
 }
 
@@ -45,7 +32,9 @@ rclcpp::spin_some(rclcpp::Node::SharedPtr node_ptr)
 void
 rclcpp::spin(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
 {
-  rclcpp::executors::SingleThreadedExecutor exec;
+  rclcpp::ExecutorOptions options;
+  options.context = node_ptr->get_context();
+  rclcpp::executors::SingleThreadedExecutor exec(options);
   exec.add_node(node_ptr);
   exec.spin();
   exec.remove_node(node_ptr);

rclcpp/src/rclcpp/executors/static_executor_entities_collector.cpp

@@ -409,10 +409,8 @@ StaticExecutorEntitiesCollector::remove_node(
   std::for_each(
     weak_groups_to_nodes_associated_with_executor_.begin(),
     weak_groups_to_nodes_associated_with_executor_.end(),
-    [&found_group_ptrs, node_ptr](
-      std::pair<rclcpp::CallbackGroup::WeakPtr,
-      rclcpp::node_interfaces::NodeBaseInterface::WeakPtr> key_value_pair)
-    {
+    [&found_group_ptrs, node_ptr](std::pair<rclcpp::CallbackGroup::WeakPtr,
+    rclcpp::node_interfaces::NodeBaseInterface::WeakPtr> key_value_pair) {
       auto & weak_node_ptr = key_value_pair.second;
       auto shared_node_ptr = weak_node_ptr.lock();
       auto group_ptr = key_value_pair.first.lock();
@@ -421,9 +419,8 @@ StaticExecutorEntitiesCollector::remove_node(
       }
     });
   std::for_each(
-    found_group_ptrs.begin(), found_group_ptrs.end(),
-    [this](rclcpp::CallbackGroup::SharedPtr group_ptr)
-    {
+    found_group_ptrs.begin(), found_group_ptrs.end(), [this]
+      (rclcpp::CallbackGroup::SharedPtr group_ptr) {
       this->remove_callback_group_from_map(
         group_ptr,
         weak_groups_to_nodes_associated_with_executor_);

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

@@ -206,12 +206,11 @@ EventsExecutor::spin_once_impl(std::chrono::nanoseconds timeout)
     timeout = std::chrono::nanoseconds::max();
   }
 
-  // Select the smallest between input timeout and timer timeout.
-  // Cancelled timers are not considered.
+  // Select the smallest between input timeout and timer timeout
   bool is_timer_timeout = false;
   auto next_timer_timeout = timers_manager_->get_head_timeout();
-  if (next_timer_timeout.has_value() && next_timer_timeout.value() < timeout) {
-    timeout = next_timer_timeout.value();
+  if (next_timer_timeout < timeout) {
+    timeout = next_timer_timeout;
     is_timer_timeout = true;
   }
 
@@ -274,13 +273,10 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
   switch (event.type) {
     case ExecutorEventType::CLIENT_EVENT:
       {
-        rclcpp::ClientBase::SharedPtr client;
-        {
-          std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
-          client = this->retrieve_entity(
-            static_cast<const rcl_client_t *>(event.entity_key),
-            current_entities_collection_->clients);
-        }
+        auto client = this->retrieve_entity(
+          static_cast<const rcl_client_t *>(event.entity_key),
+          current_entities_collection_->clients);
+
         if (client) {
           for (size_t i = 0; i < event.num_events; i++) {
             execute_client(client);
@@ -291,13 +287,9 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
       }
     case ExecutorEventType::SUBSCRIPTION_EVENT:
       {
-        rclcpp::SubscriptionBase::SharedPtr subscription;
-        {
-          std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
-          subscription = this->retrieve_entity(
-            static_cast<const rcl_subscription_t *>(event.entity_key),
-            current_entities_collection_->subscriptions);
-        }
+        auto subscription = this->retrieve_entity(
+          static_cast<const rcl_subscription_t *>(event.entity_key),
+          current_entities_collection_->subscriptions);
         if (subscription) {
           for (size_t i = 0; i < event.num_events; i++) {
             execute_subscription(subscription);
@@ -307,13 +299,10 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
       }
     case ExecutorEventType::SERVICE_EVENT:
       {
-        rclcpp::ServiceBase::SharedPtr service;
-        {
-          std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
-          service = this->retrieve_entity(
-            static_cast<const rcl_service_t *>(event.entity_key),
-            current_entities_collection_->services);
-        }
+        auto service = this->retrieve_entity(
+          static_cast<const rcl_service_t *>(event.entity_key),
+          current_entities_collection_->services);
+
         if (service) {
           for (size_t i = 0; i < event.num_events; i++) {
             execute_service(service);
@@ -330,13 +319,9 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
       }
     case ExecutorEventType::WAITABLE_EVENT:
       {
-        rclcpp::Waitable::SharedPtr waitable;
-        {
-          std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
-          waitable = this->retrieve_entity(
-            static_cast<const rclcpp::Waitable *>(event.entity_key),
-            current_entities_collection_->waitables);
-        }
+        auto waitable = this->retrieve_entity(
+          static_cast<const rclcpp::Waitable *>(event.entity_key),
+          current_entities_collection_->waitables);
         if (waitable) {
           for (size_t i = 0; i < event.num_events; i++) {
             auto data = waitable->take_data_by_entity_id(event.waitable_data);
@@ -401,7 +386,6 @@ EventsExecutor::get_automatically_added_callback_groups_from_nodes()
 void
 EventsExecutor::refresh_current_collection_from_callback_groups()
 {
-  // Build the new collection
   this->entities_collector_->update_collections();
   auto callback_groups = this->entities_collector_->get_all_callback_groups();
   rclcpp::executors::ExecutorEntitiesCollection new_collection;
@@ -416,9 +400,6 @@ EventsExecutor::refresh_current_collection_from_callback_groups()
   // To do it, we need to add the notify waitable as an entry in both the new and
   // current collections such that it's neither added or removed.
   this->add_notify_waitable_to_collection(new_collection.waitables);
-
-  // Acquire lock before modifying the current collection
-  std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
   this->add_notify_waitable_to_collection(current_entities_collection_->waitables);
 
   this->refresh_current_collection(new_collection);
@@ -428,9 +409,6 @@ void
 EventsExecutor::refresh_current_collection(
   const rclcpp::executors::ExecutorEntitiesCollection & new_collection)
 {
-  // Acquire lock before modifying the current collection
-  std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
-
   current_entities_collection_->timers.update(
     new_collection.timers,
     [this](rclcpp::TimerBase::SharedPtr timer) {timers_manager_->add_timer(timer);},

rclcpp/src/rclcpp/experimental/timers_manager.cpp

@@ -28,9 +28,9 @@ using rclcpp::experimental::TimersManager;
 TimersManager::TimersManager(
   std::shared_ptr<rclcpp::Context> context,
   std::function<void(const rclcpp::TimerBase *)> on_ready_callback)
-: on_ready_callback_(on_ready_callback),
-  context_(context)
 {
+  context_ = context;
+  on_ready_callback_ = on_ready_callback;
 }
 
 TimersManager::~TimersManager()
@@ -100,7 +100,7 @@ void TimersManager::stop()
   }
 }
 
-std::optional<std::chrono::nanoseconds> TimersManager::get_head_timeout()
+std::chrono::nanoseconds TimersManager::get_head_timeout()
 {
   // Do not allow to interfere with the thread running
   if (running_) {
@@ -169,7 +169,7 @@ void TimersManager::execute_ready_timer(const rclcpp::TimerBase * timer_id)
   }
 }
 
-std::optional<std::chrono::nanoseconds> TimersManager::get_head_timeout_unsafe()
+std::chrono::nanoseconds TimersManager::get_head_timeout_unsafe()
 {
   // If we don't have any weak pointer, then we just return maximum timeout
   if (weak_timers_heap_.empty()) {
@@ -191,9 +191,7 @@ std::optional<std::chrono::nanoseconds> TimersManager::get_head_timeout_unsafe()
     }
     head_timer = locked_heap.front();
   }
-  if (head_timer->is_canceled()) {
-    return std::nullopt;
-  }
+
   return head_timer->time_until_trigger();
 }
 
@@ -244,34 +242,17 @@ void TimersManager::run_timers()
     // Lock mutex
     std::unique_lock<std::mutex> lock(timers_mutex_);
 
-    std::optional<std::chrono::nanoseconds> time_to_sleep = get_head_timeout_unsafe();
+    std::chrono::nanoseconds time_to_sleep = get_head_timeout_unsafe();
 
-    // If head timer was cancelled, try to reheap and get a new head.
-    // This avoids an edge condition where head timer is cancelled, but other
-    // valid timers remain in the heap.
-    if (!time_to_sleep.has_value()) {
-      // Re-heap to (possibly) move cancelled timer from head of heap. If
-      // entire heap is cancelled, this will still result in a nullopt.
-      TimersHeap locked_heap = weak_timers_heap_.validate_and_lock();
-      locked_heap.heapify();
-      weak_timers_heap_.store(locked_heap);
-      time_to_sleep = get_head_timeout_unsafe();
-    }
-
-    // If no timers, or all timers cancelled, wait for an update.
-    if (!time_to_sleep.has_value() || (time_to_sleep.value() == std::chrono::nanoseconds::max()) ) {
-      // Wait until notification that timers have been updated
-      timers_cv_.wait(lock, [this]() {return timers_updated_;});
-
-      // Re-heap in case ordering changed due to a cancelled timer
-      // re-activating.
-      TimersHeap locked_heap = weak_timers_heap_.validate_and_lock();
-      locked_heap.heapify();
-      weak_timers_heap_.store(locked_heap);
-    } else if (time_to_sleep.value() != std::chrono::nanoseconds::zero()) {
-      // If time_to_sleep is zero, we immediately execute. Otherwise, wait
-      // until timeout or notification that timers have been updated
-      timers_cv_.wait_for(lock, time_to_sleep.value(), [this]() {return timers_updated_;});
+    // No need to wait if a timer is already available
+    if (time_to_sleep > std::chrono::nanoseconds::zero()) {
+      if (time_to_sleep != std::chrono::nanoseconds::max()) {
+        // Wait until timeout or notification that timers have been updated
+        timers_cv_.wait_for(lock, time_to_sleep, [this]() {return timers_updated_;});
+      } else {
+        // Wait until notification that timers have been updated
+        timers_cv_.wait(lock, [this]() {return timers_updated_;});
+      }
     }
 
     // Reset timers updated flag

rclcpp/src/rclcpp/generic_client.cpp

@@ -1,164 +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.
-
-#include <future>
-
-#include "rclcpp/generic_client.hpp"
-#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"
-
-namespace rclcpp
-{
-GenericClient::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)
-: ClientBase(node_base, node_graph)
-{
-  ts_lib_ = get_typesupport_library(
-    service_type, "rosidl_typesupport_cpp");
-
-  auto service_ts_ = get_service_typesupport_handle(
-    service_type, "rosidl_typesupport_cpp", *ts_lib_);
-
-  auto response_type_support_intro = get_message_typesupport_handle(
-    service_ts_->response_typesupport,
-    rosidl_typesupport_introspection_cpp::typesupport_identifier);
-  response_members_ = static_cast<const rosidl_typesupport_introspection_cpp::MessageMembers *>(
-    response_type_support_intro->data);
-
-  rcl_ret_t ret = rcl_client_init(
-    this->get_client_handle().get(),
-    this->get_rcl_node_handle(),
-    service_ts_,
-    service_name.c_str(),
-    &client_options);
-  if (ret != RCL_RET_OK) {
-    if (ret == RCL_RET_SERVICE_NAME_INVALID) {
-      auto rcl_node_handle = this->get_rcl_node_handle();
-      // this will throw on any validation problem
-      rcl_reset_error();
-      expand_topic_or_service_name(
-        service_name,
-        rcl_node_get_name(rcl_node_handle),
-        rcl_node_get_namespace(rcl_node_handle),
-        true);
-    }
-    rclcpp::exceptions::throw_from_rcl_error(ret, "could not create generic client");
-  }
-}
-
-std::shared_ptr<void>
-GenericClient::create_response()
-{
-  void * response = new uint8_t[response_members_->size_of_];
-  response_members_->init_function(response, rosidl_runtime_cpp::MessageInitialization::ZERO);
-  return std::shared_ptr<void>(
-    response,
-    [this](void * p)
-    {
-      response_members_->fini_function(p);
-      delete[] reinterpret_cast<uint8_t *>(p);
-    });
-}
-
-std::shared_ptr<rmw_request_id_t>
-GenericClient::create_request_header()
-{
-  // TODO(wjwwood): This should probably use rmw_request_id's allocator.
-  //                (since it is a C type)
-  return std::shared_ptr<rmw_request_id_t>(new rmw_request_id_t);
-}
-
-void
-GenericClient::handle_response(
-  std::shared_ptr<rmw_request_id_t> request_header,
-  std::shared_ptr<void> response)
-{
-  auto optional_pending_request =
-    this->get_and_erase_pending_request(request_header->sequence_number);
-  if (!optional_pending_request) {
-    return;
-  }
-  auto & value = *optional_pending_request;
-  if (std::holds_alternative<Promise>(value)) {
-    auto & promise = std::get<Promise>(value);
-    promise.set_value(std::move(response));
-  }
-}
-
-size_t
-GenericClient::prune_pending_requests()
-{
-  std::lock_guard guard(pending_requests_mutex_);
-  auto ret = pending_requests_.size();
-  pending_requests_.clear();
-  return ret;
-}
-
-bool
-GenericClient::remove_pending_request(int64_t request_id)
-{
-  std::lock_guard guard(pending_requests_mutex_);
-  return pending_requests_.erase(request_id) != 0u;
-}
-
-std::optional<GenericClient::CallbackInfoVariant>
-GenericClient::get_and_erase_pending_request(int64_t request_number)
-{
-  std::unique_lock<std::mutex> lock(pending_requests_mutex_);
-  auto it = pending_requests_.find(request_number);
-  if (it == pending_requests_.end()) {
-    RCUTILS_LOG_DEBUG_NAMED(
-      "rclcpp",
-      "Received invalid sequence number. Ignoring...");
-    return std::nullopt;
-  }
-  auto value = std::move(it->second.second);
-  pending_requests_.erase(request_number);
-  return value;
-}
-
-GenericClient::FutureAndRequestId
-GenericClient::async_send_request(const Request request)
-{
-  Promise promise;
-  auto future = promise.get_future();
-  auto req_id = async_send_request_impl(
-    request,
-    std::move(promise));
-  return FutureAndRequestId(std::move(future), req_id);
-}
-
-int64_t
-GenericClient::async_send_request_impl(const Request request, CallbackInfoVariant value)
-{
-  int64_t sequence_number;
-  std::lock_guard<std::mutex> lock(pending_requests_mutex_);
-  rcl_ret_t ret = rcl_send_request(get_client_handle().get(), request, &sequence_number);
-  if (RCL_RET_OK != ret) {
-    rclcpp::exceptions::throw_from_rcl_error(ret, "failed to send request");
-  }
-  pending_requests_.try_emplace(
-    sequence_number,
-    std::make_pair(std::chrono::system_clock::now(), std::move(value)));
-  return sequence_number;
-}
-
-}  // namespace rclcpp

rclcpp/src/rclcpp/generic_subscription.cpp

@@ -49,9 +49,9 @@ GenericSubscription::handle_message(
 void
 GenericSubscription::handle_serialized_message(
   const std::shared_ptr<rclcpp::SerializedMessage> & message,
-  const rclcpp::MessageInfo & message_info)
+  const rclcpp::MessageInfo &)
 {
-  callback_(message, message_info);
+  callback_(message);
 }
 
 void

rclcpp/src/rclcpp/guard_condition.cpp

@@ -23,17 +23,16 @@ namespace rclcpp
 {
 
 GuardCondition::GuardCondition(
-  const rclcpp::Context::SharedPtr & context,
+  rclcpp::Context::SharedPtr context,
   rcl_guard_condition_options_t guard_condition_options)
-: rcl_guard_condition_{rcl_get_zero_initialized_guard_condition()}
+: context_(context), rcl_guard_condition_{rcl_get_zero_initialized_guard_condition()}
 {
-  if (!context) {
+  if (!context_) {
     throw std::invalid_argument("context argument unexpectedly nullptr");
   }
-
   rcl_ret_t ret = rcl_guard_condition_init(
     &this->rcl_guard_condition_,
-    context->get_rcl_context().get(),
+    context_->get_rcl_context().get(),
     guard_condition_options);
   if (RCL_RET_OK != ret) {
     rclcpp::exceptions::throw_from_rcl_error(ret, "failed to create guard condition");
@@ -54,6 +53,12 @@ GuardCondition::~GuardCondition()
   }
 }
 
+rclcpp::Context::SharedPtr
+GuardCondition::get_context() const
+{
+  return context_;
+}
+
 rcl_guard_condition_t &
 GuardCondition::get_rcl_guard_condition()
 {

rclcpp/src/rclcpp/intra_process_manager.cpp

@@ -32,24 +32,13 @@ IntraProcessManager::~IntraProcessManager()
 {}
 
 uint64_t
-IntraProcessManager::add_publisher(
-  rclcpp::PublisherBase::SharedPtr publisher,
-  rclcpp::experimental::buffers::IntraProcessBufferBase::SharedPtr buffer)
+IntraProcessManager::add_publisher(rclcpp::PublisherBase::SharedPtr publisher)
 {
   std::unique_lock<std::shared_timed_mutex> lock(mutex_);
 
   uint64_t pub_id = IntraProcessManager::get_next_unique_id();
 
   publishers_[pub_id] = publisher;
-  if (publisher->is_durability_transient_local()) {
-    if (buffer) {
-      publisher_buffers_[pub_id] = buffer;
-    } else {
-      throw std::runtime_error(
-              "transient_local publisher needs to pass"
-              "a valid publisher buffer ptr when calling add_publisher()");
-    }
-  }
 
   // Initialize the subscriptions storage for this publisher.
   pub_to_subs_[pub_id] = SplittedSubscriptions();
@@ -69,6 +58,30 @@ IntraProcessManager::add_publisher(
   return pub_id;
 }
 
+uint64_t
+IntraProcessManager::add_subscription(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());
+    }
+  }
+
+  return sub_id;
+}
+
 void
 IntraProcessManager::remove_subscription(uint64_t intra_process_subscription_id)
 {
@@ -99,7 +112,6 @@ IntraProcessManager::remove_publisher(uint64_t intra_process_publisher_id)
   std::unique_lock<std::shared_timed_mutex> lock(mutex_);
 
   publishers_.erase(intra_process_publisher_id);
-  publisher_buffers_.erase(intra_process_publisher_id);
   pub_to_subs_.erase(intra_process_publisher_id);
 }
 
@@ -213,52 +225,5 @@ IntraProcessManager::can_communicate(
   return true;
 }
 
-size_t
-IntraProcessManager::lowest_available_capacity(const uint64_t intra_process_publisher_id) const
-{
-  size_t capacity = std::numeric_limits<size_t>::max();
-
-  auto publisher_it = pub_to_subs_.find(intra_process_publisher_id);
-  if (publisher_it == pub_to_subs_.end()) {
-    // Publisher is either invalid or no longer exists.
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Calling lowest_available_capacity for invalid or no longer existing publisher id");
-    return 0u;
-  }
-
-  if (publisher_it->second.take_shared_subscriptions.empty() &&
-    publisher_it->second.take_ownership_subscriptions.empty())
-  {
-    // no subscriptions available
-    return 0u;
-  }
-
-  auto available_capacity = [this, &capacity](const uint64_t intra_process_subscription_id)
-    {
-      auto subscription_it = subscriptions_.find(intra_process_subscription_id);
-      if (subscription_it != subscriptions_.end()) {
-        auto subscription = subscription_it->second.lock();
-        if (subscription) {
-          capacity = std::min(capacity, subscription->available_capacity());
-        }
-      } else {
-        // Subscription is either invalid or no longer exists.
-        RCLCPP_WARN(
-          rclcpp::get_logger("rclcpp"),
-          "Calling available_capacity for invalid or no longer existing subscription id");
-      }
-    };
-
-  for (const auto sub_id : publisher_it->second.take_shared_subscriptions) {
-    available_capacity(sub_id);
-  }
-
-  for (const auto sub_id : publisher_it->second.take_ownership_subscriptions) {
-    available_capacity(sub_id);
-  }
-
-  return capacity;
-}
 }  // namespace experimental
 }  // namespace rclcpp

rclcpp/src/rclcpp/logger.cpp

@@ -17,7 +17,6 @@
 #include <utility>
 
 #include "rcl_logging_interface/rcl_logging_interface.h"
-#include "rcl/error_handling.h"
 #include "rcl/logging_rosout.h"
 
 #include "rclcpp/exceptions.hpp"
@@ -81,12 +80,10 @@ Logger::get_child(const std::string & suffix)
   {
     std::lock_guard<std::recursive_mutex> guard(*logging_mutex);
     rcl_ret = rcl_logging_rosout_add_sublogger((*name_).c_str(), suffix.c_str());
-    if (RCL_RET_NOT_FOUND == rcl_ret) {
-      rcl_reset_error();
-    } else if (RCL_RET_OK != rcl_ret) {
+    if (RCL_RET_OK != rcl_ret) {
       exceptions::throw_from_rcl_error(
         rcl_ret, "failed to call rcl_logging_rosout_add_sublogger",
-        rcl_get_error_state(), rcl_reset_error);
+        rcutils_get_error_state(), rcutils_reset_error);
     }
   }
 
@@ -101,7 +98,9 @@ Logger::get_child(const std::string & suffix)
           logger_sublogger_pairname_ptr->second.c_str());
         delete logger_sublogger_pairname_ptr;
         if (RCL_RET_OK != rcl_ret) {
-          rcl_reset_error();
+          exceptions::throw_from_rcl_error(
+            rcl_ret, "failed to call rcl_logging_rosout_remove_sublogger",
+            rcutils_get_error_state(), rcutils_reset_error);
         }
       });
   }

rclcpp/src/rclcpp/node.cpp

@@ -17,13 +17,15 @@
 #include <limits>
 #include <map>
 #include <memory>
+#include <mutex>
+#include <shared_mutex>
 #include <string>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "rcl/arguments.h"
 
-#include "rclcpp/create_generic_client.hpp"
 #include "rclcpp/detail/qos_parameters.hpp"
 #include "rclcpp/exceptions.hpp"
 #include "rclcpp/graph_listener.hpp"
@@ -111,21 +113,71 @@ create_effective_namespace(const std::string & node_namespace, const std::string
 
 }  // namespace
 
-/// Internal implementation to provide hidden and API/ABI stable changes to the Node.
+/// \brief Associate new extra member variables with instances of Node without changing ABI.
 /**
- * This class is intended to be an "escape hatch" within a stable distribution, so that certain
- * smaller features and bugfixes can be backported, having a place to put new members, while
- * maintaining the ABI.
- *
- * This is not intended to be a parking place for new features, it should be used for backports
- * only, left empty and unallocated in Rolling.
+ * It is used only for bugfixes or backported features that require new members.
+ * Atomically constructs/destroys all extra members.
+ * Node instance will register and remove itself, and use its methods to retrieve members.
+ * Note for performance consideration that accessing these members uses a map lookup.
  */
-class Node::NodeImpl
+class Node::BackportMembers
 {
 public:
-  NodeImpl() = default;
-  ~NodeImpl() = default;
+  BackportMembers() = default;
+  ~BackportMembers() = default;
+
+  /// \brief Add all backported members for a new Node.
+  /**
+   * \param[in] key Raw pointer to the Node instance that will use new members.
+   */
+  void add(Node * key)
+  {
+    // Adding a new instance to the maps requires exclusive access
+    std::unique_lock lock(map_access_mutex_);
+    type_descriptions_map_.emplace(
+      key,
+      std::make_shared<rclcpp::node_interfaces::NodeTypeDescriptions>(
+        key->get_node_base_interface(),
+        key->get_node_logging_interface(),
+        key->get_node_parameters_interface(),
+        key->get_node_services_interface()));
+  }
+
+  /// \brief Remove the members for an instance of Node
+  /**
+   * \param[in] key Raw pointer to the Node
+   */
+  void remove(const Node * key)
+  {
+    // Removing an instance from the maps requires exclusive access
+    std::unique_lock lock(map_access_mutex_);
+    type_descriptions_map_.erase(key);
+  }
+
+  /// \brief Retrieve the NodeTypeDescriptionsInterface for a Node.
+  /**
+   * \param[in] key Raw pointer to an instance of Node.
+   * \return A shared ptr to this Node's NodeTypeDescriptionsInterface instance.
+   */
+  rclcpp::node_interfaces::NodeTypeDescriptionsInterface::SharedPtr
+  get_node_type_descriptions_interface(const Node * key) const
+  {
+    // Multiple threads can retrieve from the maps at the same time
+    std::shared_lock lock(map_access_mutex_);
+    return type_descriptions_map_.at(key);
+  }
+
+private:
+  /// \brief Map that stored TypeDescriptionsInterface members
+  std::unordered_map<
+    const Node *, rclcpp::node_interfaces::NodeTypeDescriptionsInterface::SharedPtr
+  > type_descriptions_map_;
+
+  /// \brief Controls access to all private maps
+  mutable std::shared_mutex map_access_mutex_;
 };
+// Definition of static member declaration
+Node::BackportMembers Node::backport_members_;
 
 Node::Node(
   const std::string & node_name,
@@ -224,17 +276,13 @@ Node::Node(
       options.clock_qos(),
       options.use_clock_thread()
     )),
-  node_type_descriptions_(new rclcpp::node_interfaces::NodeTypeDescriptions(
-      node_base_,
-      node_logging_,
-      node_parameters_,
-      node_services_
-    )),
   node_waitables_(new rclcpp::node_interfaces::NodeWaitables(node_base_.get())),
   node_options_(options),
   sub_namespace_(""),
   effective_namespace_(create_effective_namespace(this->get_namespace(), sub_namespace_))
 {
+  backport_members_.add(this);
+
   // we have got what we wanted directly from the overrides,
   // but declare the parameters anyway so they are visible.
   rclcpp::detail::declare_qos_parameters(
@@ -270,8 +318,7 @@ Node::Node(
   node_waitables_(other.node_waitables_),
   node_options_(other.node_options_),
   sub_namespace_(extend_sub_namespace(other.get_sub_namespace(), sub_namespace)),
-  effective_namespace_(create_effective_namespace(other.get_namespace(), sub_namespace_)),
-  hidden_impl_(other.hidden_impl_)
+  effective_namespace_(create_effective_namespace(other.get_namespace(), sub_namespace_))
 {
   // Validate new effective namespace.
   int validation_result;
@@ -297,6 +344,7 @@ Node::Node(
 Node::~Node()
 {
   // release sub-interfaces in an order that allows them to consult with node_base during tear-down
+  backport_members_.remove(this);
   node_waitables_.reset();
   node_time_source_.reset();
   node_parameters_.reset();
@@ -523,18 +571,6 @@ Node::count_subscribers(const std::string & topic_name) const
   return node_graph_->count_subscribers(topic_name);
 }
 
-size_t
-Node::count_clients(const std::string & service_name) const
-{
-  return node_graph_->count_clients(service_name);
-}
-
-size_t
-Node::count_services(const std::string & service_name) const
-{
-  return node_graph_->count_services(service_name);
-}
-
 std::vector<rclcpp::TopicEndpointInfo>
 Node::get_publishers_info_by_topic(const std::string & topic_name, bool no_mangle) const
 {
@@ -631,7 +667,7 @@ Node::get_node_topics_interface()
 rclcpp::node_interfaces::NodeTypeDescriptionsInterface::SharedPtr
 Node::get_node_type_descriptions_interface()
 {
-  return node_type_descriptions_;
+  return backport_members_.get_node_type_descriptions_interface(this);
 }
 
 rclcpp::node_interfaces::NodeServicesInterface::SharedPtr
@@ -677,20 +713,3 @@ Node::get_node_options() const
 {
   return this->node_options_;
 }
-
-rclcpp::GenericClient::SharedPtr
-Node::create_generic_client(
-  const std::string & service_name,
-  const std::string & service_type,
-  const rclcpp::QoS & qos,
-  rclcpp::CallbackGroup::SharedPtr group)
-{
-  return rclcpp::create_generic_client(
-    node_base_,
-    node_graph_,
-    node_services_,
-    service_name,
-    service_type,
-    qos,
-    group);
-}

rclcpp/src/rclcpp/node_interfaces/node_base.cpp

@@ -20,9 +20,6 @@
 #include "rclcpp/node_interfaces/node_base.hpp"
 
 #include "rcl/arguments.h"
-#include "rcl/node_type_cache.h"
-#include "rcl/logging.h"
-#include "rcl/logging_rosout.h"
 #include "rclcpp/exceptions.hpp"
 #include "rcutils/logging_macros.h"
 #include "rmw/validate_namespace.h"
@@ -57,12 +54,17 @@ NodeBase::NodeBase(
   std::shared_ptr<std::recursive_mutex> logging_mutex = get_global_logging_mutex();
 
   rcl_ret_t ret;
-
-  // TODO(ivanpauno): /rosout Qos should be reconfigurable.
-  ret = rcl_node_init(
-    rcl_node.get(),
-    node_name.c_str(), namespace_.c_str(),
-    context_->get_rcl_context().get(), &rcl_node_options);
+  {
+    std::lock_guard<std::recursive_mutex> guard(*logging_mutex);
+    // TODO(ivanpauno): /rosout Qos should be reconfigurable.
+    // TODO(ivanpauno): Instead of mutually excluding rcl_node_init with the global logger mutex,
+    // rcl_logging_rosout_init_publisher_for_node could be decoupled from there and be called
+    // here directly.
+    ret = rcl_node_init(
+      rcl_node.get(),
+      node_name.c_str(), namespace_.c_str(),
+      context_->get_rcl_context().get(), &rcl_node_options);
+  }
   if (ret != RCL_RET_OK) {
     if (ret == RCL_RET_NODE_INVALID_NAME) {
       rcl_reset_error();  // discard rcl_node_init error
@@ -112,29 +114,13 @@ NodeBase::NodeBase(
     throw_from_rcl_error(ret, "failed to initialize rcl node");
   }
 
-  // The initialization for the rosout publisher
-  if (rcl_logging_rosout_enabled() && rcl_node_options.enable_rosout) {
-    std::lock_guard<std::recursive_mutex> guard(*logging_mutex);
-    ret = rcl_logging_rosout_init_publisher_for_node(rcl_node.get());
-    if (ret != RCL_RET_OK) {
-      throw_from_rcl_error(ret, "failed to initialize rosout publisher");
-    }
-  }
-
   node_handle_.reset(
     rcl_node.release(),
-    [logging_mutex, rcl_node_options](rcl_node_t * node) -> void {
-      {
-        std::lock_guard<std::recursive_mutex> guard(*logging_mutex);
-        if (rcl_logging_rosout_enabled() && rcl_node_options.enable_rosout) {
-          rcl_ret_t ret = rcl_logging_rosout_fini_publisher_for_node(node);
-          if (ret != RCL_RET_OK) {
-            RCUTILS_LOG_ERROR_NAMED(
-              "rclcpp",
-              "Error in destruction of rosout publisher: %s", rcl_get_error_string().str);
-          }
-        }
-      }
+    [logging_mutex](rcl_node_t * node) -> void {
+      std::lock_guard<std::recursive_mutex> guard(*logging_mutex);
+      // TODO(ivanpauno): Instead of mutually excluding rcl_node_fini with the global logger mutex,
+      // rcl_logging_rosout_fini_publisher_for_node could be decoupled from there and be called
+      // here directly.
       if (rcl_node_fini(node) != RCL_RET_OK) {
         RCUTILS_LOG_ERROR_NAMED(
           "rclcpp",
@@ -218,9 +204,14 @@ NodeBase::create_callback_group(
   rclcpp::CallbackGroupType group_type,
   bool automatically_add_to_executor_with_node)
 {
+  auto weak_context = this->get_context()->weak_from_this();
+  auto get_node_context = [weak_context]() -> rclcpp::Context::SharedPtr {
+      return weak_context.lock();
+    };
+
   auto group = std::make_shared<rclcpp::CallbackGroup>(
     group_type,
-    context_->weak_from_this(),
+    get_node_context,
     automatically_add_to_executor_with_node);
   std::lock_guard<std::mutex> lock(callback_groups_mutex_);
   callback_groups_.push_back(group);

rclcpp/src/rclcpp/node_interfaces/node_graph.cpp

@@ -498,50 +498,6 @@ NodeGraph::count_subscribers(const std::string & topic_name) const
   return count;
 }
 
-size_t
-NodeGraph::count_clients(const std::string & service_name) const
-{
-  auto rcl_node_handle = node_base_->get_rcl_node_handle();
-
-  auto fqdn = rclcpp::expand_topic_or_service_name(
-    service_name,
-    rcl_node_get_name(rcl_node_handle),
-    rcl_node_get_namespace(rcl_node_handle),
-    true);
-
-  size_t count;
-  auto ret = rcl_count_clients(rcl_node_handle, fqdn.c_str(), &count);
-  if (ret != RMW_RET_OK) {
-    // *INDENT-OFF*
-    throw std::runtime_error(
-      std::string("could not count clients: ") + rmw_get_error_string().str);
-    // *INDENT-ON*
-  }
-  return count;
-}
-
-size_t
-NodeGraph::count_services(const std::string & service_name) const
-{
-  auto rcl_node_handle = node_base_->get_rcl_node_handle();
-
-  auto fqdn = rclcpp::expand_topic_or_service_name(
-    service_name,
-    rcl_node_get_name(rcl_node_handle),
-    rcl_node_get_namespace(rcl_node_handle),
-    true);
-
-  size_t count;
-  auto ret = rcl_count_services(rcl_node_handle, fqdn.c_str(), &count);
-  if (ret != RMW_RET_OK) {
-    // *INDENT-OFF*
-    throw std::runtime_error(
-      std::string("could not count services: ") + rmw_get_error_string().str);
-    // *INDENT-ON*
-  }
-  return count;
-}
-
 const rcl_guard_condition_t *
 NodeGraph::get_graph_guard_condition() const
 {

rclcpp/src/rclcpp/node_interfaces/node_parameters.cpp

@@ -1038,48 +1038,35 @@ NodeParameters::list_parameters(const std::vector<std::string> & prefixes, uint6
   // TODO(mikaelarguedas) define parameter separator different from "/" to avoid ambiguity
   // using "." for now
   const char * separator = ".";
-
-  auto separators_less_than_depth = [&depth, &separator](const std::string & str) -> bool {
-      return static_cast<uint64_t>(std::count(str.begin(), str.end(), *separator)) < depth;
-    };
-
-  bool recursive = (prefixes.size() == 0) &&
-    (depth == rcl_interfaces::srv::ListParameters::Request::DEPTH_RECURSIVE);
-
-  for (const std::pair<const std::string, ParameterInfo> & kv : parameters_) {
-    if (!recursive) {
-      bool get_all = (prefixes.size() == 0) && separators_less_than_depth(kv.first);
-      if (!get_all) {
-        bool prefix_matches = std::any_of(
-          prefixes.cbegin(), prefixes.cend(),
-          [&kv, &depth, &separator, &separators_less_than_depth](const std::string & prefix) {
-            if (kv.first == prefix) {
-              return true;
-            } else if (kv.first.find(prefix + separator) == 0) {
-              if (depth == rcl_interfaces::srv::ListParameters::Request::DEPTH_RECURSIVE) {
-                return true;
-              }
-              std::string substr = kv.first.substr(prefix.length() + 1);
-              return separators_less_than_depth(substr);
-            }
-            return false;
-          });
-
-        if (!prefix_matches) {
-          continue;
+  for (auto & kv : parameters_) {
+    bool get_all = (prefixes.size() == 0) &&
+      ((depth == rcl_interfaces::srv::ListParameters::Request::DEPTH_RECURSIVE) ||
+      (static_cast<uint64_t>(std::count(kv.first.begin(), kv.first.end(), *separator)) < depth));
+    bool prefix_matches = std::any_of(
+      prefixes.cbegin(), prefixes.cend(),
+      [&kv, &depth, &separator](const std::string & prefix) {
+        if (kv.first == prefix) {
+          return true;
+        } else if (kv.first.find(prefix + separator) == 0) {
+          size_t length = prefix.length();
+          std::string substr = kv.first.substr(length);
+          // Cast as unsigned integer to avoid warning
+          return (depth == rcl_interfaces::srv::ListParameters::Request::DEPTH_RECURSIVE) ||
+          (static_cast<uint64_t>(std::count(substr.begin(), substr.end(), *separator)) < depth);
+        }
+        return false;
+      });
+    if (get_all || prefix_matches) {
+      result.names.push_back(kv.first);
+      size_t last_separator = kv.first.find_last_of(separator);
+      if (std::string::npos != last_separator) {
+        std::string prefix = kv.first.substr(0, last_separator);
+        if (
+          std::find(result.prefixes.cbegin(), result.prefixes.cend(), prefix) ==
+          result.prefixes.cend())
+        {
+          result.prefixes.push_back(prefix);
         }
-      }
-    }
-
-    result.names.push_back(kv.first);
-    size_t last_separator = kv.first.find_last_of(separator);
-    if (std::string::npos != last_separator) {
-      std::string prefix = kv.first.substr(0, last_separator);
-      if (
-        std::find(result.prefixes.cbegin(), result.prefixes.cend(), prefix) ==
-        result.prefixes.cend())
-      {
-        result.prefixes.push_back(prefix);
       }
     }
   }

rclcpp/src/rclcpp/node_interfaces/node_services.cpp

@@ -32,7 +32,8 @@ NodeServices::add_service(
 {
   if (group) {
     if (!node_base_->callback_group_in_node(group)) {
-      throw rclcpp::exceptions::MissingGroupNodeException("service");
+      // TODO(jacquelinekay): use custom exception
+      throw std::runtime_error("Cannot create service, group not in node.");
     }
   } else {
     group = node_base_->get_default_callback_group();
@@ -57,7 +58,8 @@ NodeServices::add_client(
 {
   if (group) {
     if (!node_base_->callback_group_in_node(group)) {
-      throw rclcpp::exceptions::MissingGroupNodeException("client");
+      // TODO(jacquelinekay): use custom exception
+      throw std::runtime_error("Cannot create client, group not in node.");
     }
   } else {
     group = node_base_->get_default_callback_group();

rclcpp/src/rclcpp/node_interfaces/node_timers.cpp

@@ -34,7 +34,8 @@ NodeTimers::add_timer(
 {
   if (callback_group) {
     if (!node_base_->callback_group_in_node(callback_group)) {
-      throw rclcpp::exceptions::MissingGroupNodeException("timer");
+      // TODO(jacquelinekay): use custom exception
+      throw std::runtime_error("Cannot create timer, group not in node.");
     }
   } else {
     callback_group = node_base_->get_default_callback_group();
@@ -49,7 +50,7 @@ NodeTimers::add_timer(
             std::string("failed to notify wait set on timer creation: ") + ex.what());
   }
 
-  TRACETOOLS_TRACEPOINT(
+  TRACEPOINT(
     rclcpp_timer_link_node,
     static_cast<const void *>(timer->get_timer_handle().get()),
     static_cast<const void *>(node_base_->get_rcl_node_handle()));

rclcpp/src/rclcpp/node_interfaces/node_topics.cpp

@@ -58,7 +58,7 @@ NodeTopics::add_publisher(
   // Assign to a group.
   if (callback_group) {
     if (!node_base_->callback_group_in_node(callback_group)) {
-      throw rclcpp::exceptions::MissingGroupNodeException("publisher");
+      throw std::runtime_error("Cannot create publisher, callback group not in node.");
     }
   } else {
     callback_group = node_base_->get_default_callback_group();
@@ -97,7 +97,8 @@ NodeTopics::add_subscription(
   // Assign to a group.
   if (callback_group) {
     if (!node_base_->callback_group_in_node(callback_group)) {
-      throw rclcpp::exceptions::MissingGroupNodeException("subscription");
+      // TODO(jacquelinekay): use custom exception
+      throw std::runtime_error("Cannot create subscription, callback group not in node.");
     }
   } else {
     callback_group = node_base_->get_default_callback_group();

rclcpp/src/rclcpp/node_interfaces/node_type_descriptions.cpp

@@ -84,31 +84,23 @@ public:
     }
 
     if (enabled) {
-      auto * rcl_node = node_base->get_rcl_node_handle();
-      std::shared_ptr<rcl_service_t> rcl_srv(
-        new rcl_service_t,
-        [rcl_node, logger = this->logger_](rcl_service_t * service)
-        {
-          if (rcl_service_fini(service, rcl_node) != RCL_RET_OK) {
-            RCLCPP_ERROR(
-              logger,
-              "Error in destruction of rcl service handle [~/get_type_description]: %s",
-              rcl_get_error_string().str);
-            rcl_reset_error();
-          }
-          delete service;
-        });
-      *rcl_srv = rcl_get_zero_initialized_service();
-      rcl_ret_t rcl_ret = rcl_node_type_description_service_init(rcl_srv.get(), rcl_node);
-
+      auto rcl_node = node_base->get_rcl_node_handle();
+      rcl_ret_t rcl_ret = rcl_node_type_description_service_init(rcl_node);
       if (rcl_ret != RCL_RET_OK) {
         RCLCPP_ERROR(
-          logger_, "Failed to initialize ~/get_type_description service: %s",
+          logger_, "Failed to initialize ~/get_type_description_service: %s",
           rcl_get_error_string().str);
         throw std::runtime_error(
                 "Failed to initialize ~/get_type_description service.");
       }
 
+      rcl_service_t * rcl_srv = nullptr;
+      rcl_ret = rcl_node_get_type_description_service(rcl_node, &rcl_srv);
+      if (rcl_ret != RCL_RET_OK) {
+        throw std::runtime_error(
+                "Failed to get initialized ~/get_type_description service from rcl.");
+      }
+
       rclcpp::AnyServiceCallback<ServiceT> cb;
       cb.set(
         [this](
@@ -132,6 +124,18 @@ public:
         nullptr);
     }
   }
+
+  ~NodeTypeDescriptionsImpl()
+  {
+    if (
+      type_description_srv_ &&
+      RCL_RET_OK != rcl_node_type_description_service_fini(node_base_->get_rcl_node_handle()))
+    {
+      RCLCPP_ERROR(
+        logger_,
+        "Error in shutdown of get_type_description service: %s", rcl_get_error_string().str);
+    }
+  }
 };
 
 NodeTypeDescriptions::NodeTypeDescriptions(

rclcpp/src/rclcpp/node_interfaces/node_waitables.cpp

@@ -32,7 +32,8 @@ NodeWaitables::add_waitable(
 {
   if (group) {
     if (!node_base_->callback_group_in_node(group)) {
-      throw rclcpp::exceptions::MissingGroupNodeException("waitable");
+      // TODO(jacobperron): use custom exception
+      throw std::runtime_error("Cannot create waitable, group not in node.");
     }
   } else {
     group = node_base_->get_default_callback_group();

rclcpp/src/rclcpp/parameter_value.cpp

@@ -129,7 +129,8 @@ ParameterValue::ParameterValue(const rcl_interfaces::msg::ParameterValue & value
     case PARAMETER_NOT_SET:
       break;
     default:
-      throw rclcpp::exceptions::UnknownTypeError(std::to_string(value.type));
+      // TODO(wjwwood): use custom exception
+      throw std::runtime_error("Unknown type: " + std::to_string(value.type));
   }
 }
 

rclcpp/src/rclcpp/publisher_base.cpp

@@ -270,13 +270,6 @@ PublisherBase::get_intra_process_subscription_count() const
   return ipm->get_subscription_count(intra_process_publisher_id_);
 }
 
-bool
-PublisherBase::is_durability_transient_local() const
-{
-  return rcl_publisher_get_actual_qos(publisher_handle_.get())->durability ==
-         RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL;
-}
-
 rclcpp::QoS
 PublisherBase::get_actual_qos() const
 {
@@ -391,22 +384,3 @@ std::vector<rclcpp::NetworkFlowEndpoint> PublisherBase::get_network_flow_endpoin
 
   return network_flow_endpoint_vector;
 }
-
-size_t PublisherBase::lowest_available_ipm_capacity() const
-{
-  if (!intra_process_is_enabled_) {
-    return 0u;
-  }
-
-  auto ipm = weak_ipm_.lock();
-
-  if (!ipm) {
-    // TODO(ivanpauno): should this raise an error?
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Intra process manager died for a publisher.");
-    return 0u;
-  }
-
-  return ipm->lowest_available_capacity(intra_process_publisher_id_);
-}

rclcpp/src/rclcpp/rate.cpp

@@ -1,106 +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.
-
-#include "rclcpp/rate.hpp"
-
-#include <chrono>
-#include <stdexcept>
-
-namespace rclcpp
-{
-
-Rate::Rate(
-  const double rate, Clock::SharedPtr clock)
-: clock_(clock), period_(0, 0), last_interval_(clock_->now())
-{
-  if (rate <= 0.0) {
-    throw std::invalid_argument{"rate must be greater than 0"};
-  }
-  period_ = Duration::from_seconds(1.0 / rate);
-}
-
-Rate::Rate(
-  const Duration & period, Clock::SharedPtr clock)
-: clock_(clock), period_(period), last_interval_(clock_->now())
-{
-  if (period <= Duration(0, 0)) {
-    throw std::invalid_argument{"period must be greater than 0"};
-  }
-}
-
-bool
-Rate::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_;
-  }
-  // Update the interval
-  last_interval_ += period_;
-  // If the time_to_sleep is negative or zero, don't sleep
-  if (next_interval <= now) {
-    // 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;
-  }
-  // Calculate the time to sleep
-  auto time_to_sleep = next_interval - now;
-  // Sleep (will get interrupted by ctrl-c, may not sleep full time)
-  clock_->sleep_for(time_to_sleep);
-  return true;
-}
-
-bool
-Rate::is_steady() const
-{
-  return clock_->get_clock_type() == RCL_STEADY_TIME;
-}
-
-rcl_clock_type_t
-Rate::get_type() const
-{
-  return clock_->get_clock_type();
-}
-
-void
-Rate::reset()
-{
-  last_interval_ = clock_->now();
-}
-
-std::chrono::nanoseconds
-Rate::period() const
-{
-  return std::chrono::nanoseconds(period_.nanoseconds());
-}
-
-WallRate::WallRate(const double rate)
-: Rate(rate, std::make_shared<Clock>(RCL_STEADY_TIME))
-{}
-
-WallRate::WallRate(const Duration & period)
-: Rate(period, std::make_shared<Clock>(RCL_STEADY_TIME))
-{}
-
-}  // namespace rclcpp

rclcpp/src/rclcpp/signal_handler.hpp

@@ -75,7 +75,7 @@ public:
   bool
   install(SignalHandlerOptions signal_handler_options = SignalHandlerOptions::All);
 
-  /// Uninstall the signal handler for SIGINT/SIGTERM and join the dedicated signal handling
+  /// Uninstall the signal handler for SIGINT/SIGTERM and join the dedicated singal handling
   /// thread.
   /**
    * Also restores the previous signal handler.
@@ -189,7 +189,7 @@ private:
 
   // Whether or not a signal has been received.
   std::atomic_bool signal_received_ = false;
-  // A thread to which signal handling tasks are deferred.
+  // A thread to which singal handling tasks are deferred.
   std::thread signal_handler_thread_;
 
   // A mutex used to synchronize the install() and uninstall() methods.

rclcpp/src/rclcpp/subscription_base.cpp

@@ -218,7 +218,7 @@ SubscriptionBase::take_type_erased(void * message_out, rclcpp::MessageInfo & mes
     &message_info_out.get_rmw_message_info(),
     nullptr  // rmw_subscription_allocation_t is unused here
   );
-  TRACETOOLS_TRACEPOINT(rclcpp_take, static_cast<const void *>(message_out));
+  TRACEPOINT(rclcpp_take, static_cast<const void *>(message_out));
   if (RCL_RET_SUBSCRIPTION_TAKE_FAILED == ret) {
     return false;
   } else if (RCL_RET_OK != ret) {

rclcpp/src/rclcpp/subscription_intra_process_base.cpp

@@ -34,9 +34,3 @@ SubscriptionIntraProcessBase::get_actual_qos() const
 {
   return qos_profile_;
 }
-
-bool
-SubscriptionIntraProcessBase::is_durability_transient_local() const
-{
-  return qos_profile_.durability() == rclcpp::DurabilityPolicy::TransientLocal;
-}

rclcpp/src/rclcpp/time.cpp

@@ -65,8 +65,6 @@ Time::Time(int64_t nanoseconds, rcl_clock_type_t clock_type)
 
 Time::Time(const Time & rhs) = default;
 
-Time::Time(Time && rhs) noexcept = default;
-
 Time::Time(
   const builtin_interfaces::msg::Time & time_msg,
   rcl_clock_type_t clock_type)
@@ -86,11 +84,23 @@ Time::Time(const rcl_time_point_t & time_point)
   // noop
 }
 
-Time::~Time() = default;
+Time::~Time()
+{
+}
 
 Time::operator builtin_interfaces::msg::Time() const
 {
-  return convert_rcl_time_to_sec_nanos(rcl_time_.nanoseconds);
+  builtin_interfaces::msg::Time msg_time;
+  constexpr rcl_time_point_value_t kRemainder = RCL_S_TO_NS(1);
+  const auto result = std::div(rcl_time_.nanoseconds, kRemainder);
+  if (result.rem >= 0) {
+    msg_time.sec = static_cast<std::int32_t>(result.quot);
+    msg_time.nanosec = static_cast<std::uint32_t>(result.rem);
+  } else {
+    msg_time.sec = static_cast<std::int32_t>(result.quot - 1);
+    msg_time.nanosec = static_cast<std::uint32_t>(kRemainder + result.rem);
+  }
+  return msg_time;
 }
 
 Time &
@@ -103,9 +113,6 @@ Time::operator=(const builtin_interfaces::msg::Time & time_msg)
   return *this;
 }
 
-Time &
-Time::operator=(Time && rhs) noexcept = default;
-
 bool
 Time::operator==(const rclcpp::Time & rhs) const
 {
@@ -269,25 +276,10 @@ Time::operator-=(const rclcpp::Duration & rhs)
 }
 
 Time
-Time::max(rcl_clock_type_t clock_type)
+Time::max()
 {
-  return Time(std::numeric_limits<int32_t>::max(), 999999999, clock_type);
+  return Time(std::numeric_limits<int32_t>::max(), 999999999);
 }
 
-builtin_interfaces::msg::Time
-convert_rcl_time_to_sec_nanos(const rcl_time_point_value_t & time_point)
-{
-  builtin_interfaces::msg::Time ret;
-  constexpr rcl_time_point_value_t kRemainder = RCL_S_TO_NS(1);
-  const auto result = std::div(time_point, kRemainder);
-  if (result.rem >= 0) {
-    ret.sec = static_cast<std::int32_t>(result.quot);
-    ret.nanosec = static_cast<std::uint32_t>(result.rem);
-  } else {
-    ret.sec = static_cast<std::int32_t>(result.quot - 1);
-    ret.nanosec = static_cast<std::uint32_t>(kRemainder + result.rem);
-  }
-  return ret;
-}
 
 }  // namespace rclcpp

rclcpp/src/rclcpp/time_source.cpp

@@ -14,7 +14,6 @@
 
 #include <memory>
 #include <string>
-#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -91,7 +90,7 @@ public:
       }
     }
     std::lock_guard<std::mutex> guard(clock_list_lock_);
-    associated_clocks_.insert(clock);
+    associated_clocks_.push_back(clock);
     // Set the clock to zero unless there's a recently received message
     set_clock(last_time_msg_, ros_time_active_, clock);
   }
@@ -100,8 +99,10 @@ public:
   void detachClock(rclcpp::Clock::SharedPtr clock)
   {
     std::lock_guard<std::mutex> guard(clock_list_lock_);
-    auto removed = associated_clocks_.erase(clock);
-    if (removed == 0) {
+    auto result = std::find(associated_clocks_.begin(), associated_clocks_.end(), clock);
+    if (result != associated_clocks_.end()) {
+      associated_clocks_.erase(result);
+    } else {
       RCLCPP_ERROR(logger_, "failed to remove clock");
     }
   }
@@ -178,8 +179,8 @@ private:
 
   // A lock to protect iterating the associated_clocks_ field.
   std::mutex clock_list_lock_;
-  // An unordered_set to store references to associated clocks.
-  std::unordered_set<rclcpp::Clock::SharedPtr> associated_clocks_;
+  // A vector to store references to associated clocks.
+  std::vector<rclcpp::Clock::SharedPtr> associated_clocks_;
 
   // Local storage of validity of ROS time
   // This is needed when new clocks are added.
@@ -236,7 +237,6 @@ public:
     rclcpp::node_interfaces::NodeClockInterface::SharedPtr node_clock_interface,
     rclcpp::node_interfaces::NodeParametersInterface::SharedPtr node_parameters_interface)
   {
-    std::lock_guard<std::mutex> guard(node_base_lock_);
     node_base_ = node_base_interface;
     node_topics_ = node_topics_interface;
     node_graph_ = node_graph_interface;
@@ -281,14 +281,17 @@ public:
     parameter_subscription_ = rclcpp::AsyncParametersClient::on_parameter_event(
       node_topics_,
       [this](std::shared_ptr<const rcl_interfaces::msg::ParameterEvent> event) {
-        this->on_parameter_event(event);
+        if (node_base_ != nullptr) {
+          this->on_parameter_event(event);
+        }
+        // Do nothing if node_base_ is nullptr because it means the TimeSource is now
+        // without an attached node
       });
   }
 
   // Detach the attached node
   void detachNode()
   {
-    std::lock_guard<std::mutex> guard(node_base_lock_);
     // destroy_clock_sub() *must* be first here, to ensure that the executor
     // can't possibly call any of the callbacks as we are cleaning up.
     destroy_clock_sub();
@@ -325,7 +328,6 @@ private:
   std::thread clock_executor_thread_;
 
   // Preserve the node reference
-  std::mutex node_base_lock_;
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base_{nullptr};
   rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr node_topics_{nullptr};
   rclcpp::node_interfaces::NodeGraphInterface::SharedPtr node_graph_{nullptr};
@@ -463,14 +465,6 @@ private:
   // Callback for parameter updates
   void on_parameter_event(std::shared_ptr<const rcl_interfaces::msg::ParameterEvent> event)
   {
-    std::lock_guard<std::mutex> guard(node_base_lock_);
-
-    if (node_base_ == nullptr) {
-      // Do nothing if node_base_ is nullptr because it means the TimeSource is now
-      // without an attached node
-      return;
-    }
-
     // Filter out events on 'use_sim_time' parameter instances in other nodes.
     if (event->node != node_base_->get_fully_qualified_name()) {
       return;

rclcpp/src/rclcpp/timer.cpp

@@ -32,8 +32,7 @@ using rclcpp::TimerBase;
 TimerBase::TimerBase(
   rclcpp::Clock::SharedPtr clock,
   std::chrono::nanoseconds period,
-  rclcpp::Context::SharedPtr context,
-  bool autostart)
+  rclcpp::Context::SharedPtr context)
 : clock_(clock), timer_handle_(nullptr)
 {
   if (nullptr == context) {
@@ -65,9 +64,9 @@ TimerBase::TimerBase(
   rcl_clock_t * clock_handle = clock_->get_clock_handle();
   {
     std::lock_guard<std::mutex> clock_guard(clock_->get_clock_mutex());
-    rcl_ret_t ret = rcl_timer_init2(
-      timer_handle_.get(), clock_handle, rcl_context.get(), period.count(),
-      nullptr, rcl_get_default_allocator(), autostart);
+    rcl_ret_t ret = rcl_timer_init(
+      timer_handle_.get(), clock_handle, rcl_context.get(), period.count(), nullptr,
+      rcl_get_default_allocator());
     if (ret != RCL_RET_OK) {
       rclcpp::exceptions::throw_from_rcl_error(ret, "Couldn't initialize rcl timer handle");
     }

rclcpp/src/rclcpp/typesupport_helpers.cpp

@@ -91,44 +91,6 @@ extract_type_identifier(const std::string & full_type)
   return std::make_tuple(package_name, middle_module, type_name);
 }
 
-const void * get_typesupport_handle_impl(
-  const std::string & type,
-  const std::string & typesupport_identifier,
-  const std::string & typesupport_name,
-  const std::string & symbol_part_name,
-  const std::string & middle_module_additional,
-  rcpputils::SharedLibrary & library)
-{
-  std::string package_name;
-  std::string middle_module;
-  std::string type_name;
-  std::tie(package_name, middle_module, type_name) = extract_type_identifier(type);
-
-  if (middle_module.empty()) {
-    middle_module = middle_module_additional;
-  }
-
-  auto mk_error = [&package_name, &type_name, &typesupport_name](auto reason) {
-      std::stringstream rcutils_dynamic_loading_error;
-      rcutils_dynamic_loading_error <<
-        "Something went wrong loading the typesupport library for " <<
-        typesupport_name << " type " << package_name <<
-        "/" << type_name << ". " << reason;
-      return rcutils_dynamic_loading_error.str();
-    };
-
-  try {
-    std::string symbol_name = typesupport_identifier + symbol_part_name +
-      package_name + "__" + middle_module + "__" + type_name;
-    const void * (* get_ts)() = nullptr;
-    // This will throw runtime_error if the symbol was not found.
-    get_ts = reinterpret_cast<decltype(get_ts)>(library.get_symbol(symbol_name));
-    return get_ts();
-  } catch (std::runtime_error &) {
-    throw std::runtime_error{mk_error("Library could not be found.")};
-  }
-}
-
 }  // anonymous namespace
 
 std::shared_ptr<rcpputils::SharedLibrary>
@@ -139,42 +101,36 @@ get_typesupport_library(const std::string & type, const std::string & typesuppor
   return std::make_shared<rcpputils::SharedLibrary>(library_path);
 }
 
-const rosidl_message_type_support_t * get_typesupport_handle(
+const rosidl_message_type_support_t *
+get_typesupport_handle(
   const std::string & type,
   const std::string & typesupport_identifier,
   rcpputils::SharedLibrary & library)
 {
-  return get_message_typesupport_handle(type, typesupport_identifier, library);
-}
+  std::string package_name;
+  std::string middle_module;
+  std::string type_name;
+  std::tie(package_name, middle_module, type_name) = extract_type_identifier(type);
 
-const rosidl_message_type_support_t * get_message_typesupport_handle(
-  const std::string & type,
-  const std::string & typesupport_identifier,
-  rcpputils::SharedLibrary & library)
-{
-  static const std::string typesupport_name = "message";
-  static const std::string symbol_part_name = "__get_message_type_support_handle__";
-  static const std::string middle_module_additional = "msg";
+  auto mk_error = [&package_name, &type_name](auto reason) {
+      std::stringstream rcutils_dynamic_loading_error;
+      rcutils_dynamic_loading_error <<
+        "Something went wrong loading the typesupport library for message type " << package_name <<
+        "/" << type_name << ". " << reason;
+      return rcutils_dynamic_loading_error.str();
+    };
 
-  return static_cast<const rosidl_message_type_support_t *>(get_typesupport_handle_impl(
-           type, typesupport_identifier, typesupport_name, symbol_part_name,
-           middle_module_additional, library
-  ));
-}
+  try {
+    std::string symbol_name = typesupport_identifier + "__get_message_type_support_handle__" +
+      package_name + "__" + (middle_module.empty() ? "msg" : middle_module) + "__" + type_name;
 
-const rosidl_service_type_support_t * get_service_typesupport_handle(
-  const std::string & type,
-  const std::string & typesupport_identifier,
-  rcpputils::SharedLibrary & library)
-{
-  static const std::string typesupport_name = "service";
-  static const std::string symbol_part_name = "__get_service_type_support_handle__";
-  static const std::string middle_module_additional = "srv";
-
-  return static_cast<const rosidl_service_type_support_t *>(get_typesupport_handle_impl(
-           type, typesupport_identifier, typesupport_name, symbol_part_name,
-           middle_module_additional, library
-  ));
+    const rosidl_message_type_support_t * (* get_ts)() = nullptr;
+    // This will throw runtime_error if the symbol was not found.
+    get_ts = reinterpret_cast<decltype(get_ts)>(library.get_symbol(symbol_name));
+    return get_ts();
+  } catch (std::runtime_error &) {
+    throw std::runtime_error{mk_error("Library could not be found.")};
+  }
 }
 
 }  // namespace rclcpp

rclcpp/test/benchmark/CMakeLists.txt

@@ -7,12 +7,14 @@ find_package(performance_test_fixture REQUIRED)
 
 add_performance_test(benchmark_client benchmark_client.cpp)
 if(TARGET benchmark_client)
-  target_link_libraries(benchmark_client ${PROJECT_NAME} ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
+  target_link_libraries(benchmark_client ${PROJECT_NAME})
+  ament_target_dependencies(benchmark_client test_msgs rcl_interfaces)
 endif()
 
 add_performance_test(benchmark_executor benchmark_executor.cpp)
 if(TARGET benchmark_executor)
-  target_link_libraries(benchmark_executor ${PROJECT_NAME} ${test_msgs_TARGETS})
+  target_link_libraries(benchmark_executor ${PROJECT_NAME})
+  ament_target_dependencies(benchmark_executor test_msgs)
 endif()
 
 add_performance_test(benchmark_init_shutdown benchmark_init_shutdown.cpp)
@@ -37,5 +39,6 @@ endif()
 
 add_performance_test(benchmark_service benchmark_service.cpp)
 if(TARGET benchmark_service)
-  target_link_libraries(benchmark_service ${PROJECT_NAME} ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
+  target_link_libraries(benchmark_service ${PROJECT_NAME})
+  ament_target_dependencies(benchmark_service test_msgs rcl_interfaces)
 endif()

rclcpp/test/msg/LargeMessage.msg

@@ -1,3 +0,0 @@
-# A message with a size larger than the default Linux stack size
-uint8[10485760] data
-uint64 size

rclcpp/test/rclcpp/CMakeLists.txt

@@ -6,7 +6,6 @@ add_definitions(-DTEST_RESOURCES_DIRECTORY="${TEST_RESOURCES_DIRECTORY}")
 
 rosidl_generate_interfaces(${PROJECT_NAME}_test_msgs
   ../msg/Header.msg
-  ../msg/LargeMessage.msg
   ../msg/MessageWithHeader.msg
   ../msg/String.msg
   DEPENDENCIES builtin_interfaces
@@ -35,60 +34,71 @@ if(TARGET test_exceptions)
   target_link_libraries(test_exceptions ${PROJECT_NAME} mimick)
 endif()
 
-ament_add_gtest(test_allocator_memory_strategy strategies/test_allocator_memory_strategy.cpp)
+# Increasing timeout because connext can take a long time to destroy nodes
+# TODO(brawner) remove when destroying Node for Connext is resolved. See:
+# https://github.com/ros2/rclcpp/issues/1250
+ament_add_gtest(
+  test_allocator_memory_strategy
+  strategies/test_allocator_memory_strategy.cpp
+  TIMEOUT 360)
 if(TARGET test_allocator_memory_strategy)
-  target_link_libraries(test_allocator_memory_strategy ${PROJECT_NAME} rcpputils::rcpputils ${test_msgs_TARGETS})
+  ament_target_dependencies(test_allocator_memory_strategy
+    "rcl"
+    "test_msgs"
+  )
+  target_link_libraries(test_allocator_memory_strategy ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_message_pool_memory_strategy strategies/test_message_pool_memory_strategy.cpp)
 if(TARGET test_message_pool_memory_strategy)
-  target_link_libraries(test_message_pool_memory_strategy ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_message_pool_memory_strategy
+    "rcl"
+    "test_msgs"
+  )
+  target_link_libraries(test_message_pool_memory_strategy ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_any_service_callback test_any_service_callback.cpp)
 if(TARGET test_any_service_callback)
-  target_link_libraries(test_any_service_callback ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_any_service_callback
+    "test_msgs"
+  )
+  target_link_libraries(test_any_service_callback ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_any_subscription_callback test_any_subscription_callback.cpp)
 if(TARGET test_any_subscription_callback)
-  target_link_libraries(test_any_subscription_callback ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_any_subscription_callback
+    "test_msgs"
+  )
+  target_link_libraries(test_any_subscription_callback ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_client test_client.cpp)
 if(TARGET test_client)
-  target_link_libraries(test_client ${PROJECT_NAME} mimick ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
-endif()
-ament_add_gtest(test_copy_all_parameter_values test_copy_all_parameter_values.cpp)
-if(TARGET test_copy_all_parameter_values)
-  target_link_libraries(test_copy_all_parameter_values ${PROJECT_NAME})
+  ament_target_dependencies(test_client
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+    "test_msgs"
+  )
+  target_link_libraries(test_client ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_create_timer test_create_timer.cpp)
 if(TARGET test_create_timer)
+  ament_target_dependencies(test_create_timer
+    "rcl_interfaces"
+    "rmw"
+    "rcl"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+  )
   target_link_libraries(test_create_timer ${PROJECT_NAME})
   target_include_directories(test_create_timer PRIVATE ./)
 endif()
-ament_add_gtest(test_generic_client test_generic_client.cpp)
-if(TARGET test_generic_client)
-  target_link_libraries(test_generic_client ${PROJECT_NAME}
-    mimick
-    ${rcl_interfaces_TARGETS}
-    rmw::rmw
-    rosidl_runtime_cpp::rosidl_runtime_cpp
-    rosidl_typesupport_cpp::rosidl_typesupport_cpp
-    ${test_msgs_TARGETS}
-  )
-endif()
-ament_add_gtest(test_client_common test_client_common.cpp)
-if(TARGET test_client_common)
-  target_link_libraries(test_client_common ${PROJECT_NAME}
-    mimick
-    ${rcl_interfaces_TARGETS}
-    rmw::rmw
-    rosidl_runtime_cpp::rosidl_runtime_cpp
-    rosidl_typesupport_cpp::rosidl_typesupport_cpp
-    ${test_msgs_TARGETS}
-  )
-endif()
 ament_add_gtest(test_create_subscription test_create_subscription.cpp)
 if(TARGET test_create_subscription)
-  target_link_libraries(test_create_subscription ${PROJECT_NAME} ${test_msgs_TARGETS})
+  target_link_libraries(test_create_subscription ${PROJECT_NAME})
+  ament_target_dependencies(test_create_subscription
+    "test_msgs"
+  )
 endif()
 function(test_add_callback_groups_to_executor_for_rmw_implementation)
   set(rmw_implementation_env_var RMW_IMPLEMENTATION=${rmw_implementation})
@@ -97,17 +107,32 @@ function(test_add_callback_groups_to_executor_for_rmw_implementation)
     TIMEOUT 120
   )
   if(TARGET test_add_callback_groups_to_executor${target_suffix})
-    target_link_libraries(test_add_callback_groups_to_executor${target_suffix} ${PROJECT_NAME} ${test_msgs_TARGETS})
+    target_link_libraries(test_add_callback_groups_to_executor${target_suffix} ${PROJECT_NAME})
+    ament_target_dependencies(test_add_callback_groups_to_executor${target_suffix}
+      "test_msgs"
+    )
   endif()
 endfunction()
 call_for_each_rmw_implementation(test_add_callback_groups_to_executor_for_rmw_implementation)
 ament_add_gtest(test_expand_topic_or_service_name test_expand_topic_or_service_name.cpp)
 if(TARGET test_expand_topic_or_service_name)
-  target_link_libraries(test_expand_topic_or_service_name ${PROJECT_NAME} mimick rcl::rcl rmw::rmw)
+  ament_target_dependencies(test_expand_topic_or_service_name
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+  )
+  target_link_libraries(test_expand_topic_or_service_name ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_function_traits test_function_traits.cpp)
 if(TARGET test_function_traits)
-  target_link_libraries(test_function_traits ${PROJECT_NAME})
+  target_include_directories(test_function_traits PUBLIC ../../include)
+  ament_target_dependencies(test_function_traits
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+  )
 endif()
 ament_add_gtest(
   test_future_return_code
@@ -117,33 +142,72 @@ if(TARGET test_future_return_code)
 endif()
 ament_add_gmock(test_intra_process_manager test_intra_process_manager.cpp)
 if(TARGET test_intra_process_manager)
-  target_link_libraries(test_intra_process_manager ${PROJECT_NAME} ${rcl_interfaces_TARGETS} rmw::rmw)
+  ament_target_dependencies(test_intra_process_manager
+    "rcl"
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+  )
+  target_link_libraries(test_intra_process_manager ${PROJECT_NAME})
 endif()
 ament_add_gmock(test_intra_process_manager_with_allocators test_intra_process_manager_with_allocators.cpp)
 if(TARGET test_intra_process_manager_with_allocators)
-  target_link_libraries(test_intra_process_manager_with_allocators ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_intra_process_manager_with_allocators
+    "test_msgs"
+  )
+  target_link_libraries(test_intra_process_manager_with_allocators ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_ring_buffer_implementation test_ring_buffer_implementation.cpp)
 if(TARGET test_ring_buffer_implementation)
+  ament_target_dependencies(test_ring_buffer_implementation
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+  )
   target_link_libraries(test_ring_buffer_implementation ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_intra_process_buffer test_intra_process_buffer.cpp)
 if(TARGET test_intra_process_buffer)
+  ament_target_dependencies(test_intra_process_buffer
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+  )
   target_link_libraries(test_intra_process_buffer ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_loaned_message test_loaned_message.cpp)
-target_link_libraries(test_loaned_message ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
+ament_target_dependencies(test_loaned_message
+  "test_msgs"
+)
+target_link_libraries(test_loaned_message ${PROJECT_NAME} mimick)
 
 ament_add_gtest(test_memory_strategy test_memory_strategy.cpp)
-target_link_libraries(test_memory_strategy ${PROJECT_NAME} ${test_msgs_TARGETS})
+ament_target_dependencies(test_memory_strategy
+  "test_msgs"
+)
+target_link_libraries(test_memory_strategy ${PROJECT_NAME})
 
 ament_add_gtest(test_message_memory_strategy test_message_memory_strategy.cpp)
-target_link_libraries(test_message_memory_strategy ${PROJECT_NAME} ${test_msgs_TARGETS})
+ament_target_dependencies(test_message_memory_strategy
+  "test_msgs"
+)
+target_link_libraries(test_message_memory_strategy ${PROJECT_NAME})
 
 ament_add_gtest(test_node test_node.cpp TIMEOUT 240)
 if(TARGET test_node)
-  target_link_libraries(test_node ${PROJECT_NAME} mimick rcpputils::rcpputils rmw::rmw ${test_msgs_TARGETS})
+  ament_target_dependencies(test_node
+    "rcl_interfaces"
+    "rcpputils"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+    "test_msgs"
+  )
+  target_link_libraries(test_node ${PROJECT_NAME} mimick)
 endif()
 
 ament_add_gtest(test_node_interfaces__get_node_interfaces
@@ -154,7 +218,7 @@ endif()
 ament_add_gtest(test_node_interfaces__node_base
   node_interfaces/test_node_base.cpp)
 if(TARGET test_node_interfaces__node_base)
-  target_link_libraries(test_node_interfaces__node_base ${PROJECT_NAME} mimick rcl::rcl rmw::rmw)
+  target_link_libraries(test_node_interfaces__node_base ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_node_interfaces__node_clock
   node_interfaces/test_node_clock.cpp)
@@ -165,42 +229,48 @@ ament_add_gtest(test_node_interfaces__node_graph
   node_interfaces/test_node_graph.cpp
   TIMEOUT 120)
 if(TARGET test_node_interfaces__node_graph)
-  target_link_libraries(test_node_interfaces__node_graph ${PROJECT_NAME} mimick rcl::rcl ${test_msgs_TARGETS})
+  ament_target_dependencies(
+    test_node_interfaces__node_graph
+    "test_msgs")
+  target_link_libraries(test_node_interfaces__node_graph ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_node_interfaces__node_interfaces
   node_interfaces/test_node_interfaces.cpp)
 if(TARGET test_node_interfaces__node_interfaces)
-  target_link_libraries(test_node_interfaces__node_interfaces ${PROJECT_NAME})
+  target_link_libraries(test_node_interfaces__node_interfaces ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_node_interfaces__node_parameters
   node_interfaces/test_node_parameters.cpp)
 if(TARGET test_node_interfaces__node_parameters)
-  target_link_libraries(test_node_interfaces__node_parameters ${PROJECT_NAME} mimick rcpputils::rcpputils)
+  target_link_libraries(test_node_interfaces__node_parameters ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_node_interfaces__node_services
   node_interfaces/test_node_services.cpp)
 if(TARGET test_node_interfaces__node_services)
-  target_link_libraries(test_node_interfaces__node_services ${PROJECT_NAME} mimick rcl::rcl)
+  target_link_libraries(test_node_interfaces__node_services ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_node_interfaces__node_timers
   node_interfaces/test_node_timers.cpp)
 if(TARGET test_node_interfaces__node_timers)
-  target_link_libraries(test_node_interfaces__node_timers ${PROJECT_NAME} mimick rcl::rcl)
+  target_link_libraries(test_node_interfaces__node_timers ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_node_interfaces__node_topics
   node_interfaces/test_node_topics.cpp)
 if(TARGET test_node_interfaces__node_topics)
-  target_link_libraries(test_node_interfaces__node_topics ${PROJECT_NAME} mimick rcl::rcl ${test_msgs_TARGETS})
+  ament_target_dependencies(
+    test_node_interfaces__node_topics
+    "test_msgs")
+  target_link_libraries(test_node_interfaces__node_topics ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_node_interfaces__node_type_descriptions
   node_interfaces/test_node_type_descriptions.cpp)
 if(TARGET test_node_interfaces__node_type_descriptions)
-  target_link_libraries(test_node_interfaces__node_type_descriptions ${PROJECT_NAME})
+  target_link_libraries(test_node_interfaces__node_type_descriptions ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_node_interfaces__node_waitables
   node_interfaces/test_node_waitables.cpp)
 if(TARGET test_node_interfaces__node_waitables)
-  target_link_libraries(test_node_interfaces__node_waitables ${PROJECT_NAME} mimick rcl::rcl)
+  target_link_libraries(test_node_interfaces__node_waitables ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_node_interfaces__test_template_utils  # Compile time test
   node_interfaces/detail/test_template_utils.cpp)
@@ -231,43 +301,82 @@ endif()
 
 ament_add_gtest(test_node_global_args test_node_global_args.cpp)
 if(TARGET test_node_global_args)
+  ament_target_dependencies(test_node_global_args
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+  )
   target_link_libraries(test_node_global_args ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_node_options test_node_options.cpp)
 if(TARGET test_node_options)
-  target_link_libraries(test_node_options ${PROJECT_NAME} mimick rcl::rcl)
+  ament_target_dependencies(test_node_options "rcl")
+  target_link_libraries(test_node_options ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_init_options test_init_options.cpp)
 if(TARGET test_init_options)
-  target_link_libraries(test_init_options ${PROJECT_NAME} mimick rcl::rcl)
+  ament_target_dependencies(test_init_options "rcl")
+  target_link_libraries(test_init_options ${PROJECT_NAME} mimick)
 endif()
 ament_add_gmock(test_parameter_client test_parameter_client.cpp)
 if(TARGET test_parameter_client)
-  target_link_libraries(test_parameter_client ${PROJECT_NAME} ${rcl_interfaces_TARGETS})
+  ament_target_dependencies(test_parameter_client
+    "rcl_interfaces"
+  )
+  target_link_libraries(test_parameter_client ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_parameter_service test_parameter_service.cpp)
 if(TARGET test_parameter_service)
+  ament_target_dependencies(test_parameter_service
+    "rcl_interfaces"
+  )
   target_link_libraries(test_parameter_service ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_parameter_events_filter test_parameter_events_filter.cpp)
 if(TARGET test_parameter_events_filter)
-  target_link_libraries(test_parameter_events_filter ${PROJECT_NAME} ${rcl_interfaces_TARGETS})
+  ament_target_dependencies(test_parameter_events_filter
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+  )
+  target_link_libraries(test_parameter_events_filter ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_parameter test_parameter.cpp)
 if(TARGET test_parameter)
+  ament_target_dependencies(test_parameter
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+  )
   target_link_libraries(test_parameter ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_parameter_event_handler test_parameter_event_handler.cpp)
 if(TARGET test_parameter_event_handler)
+  ament_target_dependencies(test_parameter_event_handler
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_generator_cpp"
+    "rosidl_typesupport_cpp"
+  )
   target_link_libraries(test_parameter_event_handler ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_parameter_map test_parameter_map.cpp)
 if(TARGET test_parameter_map)
-  target_link_libraries(test_parameter_map ${PROJECT_NAME} rcl::rcl rcl_yaml_param_parser::rcl_yaml_param_parser rcutils::rcutils)
+  target_link_libraries(test_parameter_map ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_publisher test_publisher.cpp TIMEOUT 120)
 if(TARGET test_publisher)
-  target_link_libraries(test_publisher ${PROJECT_NAME} mimick rcl::rcl rcutils::rcutils ${test_msgs_TARGETS})
+  ament_target_dependencies(test_publisher
+    "rcl"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+    "test_msgs"
+  )
+  target_link_libraries(test_publisher ${PROJECT_NAME} mimick)
 endif()
 
 set(append_library_dirs "${CMAKE_CURRENT_BINARY_DIR}")
@@ -297,22 +406,32 @@ ament_add_gtest(test_subscription_publisher_with_same_type_adapter test_subscrip
   APPEND_LIBRARY_DIRS "${append_library_dirs}"
 )
 if(TARGET test_subscription_publisher_with_same_type_adapter)
+  ament_target_dependencies(test_subscription_publisher_with_same_type_adapter
+    "statistics_msgs"
+  )
   target_link_libraries(test_subscription_publisher_with_same_type_adapter
     ${PROJECT_NAME}
-    ${cpp_typesupport_target}
-    ${statistics_msgs_TARGETS}
-  )
+    ${cpp_typesupport_target})
 endif()
 
 ament_add_gtest(test_publisher_subscription_count_api test_publisher_subscription_count_api.cpp)
 if(TARGET test_publisher_subscription_count_api)
-  target_link_libraries(test_publisher_subscription_count_api ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_publisher_subscription_count_api
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+    "test_msgs"
+  )
+  target_link_libraries(test_publisher_subscription_count_api ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_qos test_qos.cpp)
 if(TARGET test_qos)
+  ament_target_dependencies(test_qos
+    "rmw"
+  )
   target_link_libraries(test_qos
     ${PROJECT_NAME}
-    rmw::rmw
   )
 endif()
 function(test_generic_pubsub_for_rmw_implementation)
@@ -321,7 +440,12 @@ function(test_generic_pubsub_for_rmw_implementation)
     ENV ${rmw_implementation_env_var}
   )
   if(TARGET test_generic_pubsub${target_suffix})
-    target_link_libraries(test_generic_pubsub${target_suffix} ${PROJECT_NAME} rcl::rcl ${test_msgs_TARGETS})
+    target_link_libraries(test_generic_pubsub${target_suffix} ${PROJECT_NAME})
+    ament_target_dependencies(test_generic_pubsub${target_suffix}
+      "rcpputils"
+      "rosidl_typesupport_cpp"
+      "test_msgs"
+    )
   endif()
 endfunction()
 call_for_each_rmw_implementation(test_generic_pubsub_for_rmw_implementation)
@@ -332,79 +456,153 @@ function(test_qos_event_for_rmw_implementation)
     ENV ${rmw_implementation_env_var}
   )
   if(TARGET test_qos_event${target_suffix})
-    target_link_libraries(test_qos_event${target_suffix} ${PROJECT_NAME} mimick rcutils::rcutils rmw::rmw ${test_msgs_TARGETS})
+    target_link_libraries(test_qos_event${target_suffix} ${PROJECT_NAME} mimick)
+    ament_target_dependencies(test_qos_event${target_suffix}
+      "rmw"
+      "rosidl_typesupport_cpp"
+      "test_msgs"
+    )
   endif()
 endfunction()
 call_for_each_rmw_implementation(test_qos_event_for_rmw_implementation)
 
 ament_add_gmock(test_qos_overriding_options test_qos_overriding_options.cpp)
 if(TARGET test_qos_overriding_options)
-  target_link_libraries(test_qos_overriding_options ${PROJECT_NAME})
+  target_link_libraries(test_qos_overriding_options
+    ${PROJECT_NAME}
+  )
 endif()
 ament_add_gmock(test_qos_parameters test_qos_parameters.cpp)
 if(TARGET test_qos_parameters)
-  target_link_libraries(test_qos_parameters ${PROJECT_NAME})
+  target_link_libraries(test_qos_parameters
+    ${PROJECT_NAME}
+  )
 endif()
 ament_add_gtest(test_rate test_rate.cpp)
 if(TARGET test_rate)
-  target_link_libraries(test_rate ${PROJECT_NAME})
+  ament_target_dependencies(test_rate
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+  )
+  target_link_libraries(test_rate
+    ${PROJECT_NAME}
+  )
 endif()
 ament_add_gtest(test_serialized_message_allocator test_serialized_message_allocator.cpp)
 if(TARGET test_serialized_message_allocator)
-  target_link_libraries(test_serialized_message_allocator ${PROJECT_NAME} rcl::rcl ${test_msgs_TARGETS})
+  ament_target_dependencies(test_serialized_message_allocator
+    test_msgs
+  )
+  target_link_libraries(test_serialized_message_allocator
+    ${PROJECT_NAME}
+  )
 endif()
 ament_add_gtest(test_serialized_message test_serialized_message.cpp)
 if(TARGET test_serialized_message)
-  target_link_libraries(test_serialized_message ${PROJECT_NAME} rcpputils::rcpputils ${test_msgs_TARGETS})
+  ament_target_dependencies(test_serialized_message
+    test_msgs
+  )
+  target_link_libraries(test_serialized_message
+    ${PROJECT_NAME}
+  )
 endif()
 ament_add_gtest(test_service test_service.cpp)
 if(TARGET test_service)
-  target_link_libraries(test_service ${PROJECT_NAME} mimick ${rcl_interfaces_TARGES} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_service
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+    "test_msgs"
+  )
+  target_link_libraries(test_service ${PROJECT_NAME} mimick)
 endif()
 ament_add_gmock(test_service_introspection test_service_introspection.cpp)
-if(TARGET test_service_introspection)
-  target_link_libraries(test_service_introspection ${PROJECT_NAME} mimick ${service_msgs_TARGETS} ${test_msgs_TARGETS})
+if(TARGET test_service)
+  ament_target_dependencies(test_service_introspection
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+    "test_msgs"
+  )
+  target_link_libraries(test_service_introspection ${PROJECT_NAME} mimick)
 endif()
 # Creating and destroying nodes is slow with Connext, so this needs larger timeout.
 ament_add_gtest(test_subscription test_subscription.cpp TIMEOUT 120)
 if(TARGET test_subscription)
-  target_link_libraries(test_subscription ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
+  ament_target_dependencies(test_subscription
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+    "test_msgs"
+  )
+  target_link_libraries(test_subscription ${PROJECT_NAME} mimick)
 endif()
 ament_add_gtest(test_subscription_publisher_count_api test_subscription_publisher_count_api.cpp)
 if(TARGET test_subscription_publisher_count_api)
-  target_link_libraries(test_subscription_publisher_count_api ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_subscription_publisher_count_api
+    "rcl_interfaces"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+    "test_msgs"
+  )
+  target_link_libraries(test_subscription_publisher_count_api ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_subscription_traits test_subscription_traits.cpp)
 if(TARGET test_subscription_traits)
-  target_link_libraries(test_subscription_traits ${PROJECT_NAME} rcl::rcl ${test_msgs_TARGETS})
+  ament_target_dependencies(test_subscription_traits
+    "rcl"
+    "test_msgs"
+  )
+  target_link_libraries(test_subscription_traits ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_type_support test_type_support.cpp)
 if(TARGET test_type_support)
-  target_link_libraries(test_type_support ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_type_support
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+    "test_msgs"
+  )
+  target_link_libraries(test_type_support ${PROJECT_NAME})
 endif()
 ament_add_gmock(test_typesupport_helpers test_typesupport_helpers.cpp)
 if(TARGET test_typesupport_helpers)
-  target_link_libraries(test_typesupport_helpers ${PROJECT_NAME} rcpputils::rcpputils)
+  target_link_libraries(test_typesupport_helpers ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_find_weak_nodes test_find_weak_nodes.cpp)
 if(TARGET test_find_weak_nodes)
+  ament_target_dependencies(test_find_weak_nodes
+    "rcl"
+  )
   target_link_libraries(test_find_weak_nodes ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_externally_defined_services test_externally_defined_services.cpp)
-target_link_libraries(test_externally_defined_services ${PROJECT_NAME} rcl::rcl ${test_msgs_TARGETS})
+ament_target_dependencies(test_externally_defined_services
+  "rcl"
+  "test_msgs"
+)
+target_link_libraries(test_externally_defined_services ${PROJECT_NAME})
 
 ament_add_gtest(test_duration test_duration.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_duration)
-  target_link_libraries(test_duration ${PROJECT_NAME} rcl::rcl)
+  ament_target_dependencies(test_duration
+    "rcl")
+  target_link_libraries(test_duration ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_logger test_logger.cpp)
-target_link_libraries(test_logger ${PROJECT_NAME} rcutils::rcutils)
+target_link_libraries(test_logger ${PROJECT_NAME})
 
 ament_add_gmock(test_logging test_logging.cpp)
-target_link_libraries(test_logging ${PROJECT_NAME} rcutils::rcutils)
+target_link_libraries(test_logging ${PROJECT_NAME})
 
 ament_add_gmock(test_context test_context.cpp)
 target_link_libraries(test_context ${PROJECT_NAME})
@@ -412,114 +610,134 @@ target_link_libraries(test_context ${PROJECT_NAME})
 ament_add_gtest(test_time test_time.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_time)
-  target_link_libraries(test_time ${PROJECT_NAME} rcl::rcl rcutils::rcutils)
+  ament_target_dependencies(test_time
+    "rcl")
+  target_link_libraries(test_time ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_timer test_timer.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_timer)
-  target_link_libraries(test_timer ${PROJECT_NAME} mimick rcl::rcl)
+  ament_target_dependencies(test_timer
+    "rcl")
+  target_link_libraries(test_timer ${PROJECT_NAME} mimick)
 endif()
 
 ament_add_gtest(test_timers_manager test_timers_manager.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_timers_manager)
-  target_link_libraries(test_timers_manager ${PROJECT_NAME})
+  ament_target_dependencies(test_timers_manager
+    "rcl")
+  target_link_libraries(test_timers_manager ${PROJECT_NAME} mimick)
 endif()
 
 ament_add_gtest(test_time_source test_time_source.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_time_source)
-  target_link_libraries(test_time_source ${PROJECT_NAME} rcl::rcl)
+  ament_target_dependencies(test_time_source
+    "rcl")
+  target_link_libraries(test_time_source ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_utilities test_utilities.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_utilities)
-  target_link_libraries(test_utilities ${PROJECT_NAME} mimick rcl::rcl)
+  ament_target_dependencies(test_utilities
+    "rcl")
+  target_link_libraries(test_utilities ${PROJECT_NAME} mimick)
 endif()
 
 ament_add_gtest(test_wait_for_message test_wait_for_message.cpp)
 if(TARGET test_wait_for_message)
-  target_link_libraries(test_wait_for_message ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_wait_for_message
+    "test_msgs")
+  target_link_libraries(test_wait_for_message ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_logger_service test_logger_service.cpp)
 if(TARGET test_logger_service)
-  target_link_libraries(test_logger_service ${PROJECT_NAME} ${rcl_interfaces_TARGETS})
+  ament_target_dependencies(test_logger_service
+    "rcl_interfaces")
+  target_link_libraries(test_logger_service ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_interface_traits test_interface_traits.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_interface_traits)
+  ament_target_dependencies(test_interface_traits
+    "rcl")
   target_link_libraries(test_interface_traits ${PROJECT_NAME})
 endif()
 
+# TODO(brawner) remove when destroying Node for Connext is resolved. See:
+# https://github.com/ros2/rclcpp/issues/1250
 ament_add_gtest(
   test_executors
   executors/test_executors.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}"
   TIMEOUT 180)
 if(TARGET test_executors)
-  target_link_libraries(test_executors ${PROJECT_NAME} rcl::rcl ${test_msgs_TARGETS})
-endif()
-
-ament_add_gtest(
-  test_executors_timer_cancel_behavior
-  executors/test_executors_timer_cancel_behavior.cpp
-  APPEND_LIBRARY_DIRS "${append_library_dirs}"
-  TIMEOUT 180)
-if(TARGET test_executors)
-  target_link_libraries(test_executors_timer_cancel_behavior ${PROJECT_NAME} ${rosgraph_msgs_TARGETS})
-endif()
-
-ament_add_gtest(
-  test_executors_intraprocess
-  executors/test_executors_intraprocess.cpp
-  APPEND_LIBRARY_DIRS "${append_library_dirs}"
-  TIMEOUT 180)
-if(TARGET test_executors)
-  target_link_libraries(test_executors_intraprocess ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_executors
+    "rcl"
+    "test_msgs")
+  target_link_libraries(test_executors ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_static_single_threaded_executor executors/test_static_single_threaded_executor.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_static_single_threaded_executor)
-  target_link_libraries(test_static_single_threaded_executor ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
+  ament_target_dependencies(test_static_single_threaded_executor
+    "test_msgs")
+  target_link_libraries(test_static_single_threaded_executor ${PROJECT_NAME} mimick)
 endif()
 
 ament_add_gtest(test_multi_threaded_executor executors/test_multi_threaded_executor.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_multi_threaded_executor)
+  ament_target_dependencies(test_multi_threaded_executor
+    "rcl")
   target_link_libraries(test_multi_threaded_executor ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_static_executor_entities_collector executors/test_static_executor_entities_collector.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}" TIMEOUT 120)
 if(TARGET test_static_executor_entities_collector)
-  target_link_libraries(test_static_executor_entities_collector ${PROJECT_NAME} mimick rcpputils::rcpputils ${test_msgs_TARGETS})
+  ament_target_dependencies(test_static_executor_entities_collector
+    "rcl"
+    "test_msgs")
+  target_link_libraries(test_static_executor_entities_collector ${PROJECT_NAME} mimick)
 endif()
 
 ament_add_gtest(test_entities_collector executors/test_entities_collector.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}" TIMEOUT 120)
 if(TARGET test_entities_collector)
-  target_link_libraries(test_entities_collector ${PROJECT_NAME})
+  ament_target_dependencies(test_entities_collector
+    "rcl"
+    "test_msgs")
+  target_link_libraries(test_entities_collector ${PROJECT_NAME} mimick)
 endif()
 
 ament_add_gtest(test_executor_notify_waitable executors/test_executor_notify_waitable.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}" TIMEOUT 120)
 if(TARGET test_executor_notify_waitable)
-  target_link_libraries(test_executor_notify_waitable ${PROJECT_NAME} mimick rcpputils::rcpputils)
+  ament_target_dependencies(test_executor_notify_waitable
+    "rcl"
+    "test_msgs")
+  target_link_libraries(test_executor_notify_waitable ${PROJECT_NAME} mimick)
 endif()
 
 ament_add_gtest(test_events_executor executors/test_events_executor.cpp TIMEOUT 5)
 if(TARGET test_events_executor)
-  target_link_libraries(test_events_executor ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_events_executor
+    "test_msgs")
+  target_link_libraries(test_events_executor ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_events_queue executors/test_events_queue.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_events_queue)
+  ament_target_dependencies(test_events_queue
+    "test_msgs")
   target_link_libraries(test_events_queue ${PROJECT_NAME})
 endif()
 
@@ -532,60 +750,76 @@ endif()
 ament_add_gtest(test_wait_set test_wait_set.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_wait_set)
-  target_link_libraries(test_wait_set ${PROJECT_NAME} ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_wait_set "test_msgs")
+  target_link_libraries(test_wait_set ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_subscription_topic_statistics topic_statistics/test_subscription_topic_statistics.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}"
 )
 if(TARGET test_subscription_topic_statistics)
+  ament_target_dependencies(test_subscription_topic_statistics
+    "builtin_interfaces"
+    "libstatistics_collector"
+    "rcl_interfaces"
+    "rcutils"
+    "rmw"
+    "rosidl_runtime_cpp"
+    "rosidl_typesupport_cpp"
+    "statistics_msgs"
+    "test_msgs")
   target_link_libraries(test_subscription_topic_statistics
     ${PROJECT_NAME}
-    libstatistics_collector::libstatistics_collector
-    ${statistics_msgs_TARGETS}
-    ${test_msgs_TARGETS}
-  )
+    ${cpp_typesupport_target})
 endif()
 
 ament_add_gtest(test_subscription_options test_subscription_options.cpp)
 if(TARGET test_subscription_options)
+  ament_target_dependencies(test_subscription_options "rcl")
   target_link_libraries(test_subscription_options ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_dynamic_storage wait_set_policies/test_dynamic_storage.cpp)
 if(TARGET test_dynamic_storage)
-  target_link_libraries(test_dynamic_storage ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_dynamic_storage "rcl" "test_msgs")
+  target_link_libraries(test_dynamic_storage ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_storage_policy_common wait_set_policies/test_storage_policy_common.cpp)
 if(TARGET test_storage_policy_common)
-  target_link_libraries(test_storage_policy_common ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
+  ament_target_dependencies(test_storage_policy_common "rcl" "test_msgs")
+  target_link_libraries(test_storage_policy_common ${PROJECT_NAME} mimick)
 endif()
 
 ament_add_gtest(test_static_storage wait_set_policies/test_static_storage.cpp)
 if(TARGET test_static_storage)
-  target_link_libraries(test_static_storage ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_static_storage "rcl" "test_msgs")
+  target_link_libraries(test_static_storage ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_thread_safe_synchronization wait_set_policies/test_thread_safe_synchronization.cpp)
 if(TARGET test_thread_safe_synchronization)
-  target_link_libraries(test_thread_safe_synchronization ${PROJECT_NAME} ${test_msgs_TARGETS})
+  ament_target_dependencies(test_thread_safe_synchronization "rcl" "test_msgs")
+  target_link_libraries(test_thread_safe_synchronization ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_rosout_qos test_rosout_qos.cpp)
 if(TARGET test_rosout_qos)
-  target_link_libraries(test_rosout_qos ${PROJECT_NAME} rcl::rcl rmw::rmw)
+  ament_target_dependencies(test_rosout_qos "rcl")
+  target_link_libraries(test_rosout_qos ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_rosout_subscription test_rosout_subscription.cpp)
 if(TARGET test_rosout_subscription)
-  target_link_libraries(test_rosout_subscription ${PROJECT_NAME} ${rcl_interfaces_TARGETS})
+  ament_target_dependencies(test_rosout_subscription "rcl")
+  target_link_libraries(test_rosout_subscription ${PROJECT_NAME})
 endif()
 
 ament_add_gtest(test_executor test_executor.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}"
   TIMEOUT 120)
 if(TARGET test_executor)
+  ament_target_dependencies(test_executor "rcl")
   target_link_libraries(test_executor ${PROJECT_NAME} mimick)
 endif()
 
@@ -602,7 +836,12 @@ function(test_subscription_content_filter_for_rmw_implementation)
     TIMEOUT 120
   )
   if(TARGET test_subscription_content_filter${target_suffix})
-    target_link_libraries(test_subscription_content_filter${target_suffix} ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
+    target_link_libraries(test_subscription_content_filter${target_suffix} ${PROJECT_NAME} mimick)
+    ament_target_dependencies(test_subscription_content_filter${target_suffix}
+      "rcpputils"
+      "rosidl_typesupport_cpp"
+      "test_msgs"
+    )
   endif()
 endfunction()
 call_for_each_rmw_implementation(test_subscription_content_filter_for_rmw_implementation)

rclcpp/test/rclcpp/executors/executor_types.hpp

@@ -1,70 +0,0 @@
-// Copyright 2017 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef RCLCPP__EXECUTORS__EXECUTOR_TYPES_HPP_
-#define RCLCPP__EXECUTORS__EXECUTOR_TYPES_HPP_
-
-#include <gtest/gtest.h>
-
-#include <string>
-#include <type_traits>
-
-#include "rclcpp/experimental/executors/events_executor/events_executor.hpp"
-#include "rclcpp/executors/single_threaded_executor.hpp"
-#include "rclcpp/executors/static_single_threaded_executor.hpp"
-#include "rclcpp/executors/multi_threaded_executor.hpp"
-
-using ExecutorTypes =
-  ::testing::Types<
-  rclcpp::executors::SingleThreadedExecutor,
-  rclcpp::executors::MultiThreadedExecutor,
-  rclcpp::executors::StaticSingleThreadedExecutor,
-  rclcpp::experimental::executors::EventsExecutor>;
-
-class ExecutorTypeNames
-{
-public:
-  template<typename T>
-  static std::string GetName(int idx)
-  {
-    (void)idx;
-    if (std::is_same<T, rclcpp::executors::SingleThreadedExecutor>()) {
-      return "SingleThreadedExecutor";
-    }
-
-    if (std::is_same<T, rclcpp::executors::MultiThreadedExecutor>()) {
-      return "MultiThreadedExecutor";
-    }
-
-    if (std::is_same<T, rclcpp::executors::StaticSingleThreadedExecutor>()) {
-      return "StaticSingleThreadedExecutor";
-    }
-
-    if (std::is_same<T, rclcpp::experimental::executors::EventsExecutor>()) {
-      return "EventsExecutor";
-    }
-
-    return "";
-  }
-};
-
-// StaticSingleThreadedExecutor is not included in these tests for now, due to:
-// https://github.com/ros2/rclcpp/issues/1219
-using StandardExecutors =
-  ::testing::Types<
-  rclcpp::executors::SingleThreadedExecutor,
-  rclcpp::executors::MultiThreadedExecutor,
-  rclcpp::experimental::executors::EventsExecutor>;
-
-#endif  // RCLCPP__EXECUTORS__EXECUTOR_TYPES_HPP_

rclcpp/test/rclcpp/executors/test_events_executor.cpp

@@ -43,6 +43,11 @@ public:
 
 TEST_F(TestEventsExecutor, run_pub_sub)
 {
+  // rmw_connextdds doesn't support events-executor
+  if (std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0) {
+    GTEST_SKIP();
+  }
+
   auto node = std::make_shared<rclcpp::Node>("node");
 
   bool msg_received = false;
@@ -60,7 +65,7 @@ TEST_F(TestEventsExecutor, run_pub_sub)
   executor.add_node(node);
 
   bool spin_exited = false;
-  std::thread spinner([&spin_exited, &executor]() {
+  std::thread spinner([&spin_exited, &executor, this]() {
       executor.spin();
       spin_exited = true;
     });
@@ -75,6 +80,8 @@ TEST_F(TestEventsExecutor, run_pub_sub)
     !spin_exited &&
     (std::chrono::high_resolution_clock::now() - start < 1s))
   {
+    auto time = std::chrono::high_resolution_clock::now() - start;
+    auto time_msec = std::chrono::duration_cast<std::chrono::milliseconds>(time);
     std::this_thread::sleep_for(25ms);
   }
 
@@ -88,6 +95,11 @@ TEST_F(TestEventsExecutor, run_pub_sub)
 
 TEST_F(TestEventsExecutor, run_clients_servers)
 {
+  // rmw_connextdds doesn't support events-executor
+  if (std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0) {
+    GTEST_SKIP();
+  }
+
   auto node = std::make_shared<rclcpp::Node>("node");
 
   bool request_received = false;
@@ -107,7 +119,7 @@ TEST_F(TestEventsExecutor, run_clients_servers)
   executor.add_node(node);
 
   bool spin_exited = false;
-  std::thread spinner([&spin_exited, &executor]() {
+  std::thread spinner([&spin_exited, &executor, this]() {
       executor.spin();
       spin_exited = true;
     });
@@ -141,6 +153,11 @@ TEST_F(TestEventsExecutor, run_clients_servers)
 
 TEST_F(TestEventsExecutor, spin_once_max_duration_timeout)
 {
+  // rmw_connextdds doesn't support events-executor
+  if (std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0) {
+    GTEST_SKIP();
+  }
+
   auto node = std::make_shared<rclcpp::Node>("node");
 
   EventsExecutor executor;
@@ -173,6 +190,11 @@ TEST_F(TestEventsExecutor, spin_once_max_duration_timeout)
 
 TEST_F(TestEventsExecutor, spin_once_max_duration_timer)
 {
+  // rmw_connextdds doesn't support events-executor
+  if (std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0) {
+    GTEST_SKIP();
+  }
+
   auto node = std::make_shared<rclcpp::Node>("node");
 
   EventsExecutor executor;
@@ -204,6 +226,11 @@ TEST_F(TestEventsExecutor, spin_once_max_duration_timer)
 
 TEST_F(TestEventsExecutor, spin_some_max_duration)
 {
+  // rmw_connextdds doesn't support events-executor
+  if (std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0) {
+    GTEST_SKIP();
+  }
+
   {
     auto node = std::make_shared<rclcpp::Node>("node");
 
@@ -250,6 +277,11 @@ TEST_F(TestEventsExecutor, spin_some_max_duration)
 
 TEST_F(TestEventsExecutor, spin_some_zero_duration)
 {
+  // rmw_connextdds doesn't support events-executor
+  if (std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0) {
+    GTEST_SKIP();
+  }
+
   auto node = std::make_shared<rclcpp::Node>("node");
 
   size_t t_runs = 0;
@@ -271,6 +303,11 @@ TEST_F(TestEventsExecutor, spin_some_zero_duration)
 
 TEST_F(TestEventsExecutor, spin_all_max_duration)
 {
+  // rmw_connextdds doesn't support events-executor
+  if (std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0) {
+    GTEST_SKIP();
+  }
+
   {
     auto node = std::make_shared<rclcpp::Node>("node");
 
@@ -321,6 +358,11 @@ TEST_F(TestEventsExecutor, spin_all_max_duration)
 
 TEST_F(TestEventsExecutor, cancel_while_timers_running)
 {
+  // rmw_connextdds doesn't support events-executor
+  if (std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0) {
+    GTEST_SKIP();
+  }
+
   auto node = std::make_shared<rclcpp::Node>("node");
 
   EventsExecutor executor;
@@ -346,7 +388,7 @@ TEST_F(TestEventsExecutor, cancel_while_timers_running)
     });
 
 
-  std::thread spinner([&executor]() {executor.spin();});
+  std::thread spinner([&executor, this]() {executor.spin();});
 
   std::this_thread::sleep_for(10ms);
   // Call cancel while t1 callback is still being executed
@@ -360,6 +402,11 @@ TEST_F(TestEventsExecutor, cancel_while_timers_running)
 
 TEST_F(TestEventsExecutor, cancel_while_timers_waiting)
 {
+  // rmw_connextdds doesn't support events-executor
+  if (std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0) {
+    GTEST_SKIP();
+  }
+
   auto node = std::make_shared<rclcpp::Node>("node");
 
   size_t t1_runs = 0;
@@ -373,7 +420,7 @@ TEST_F(TestEventsExecutor, cancel_while_timers_waiting)
   executor.add_node(node);
 
   auto start = std::chrono::steady_clock::now();
-  std::thread spinner([&executor]() {executor.spin();});
+  std::thread spinner([&executor, this]() {executor.spin();});
 
   std::this_thread::sleep_for(10ms);
   executor.cancel();
@@ -388,6 +435,11 @@ TEST_F(TestEventsExecutor, destroy_entities)
   // This test fails on Windows! We skip it for now
   GTEST_SKIP();
 
+  // rmw_connextdds doesn't support events-executor
+  if (std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0) {
+    GTEST_SKIP();
+  }
+
   // Create a publisher node and start publishing messages
   auto node_pub = std::make_shared<rclcpp::Node>("node_pub");
   auto publisher = node_pub->create_publisher<test_msgs::msg::Empty>("topic", rclcpp::QoS(10));
@@ -395,7 +447,7 @@ TEST_F(TestEventsExecutor, destroy_entities)
     2ms, [&]() {publisher->publish(std::make_unique<test_msgs::msg::Empty>());});
   EventsExecutor executor_pub;
   executor_pub.add_node(node_pub);
-  std::thread spinner([&executor_pub]() {executor_pub.spin();});
+  std::thread spinner([&executor_pub, this]() {executor_pub.spin();});
 
   // Create a node with two different subscriptions to the topic
   auto node_sub = std::make_shared<rclcpp::Node>("node_sub");
@@ -433,6 +485,11 @@ std::string * g_sub_log_msg;
 std::promise<void> * g_log_msgs_promise;
 TEST_F(TestEventsExecutor, test_default_incompatible_qos_callbacks)
 {
+  // rmw_connextdds doesn't support events-executor
+  if (std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0) {
+    GTEST_SKIP();
+  }
+
   auto node = std::make_shared<rclcpp::Node>("node");
   rcutils_logging_output_handler_t original_output_handler = rcutils_logging_get_output_handler();
 

rclcpp/test/rclcpp/executors/test_executors.cpp

@@ -15,13 +15,14 @@
 /**
  * This test checks all implementations of rclcpp::executor to check they pass they basic API
  * tests. Anything specific to any executor in particular should go in a separate test file.
+ *
  */
-
 #include <gtest/gtest.h>
 
 #include <algorithm>
 #include <atomic>
 #include <chrono>
+#include <future>
 #include <limits>
 #include <memory>
 #include <string>
@@ -36,12 +37,9 @@
 #include "rclcpp/duration.hpp"
 #include "rclcpp/guard_condition.hpp"
 #include "rclcpp/rclcpp.hpp"
-#include "rclcpp/time_source.hpp"
 
 #include "test_msgs/msg/empty.hpp"
 
-#include "./executor_types.hpp"
-
 using namespace std::chrono_literals;
 
 template<typename T>
@@ -87,14 +85,65 @@ public:
 template<typename T>
 class TestExecutorsStable : public TestExecutors<T> {};
 
+using ExecutorTypes =
+  ::testing::Types<
+  rclcpp::executors::SingleThreadedExecutor,
+  rclcpp::executors::MultiThreadedExecutor,
+  rclcpp::executors::StaticSingleThreadedExecutor,
+  rclcpp::experimental::executors::EventsExecutor>;
+
+class ExecutorTypeNames
+{
+public:
+  template<typename T>
+  static std::string GetName(int idx)
+  {
+    (void)idx;
+    if (std::is_same<T, rclcpp::executors::SingleThreadedExecutor>()) {
+      return "SingleThreadedExecutor";
+    }
+
+    if (std::is_same<T, rclcpp::executors::MultiThreadedExecutor>()) {
+      return "MultiThreadedExecutor";
+    }
+
+    if (std::is_same<T, rclcpp::executors::StaticSingleThreadedExecutor>()) {
+      return "StaticSingleThreadedExecutor";
+    }
+
+    if (std::is_same<T, rclcpp::experimental::executors::EventsExecutor>()) {
+      return "EventsExecutor";
+    }
+
+    return "";
+  }
+};
+
+// TYPED_TEST_SUITE is deprecated as of gtest 1.9, use TYPED_TEST_SUITE when gtest dependency
+// is updated.
 TYPED_TEST_SUITE(TestExecutors, ExecutorTypes, ExecutorTypeNames);
 
+// StaticSingleThreadedExecutor is not included in these tests for now, due to:
+// https://github.com/ros2/rclcpp/issues/1219
+using StandardExecutors =
+  ::testing::Types<
+  rclcpp::executors::SingleThreadedExecutor,
+  rclcpp::executors::MultiThreadedExecutor,
+  rclcpp::experimental::executors::EventsExecutor>;
 TYPED_TEST_SUITE(TestExecutorsStable, StandardExecutors, ExecutorTypeNames);
 
 // Make sure that executors detach from nodes when destructing
 TYPED_TEST(TestExecutors, detachOnDestruction)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   {
     ExecutorType executor;
     executor.add_node(this->node);
@@ -111,6 +160,14 @@ TYPED_TEST(TestExecutors, detachOnDestruction)
 TYPED_TEST(TestExecutorsStable, addTemporaryNode)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor;
 
   {
@@ -131,6 +188,14 @@ TYPED_TEST(TestExecutorsStable, addTemporaryNode)
 TYPED_TEST(TestExecutors, emptyExecutor)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor;
   std::thread spinner([&]() {EXPECT_NO_THROW(executor.spin());});
   std::this_thread::sleep_for(50ms);
@@ -142,6 +207,14 @@ TYPED_TEST(TestExecutors, emptyExecutor)
 TYPED_TEST(TestExecutors, addNodeTwoExecutors)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor1;
   ExecutorType executor2;
   EXPECT_NO_THROW(executor1.add_node(this->node));
@@ -153,6 +226,14 @@ TYPED_TEST(TestExecutors, addNodeTwoExecutors)
 TYPED_TEST(TestExecutors, spinWithTimer)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor;
 
   bool timer_completed = false;
@@ -176,6 +257,14 @@ TYPED_TEST(TestExecutors, spinWithTimer)
 TYPED_TEST(TestExecutors, spinWhileAlreadySpinning)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor;
   executor.add_node(this->node);
 
@@ -203,6 +292,14 @@ TYPED_TEST(TestExecutors, spinWhileAlreadySpinning)
 TYPED_TEST(TestExecutors, testSpinUntilFutureComplete)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor;
   executor.add_node(this->node);
 
@@ -226,6 +323,14 @@ TYPED_TEST(TestExecutors, testSpinUntilFutureComplete)
 TYPED_TEST(TestExecutors, testSpinUntilSharedFutureComplete)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor;
   executor.add_node(this->node);
 
@@ -250,6 +355,14 @@ TYPED_TEST(TestExecutors, testSpinUntilSharedFutureComplete)
 TYPED_TEST(TestExecutors, testSpinUntilFutureCompleteNoTimeout)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor;
   executor.add_node(this->node);
 
@@ -297,6 +410,14 @@ TYPED_TEST(TestExecutors, testSpinUntilFutureCompleteNoTimeout)
 TYPED_TEST(TestExecutors, testSpinUntilFutureCompleteWithTimeout)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor;
   executor.add_node(this->node);
 
@@ -352,13 +473,8 @@ public:
   bool
   is_ready(rcl_wait_set_t * wait_set) override
   {
-    for (size_t i = 0; i < wait_set->size_of_guard_conditions; ++i) {
-      auto rcl_guard_condition = wait_set->guard_conditions[i];
-      if (&gc_.get_rcl_guard_condition() == rcl_guard_condition) {
-        return true;
-      }
-    }
-    return false;
+    (void)wait_set;
+    return true;
   }
 
   std::shared_ptr<void>
@@ -379,20 +495,7 @@ public:
   {
     (void) data;
     count_++;
-    if (nullptr != on_execute_callback_) {
-      on_execute_callback_();
-    } else {
-      // TODO(wjwwood): I don't know why this was here, but probably it should
-      //   not be there, or test cases where that is important should use the
-      //   on_execute_callback?
-      std::this_thread::sleep_for(3ms);
-    }
-  }
-
-  void
-  set_on_execute_callback(std::function<void()> on_execute_callback)
-  {
-    on_execute_callback_ = on_execute_callback;
+    std::this_thread::sleep_for(3ms);
   }
 
   void
@@ -422,12 +525,19 @@ public:
 private:
   size_t count_ = 0;
   rclcpp::GuardCondition gc_;
-  std::function<void()> on_execute_callback_ = nullptr;
 };
 
 TYPED_TEST(TestExecutors, spinAll)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor;
   auto waitable_interfaces = this->node->get_node_waitables_interface();
   auto my_waitable = std::make_shared<TestWaitable>();
@@ -467,188 +577,67 @@ TYPED_TEST(TestExecutors, spinAll)
   spinner.join();
 }
 
-// Helper function to convert chrono durations into a scalar that GoogleTest
-// can more easily compare and print.
-template<typename DurationT>
-auto
-to_nanoseconds_helper(DurationT duration)
-{
-  return std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count();
-}
-
-// The purpose of this test is to check that the ExecutorT.spin_some() method:
-//   - works nominally (it can execute entities)
-//   - it can execute multiple items at once
-//   - it does not wait for work to be available before returning
-TYPED_TEST(TestExecutors, spin_some)
+TYPED_TEST(TestExecutors, spinSome)
 {
   using ExecutorType = TypeParam;
-
-  // Use an isolated callback group to avoid interference from any housekeeping
-  // items that may be in the default callback group of the node.
-  constexpr bool automatically_add_to_executor_with_node = false;
-  auto isolated_callback_group = this->node->create_callback_group(
-    rclcpp::CallbackGroupType::MutuallyExclusive,
-    automatically_add_to_executor_with_node);
-
-  // Check that spin_some() returns quickly when there is no work to be done.
-  // This can be a false positive if there is somehow some work for the executor
-  // to do that has not been considered, but the isolated callback group should
-  // avoid that.
-  {
-    ExecutorType executor;
-    executor.add_callback_group(isolated_callback_group, this->node->get_node_base_interface());
-
-    auto start = std::chrono::steady_clock::now();
-    // spin_some with some non-trival "max_duration" and check that it does not
-    // take anywhere near that long to execute.
-    constexpr auto max_duration = 10s;
-    executor.spin_some(max_duration);
-    EXPECT_LT(
-      to_nanoseconds_helper(std::chrono::steady_clock::now() - start),
-      to_nanoseconds_helper(max_duration / 2))
-      << "spin_some() took a long time to execute when it should have done "
-      << "nothing and should not have blocked either, but this could be a "
-      << "false negative if the computer is really slow";
-  }
-
-  // Check that having one thing ready gets executed by spin_some().
-  auto waitable_interfaces = this->node->get_node_waitables_interface();
-  auto my_waitable1 = std::make_shared<TestWaitable>();
-  waitable_interfaces->add_waitable(my_waitable1, isolated_callback_group);
-  {
-    ExecutorType executor;
-    executor.add_callback_group(isolated_callback_group, this->node->get_node_base_interface());
-
-    my_waitable1->trigger();
-
-    // The long duration should not matter, as executing the waitable is
-    // non-blocking, and spin_some() should exit after completing the available
-    // work.
-    auto start = std::chrono::steady_clock::now();
-    constexpr auto max_duration = 10s;
-    executor.spin_some(max_duration);
-    EXPECT_LT(
-      to_nanoseconds_helper(std::chrono::steady_clock::now() - start),
-      to_nanoseconds_helper(max_duration / 2))
-      << "spin_some() took a long time to execute when it should have very "
-      << "little to do and should not have blocked either, but this could be a "
-      << "false negative if the computer is really slow";
-
-    EXPECT_EQ(my_waitable1->get_count(), 1u)
-      << "spin_some() failed to execute a waitable that was triggered";
-  }
-
-  // Check that multiple things being ready are executed by spin_some().
-  auto my_waitable2 = std::make_shared<TestWaitable>();
-  waitable_interfaces->add_waitable(my_waitable2, isolated_callback_group);
-  {
-    ExecutorType executor;
-    executor.add_callback_group(isolated_callback_group, this->node->get_node_base_interface());
-
-    const size_t original_my_waitable1_count = my_waitable1->get_count();
-    my_waitable1->trigger();
-    my_waitable2->trigger();
-
-    // The long duration should not matter, as executing the waitable is
-    // non-blocking, and spin_some() should exit after completing the available
-    // work.
-    auto start = std::chrono::steady_clock::now();
-    constexpr auto max_duration = 10s;
-    executor.spin_some(max_duration);
-    EXPECT_LT(
-      to_nanoseconds_helper(std::chrono::steady_clock::now() - start),
-      to_nanoseconds_helper(max_duration / 2))
-      << "spin_some() took a long time to execute when it should have very "
-      << "little to do and should not have blocked either, but this could be a "
-      << "false negative if the computer is really slow";
-
-    EXPECT_EQ(my_waitable1->get_count(), original_my_waitable1_count + 1)
-      << "spin_some() failed to execute a waitable that was triggered";
-    EXPECT_EQ(my_waitable2->get_count(), 1u)
-      << "spin_some() failed to execute a waitable that was triggered";
-  }
-}
-
-// The purpose of this test is to check that the ExecutorT.spin_some() method:
-//   - does not continue executing after max_duration has elapsed
-TYPED_TEST(TestExecutors, spin_some_max_duration)
-{
-  using ExecutorType = TypeParam;
-
-  // TODO(wjwwood): The `StaticSingleThreadedExecutor`
-  //   do not properly implement max_duration (it seems), so disable this test
-  //   for them in the meantime.
-  //   see: https://github.com/ros2/rclcpp/issues/2462
+  // rmw_connextdds doesn't support events-executor
   if (
-    std::is_same<ExecutorType, rclcpp::executors::StaticSingleThreadedExecutor>())
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
   {
     GTEST_SKIP();
   }
 
-  // Use an isolated callback group to avoid interference from any housekeeping
-  // items that may be in the default callback group of the node.
-  constexpr bool automatically_add_to_executor_with_node = false;
-  auto isolated_callback_group = this->node->create_callback_group(
-    rclcpp::CallbackGroupType::MutuallyExclusive,
-    automatically_add_to_executor_with_node);
-
-  // Set up a situation with two waitables that take time to execute, such that
-  // the time it takes to execute two waitables far exceeds the max_duration
-  // given to spin_some(), which should result in spin_some() starting to
-  // execute one of them, have the max duration elapse, finish executing one
-  // of them, then returning before starting on the second.
-  constexpr auto max_duration = 100ms;  // relatively short because we expect to exceed it
-  constexpr auto waitable_callback_duration = max_duration * 2;
-  auto long_running_callback = [&waitable_callback_duration]() {
-      std::this_thread::sleep_for(waitable_callback_duration);
-    };
-
-  auto waitable_interfaces = this->node->get_node_waitables_interface();
-
-  auto my_waitable1 = std::make_shared<TestWaitable>();
-  my_waitable1->set_on_execute_callback(long_running_callback);
-  waitable_interfaces->add_waitable(my_waitable1, isolated_callback_group);
-
-  auto my_waitable2 = std::make_shared<TestWaitable>();
-  my_waitable2->set_on_execute_callback(long_running_callback);
-  waitable_interfaces->add_waitable(my_waitable2, isolated_callback_group);
-
-  my_waitable1->trigger();
-  my_waitable2->trigger();
-
   ExecutorType executor;
-  executor.add_callback_group(isolated_callback_group, this->node->get_node_base_interface());
+  auto waitable_interfaces = this->node->get_node_waitables_interface();
+  auto my_waitable = std::make_shared<TestWaitable>();
+  waitable_interfaces->add_waitable(my_waitable, nullptr);
+  executor.add_node(this->node);
 
+  // Long timeout, doesn't block test from finishing because spin_some should exit after the
+  // first one completes.
+  bool spin_exited = false;
+  std::thread spinner([&spin_exited, &executor, this]() {
+      executor.spin_some(1s);
+      executor.remove_node(this->node, true);
+      spin_exited = true;
+    });
+
+  // Do some work until sufficient calls to the waitable occur, but keep going until either
+  // count becomes too large, spin exits, or the 1 second timeout completes.
   auto start = std::chrono::steady_clock::now();
-  // spin_some and check that it does not take longer than two of waitable_callback_duration,
-  // nor significantly less than a single waitable_callback_duration.
-  executor.spin_some(max_duration);
-  auto spin_some_run_time = std::chrono::steady_clock::now() - start;
-  EXPECT_GT(
-    to_nanoseconds_helper(spin_some_run_time),
-    to_nanoseconds_helper(waitable_callback_duration / 2))
-    << "spin_some() took less than half the expected time to execute a single "
-    << "waitable, which implies it did not actually execute one when it was "
-    << "expected to";
-  EXPECT_LT(
-    to_nanoseconds_helper(spin_some_run_time),
-    to_nanoseconds_helper(waitable_callback_duration * 2))
-    << "spin_some() took longer than expected to execute by a significant margin, but "
-    << "this could be a false positive on a very slow computer";
+  while (
+    my_waitable->get_count() <= 1 &&
+    !spin_exited &&
+    (std::chrono::steady_clock::now() - start < 1s))
+  {
+    my_waitable->trigger();
+    this->publisher->publish(test_msgs::msg::Empty());
+    std::this_thread::sleep_for(1ms);
+  }
+  // The count of "execute" depends on whether the executor starts spinning before (1) or after (0)
+  // the first iteration of the while loop
+  EXPECT_LE(1u, my_waitable->get_count());
+  waitable_interfaces->remove_waitable(my_waitable, nullptr);
+  EXPECT_TRUE(spin_exited);
+  // Cancel if it hasn't exited already.
+  executor.cancel();
 
-  // check that exactly one of the waitables were executed (do not depend on a specific order)
-  size_t number_of_waitables_executed = my_waitable1->get_count() + my_waitable2->get_count();
-  EXPECT_EQ(number_of_waitables_executed, 1u)
-    << "expected exactly one of the two waitables to be executed, but "
-    << "my_waitable1->get_count(): " << my_waitable1->get_count() << " and "
-    << "my_waitable2->get_count(): " << my_waitable2->get_count();
+  spinner.join();
 }
 
 // Check spin_node_until_future_complete with node base pointer
 TYPED_TEST(TestExecutors, testSpinNodeUntilFutureCompleteNodeBasePtr)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor;
 
   std::promise<bool> promise;
@@ -665,6 +654,14 @@ TYPED_TEST(TestExecutors, testSpinNodeUntilFutureCompleteNodeBasePtr)
 TYPED_TEST(TestExecutors, testSpinNodeUntilFutureCompleteNodePtr)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor;
 
   std::promise<bool> promise;
@@ -681,6 +678,14 @@ TYPED_TEST(TestExecutors, testSpinNodeUntilFutureCompleteNodePtr)
 TYPED_TEST(TestExecutors, testSpinUntilFutureCompleteInterrupted)
 {
   using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }
+
   ExecutorType executor;
   executor.add_node(this->node);
 
@@ -760,7 +765,6 @@ TYPED_TEST(TestExecutors, testRaceConditionAddNode)
             break;
           }
           total += k * (i + 42);
-          (void)total;
         }
       });
   }
@@ -833,3 +837,134 @@ TEST(TestExecutors, testSpinUntilFutureCompleteNodePtr)
 
   rclcpp::shutdown();
 }
+
+template<typename T>
+class TestIntraprocessExecutors : public ::testing::Test
+{
+public:
+  static void SetUpTestCase()
+  {
+    rclcpp::init(0, nullptr);
+  }
+
+  static void TearDownTestCase()
+  {
+    rclcpp::shutdown();
+  }
+
+  void SetUp()
+  {
+    const auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
+    std::stringstream test_name;
+    test_name << test_info->test_case_name() << "_" << test_info->name();
+    node = std::make_shared<rclcpp::Node>("node", test_name.str());
+
+    callback_count = 0u;
+
+    const std::string topic_name = std::string("topic_") + test_name.str();
+
+    rclcpp::PublisherOptions po;
+    po.use_intra_process_comm = rclcpp::IntraProcessSetting::Enable;
+    publisher = node->create_publisher<test_msgs::msg::Empty>(topic_name, rclcpp::QoS(1), po);
+
+    auto callback = [this](test_msgs::msg::Empty::ConstSharedPtr) {
+        this->callback_count.fetch_add(1u);
+      };
+
+    rclcpp::SubscriptionOptions so;
+    so.use_intra_process_comm = rclcpp::IntraProcessSetting::Enable;
+    subscription =
+      node->create_subscription<test_msgs::msg::Empty>(
+      topic_name, rclcpp::QoS(kNumMessages), std::move(callback), so);
+  }
+
+  void TearDown()
+  {
+    publisher.reset();
+    subscription.reset();
+    node.reset();
+  }
+
+  const size_t kNumMessages = 100;
+
+  rclcpp::Node::SharedPtr node;
+  rclcpp::Publisher<test_msgs::msg::Empty>::SharedPtr publisher;
+  rclcpp::Subscription<test_msgs::msg::Empty>::SharedPtr subscription;
+  std::atomic_size_t callback_count;
+};
+
+TYPED_TEST_SUITE(TestIntraprocessExecutors, ExecutorTypes, ExecutorTypeNames);
+
+TYPED_TEST(TestIntraprocessExecutors, testIntraprocessRetrigger) {
+  // This tests that executors will continue to service intraprocess subscriptions in the case
+  // that publishers aren't continuing to publish.
+  // This was previously broken in that intraprocess guard conditions were only triggered on
+  // publish and the test was added to prevent future regressions.
+  const size_t kNumMessages = 100;
+
+  using ExecutorType = TypeParam;
+  ExecutorType executor;
+  executor.add_node(this->node);
+
+  EXPECT_EQ(0u, this->callback_count.load());
+  this->publisher->publish(test_msgs::msg::Empty());
+
+  // Wait for up to 5 seconds for the first message to come available.
+  const std::chrono::milliseconds sleep_per_loop(10);
+  int loops = 0;
+  while (1u != this->callback_count.load() && loops < 500) {
+    rclcpp::sleep_for(sleep_per_loop);
+    executor.spin_some();
+    loops++;
+  }
+  EXPECT_EQ(1u, this->callback_count.load());
+
+  // reset counter
+  this->callback_count.store(0u);
+
+  for (size_t ii = 0; ii < kNumMessages; ++ii) {
+    this->publisher->publish(test_msgs::msg::Empty());
+  }
+
+  // Fire a timer every 10ms up to 5 seconds waiting for subscriptions to be read.
+  loops = 0;
+  auto timer = this->node->create_wall_timer(
+    std::chrono::milliseconds(10), [this, &executor, &loops, &kNumMessages]() {
+      loops++;
+      if (kNumMessages == this->callback_count.load() ||
+      loops == 500)
+      {
+        executor.cancel();
+      }
+    });
+  executor.spin();
+  EXPECT_EQ(kNumMessages, this->callback_count.load());
+}
+
+// Check spin functions with non default context
+TEST(TestExecutors, testSpinWithNonDefaultContext)
+{
+  auto non_default_context = std::make_shared<rclcpp::Context>();
+  non_default_context->init(0, nullptr);
+
+  {
+    auto node =
+      std::make_unique<rclcpp::Node>("node", rclcpp::NodeOptions().context(non_default_context));
+
+    EXPECT_NO_THROW(rclcpp::spin_some(node->get_node_base_interface()));
+
+    auto check_spin_until_future_complete = [&]() {
+        std::promise<bool> promise;
+        std::future<bool> future = promise.get_future();
+        promise.set_value(true);
+
+        auto shared_future = future.share();
+        auto ret = rclcpp::spin_until_future_complete(
+          node->get_node_base_interface(), shared_future, 1s);
+        EXPECT_EQ(rclcpp::FutureReturnCode::SUCCESS, ret);
+      };
+    EXPECT_NO_THROW(check_spin_until_future_complete());
+  }
+
+  rclcpp::shutdown(non_default_context);
+}

rclcpp/test/rclcpp/executors/test_executors_intraprocess.cpp

@@ -1,125 +0,0 @@
-// Copyright 2024 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <gtest/gtest.h>
-
-#include <string>
-
-#include "rclcpp/node.hpp"
-#include "rclcpp/utilities.hpp"
-
-#include "test_msgs/msg/empty.hpp"
-
-#include "./executor_types.hpp"
-
-template<typename T>
-class TestIntraprocessExecutors : public ::testing::Test
-{
-public:
-  static void SetUpTestCase()
-  {
-    rclcpp::init(0, nullptr);
-  }
-
-  static void TearDownTestCase()
-  {
-    rclcpp::shutdown();
-  }
-
-  void SetUp()
-  {
-    const auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
-    std::stringstream test_name;
-    test_name << test_info->test_case_name() << "_" << test_info->name();
-    node = std::make_shared<rclcpp::Node>("node", test_name.str());
-
-    callback_count = 0u;
-
-    const std::string topic_name = std::string("topic_") + test_name.str();
-
-    rclcpp::PublisherOptions po;
-    po.use_intra_process_comm = rclcpp::IntraProcessSetting::Enable;
-    publisher = node->create_publisher<test_msgs::msg::Empty>(topic_name, rclcpp::QoS(1), po);
-
-    auto callback = [this](test_msgs::msg::Empty::ConstSharedPtr) {
-        this->callback_count.fetch_add(1u);
-      };
-
-    rclcpp::SubscriptionOptions so;
-    so.use_intra_process_comm = rclcpp::IntraProcessSetting::Enable;
-    subscription =
-      node->create_subscription<test_msgs::msg::Empty>(
-      topic_name, rclcpp::QoS(kNumMessages), std::move(callback), so);
-  }
-
-  void TearDown()
-  {
-    publisher.reset();
-    subscription.reset();
-    node.reset();
-  }
-
-  const size_t kNumMessages = 100;
-
-  rclcpp::Node::SharedPtr node;
-  rclcpp::Publisher<test_msgs::msg::Empty>::SharedPtr publisher;
-  rclcpp::Subscription<test_msgs::msg::Empty>::SharedPtr subscription;
-  std::atomic_size_t callback_count;
-};
-
-TYPED_TEST_SUITE(TestIntraprocessExecutors, ExecutorTypes, ExecutorTypeNames);
-
-TYPED_TEST(TestIntraprocessExecutors, testIntraprocessRetrigger) {
-  // This tests that executors will continue to service intraprocess subscriptions in the case
-  // that publishers aren't continuing to publish.
-  // This was previously broken in that intraprocess guard conditions were only triggered on
-  // publish and the test was added to prevent future regressions.
-  static constexpr size_t kNumMessages = 100;
-
-  using ExecutorType = TypeParam;
-  ExecutorType executor;
-  executor.add_node(this->node);
-
-  EXPECT_EQ(0u, this->callback_count.load());
-  this->publisher->publish(test_msgs::msg::Empty());
-
-  // Wait for up to 5 seconds for the first message to come available.
-  const std::chrono::milliseconds sleep_per_loop(10);
-  int loops = 0;
-  while (1u != this->callback_count.load() && loops < 500) {
-    rclcpp::sleep_for(sleep_per_loop);
-    executor.spin_some();
-    loops++;
-  }
-  EXPECT_EQ(1u, this->callback_count.load());
-
-  // reset counter
-  this->callback_count.store(0u);
-
-  for (size_t ii = 0; ii < kNumMessages; ++ii) {
-    this->publisher->publish(test_msgs::msg::Empty());
-  }
-
-  // Fire a timer every 10ms up to 5 seconds waiting for subscriptions to be read.
-  loops = 0;
-  auto timer = this->node->create_wall_timer(
-    std::chrono::milliseconds(10), [this, &executor, &loops]() {
-      loops++;
-      if (kNumMessages == this->callback_count.load() || loops == 500) {
-        executor.cancel();
-      }
-    });
-  executor.spin();
-  EXPECT_EQ(kNumMessages, this->callback_count.load());
-}

rclcpp/test/rclcpp/executors/test_executors_timer_cancel_behavior.cpp

@@ -1,430 +0,0 @@
-// Copyright 2024 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <gtest/gtest.h>
-
-#include <chrono>
-#include <cmath>
-#include <cstdlib>
-#include <mutex>
-#include <string>
-
-#include "rclcpp/node.hpp"
-#include "rclcpp/parameter_client.hpp"
-#include "rclcpp/utilities.hpp"
-
-#include "rosgraph_msgs/msg/clock.hpp"
-
-#include "./executor_types.hpp"
-
-using namespace std::chrono_literals;
-
-class TimerNode : public rclcpp::Node
-{
-public:
-  explicit TimerNode(std::string subname)
-  : Node("timer_node", subname)
-  {
-  }
-
-  void CreateTimer1()
-  {
-    timer1_ = rclcpp::create_timer(
-      this->get_node_base_interface(), get_node_timers_interface(),
-      get_clock(), 1ms,
-      std::bind(&TimerNode::Timer1Callback, this));
-  }
-
-  void CreateTimer2()
-  {
-    timer2_ = rclcpp::create_timer(
-      this->get_node_base_interface(), get_node_timers_interface(),
-      get_clock(), 1ms,
-      std::bind(&TimerNode::Timer2Callback, this));
-  }
-
-  int GetTimer1Cnt() {return cnt1_;}
-  int GetTimer2Cnt() {return cnt2_;}
-
-  void ResetTimer1()
-  {
-    timer1_->reset();
-  }
-
-  void ResetTimer2()
-  {
-    timer2_->reset();
-  }
-
-  void CancelTimer1()
-  {
-    RCLCPP_DEBUG(this->get_logger(), "Timer 1 cancelling!");
-    timer1_->cancel();
-  }
-
-  void CancelTimer2()
-  {
-    RCLCPP_DEBUG(this->get_logger(), "Timer 2 cancelling!");
-    timer2_->cancel();
-  }
-
-private:
-  void Timer1Callback()
-  {
-    cnt1_++;
-    RCLCPP_DEBUG(this->get_logger(), "Timer 1! (%d)", cnt1_);
-  }
-
-  void Timer2Callback()
-  {
-    cnt2_++;
-    RCLCPP_DEBUG(this->get_logger(), "Timer 2! (%d)", cnt2_);
-  }
-
-  rclcpp::TimerBase::SharedPtr timer1_;
-  rclcpp::TimerBase::SharedPtr timer2_;
-  int cnt1_ = 0;
-  int cnt2_ = 0;
-};
-
-// Sets up a separate thread to publish /clock messages.
-// Clock rate relative to real clock is controlled by realtime_update_rate.
-// This is set conservatively slow to ensure unit tests are reliable on Windows
-// environments, where timing performance is subpar.
-//
-// Use `sleep_for` in tests to advance the clock. Clock should run and be published
-// in separate thread continuously to ensure correct behavior in node under test.
-class ClockPublisher : public rclcpp::Node
-{
-public:
-  explicit ClockPublisher(float simulated_clock_step = .001f, float realtime_update_rate = 0.25f)
-  : Node("clock_publisher"),
-    ros_update_duration_(0, 0),
-    realtime_clock_step_(0, 0),
-    rostime_(0, 0)
-  {
-    clock_publisher_ = this->create_publisher<rosgraph_msgs::msg::Clock>("clock", 10);
-    realtime_clock_step_ =
-      rclcpp::Duration::from_seconds(simulated_clock_step / realtime_update_rate);
-    ros_update_duration_ = rclcpp::Duration::from_seconds(simulated_clock_step);
-
-    timer_thread_ = std::thread(&ClockPublisher::RunTimer, this);
-  }
-
-  ~ClockPublisher()
-  {
-    running_ = false;
-    if (timer_thread_.joinable()) {
-      timer_thread_.join();
-    }
-  }
-
-  void sleep_for(rclcpp::Duration duration)
-  {
-    rclcpp::Time start_time(0, 0, RCL_ROS_TIME);
-    {
-      const std::lock_guard<std::mutex> lock(mutex_);
-      start_time = rostime_;
-    }
-    rclcpp::Time current_time = start_time;
-
-    while (true) {
-      {
-        const std::lock_guard<std::mutex> lock(mutex_);
-        current_time = rostime_;
-      }
-      if ((current_time - start_time) >= duration) {
-        return;
-      }
-      std::this_thread::sleep_for(realtime_clock_step_.to_chrono<std::chrono::milliseconds>());
-      rostime_ += ros_update_duration_;
-    }
-  }
-
-private:
-  void RunTimer()
-  {
-    while (running_) {
-      PublishClock();
-      std::this_thread::sleep_for(realtime_clock_step_.to_chrono<std::chrono::milliseconds>());
-    }
-  }
-
-  void PublishClock()
-  {
-    const std::lock_guard<std::mutex> lock(mutex_);
-    auto message = rosgraph_msgs::msg::Clock();
-    message.clock = rostime_;
-    clock_publisher_->publish(message);
-  }
-
-  rclcpp::Publisher<rosgraph_msgs::msg::Clock>::SharedPtr clock_publisher_;
-
-  rclcpp::Duration ros_update_duration_;
-  rclcpp::Duration realtime_clock_step_;
-  // Rostime must be guarded by a mutex, since accessible in running thread
-  // as well as sleep_for
-  rclcpp::Time rostime_;
-  std::mutex mutex_;
-  std::thread timer_thread_;
-  std::atomic<bool> running_ = true;
-};
-
-
-template<typename T>
-class TestTimerCancelBehavior : public ::testing::Test
-{
-public:
-  static void SetUpTestCase()
-  {
-    rclcpp::init(0, nullptr);
-  }
-
-  static void TearDownTestCase()
-  {
-    rclcpp::shutdown();
-  }
-
-  void SetUp()
-  {
-    const auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
-    std::stringstream test_name;
-    test_name << test_info->test_case_name() << "_" << test_info->name();
-    node = std::make_shared<TimerNode>(test_name.str());
-    param_client = std::make_shared<rclcpp::SyncParametersClient>(node);
-    ASSERT_TRUE(param_client->wait_for_service(5s));
-
-    auto set_parameters_results = param_client->set_parameters(
-      {rclcpp::Parameter("use_sim_time", true)});
-    for (auto & result : set_parameters_results) {
-      ASSERT_TRUE(result.successful);
-    }
-
-    // Check if the clock type is simulation time
-    EXPECT_EQ(RCL_ROS_TIME, node->get_clock()->get_clock_type());
-
-    // Create timers
-    this->node->CreateTimer1();
-    this->node->CreateTimer2();
-
-    // Run standalone thread to publish clock time
-    sim_clock_node = std::make_shared<ClockPublisher>();
-
-    // Spin the executor in a standalone thread
-    executor.add_node(this->node);
-    standalone_thread = std::thread(
-      [this]() {
-        executor.spin();
-      });
-  }
-
-  void TearDown()
-  {
-    node.reset();
-
-    // Clean up thread object
-    if (standalone_thread.joinable()) {
-      standalone_thread.join();
-    }
-  }
-
-  std::shared_ptr<TimerNode> node;
-  std::shared_ptr<ClockPublisher> sim_clock_node;
-  rclcpp::SyncParametersClient::SharedPtr param_client;
-  std::thread standalone_thread;
-  T executor;
-};
-
-using MainExecutorTypes =
-  ::testing::Types<
-  rclcpp::executors::SingleThreadedExecutor,
-  rclcpp::executors::MultiThreadedExecutor,
-  rclcpp::executors::StaticSingleThreadedExecutor>;
-
-// TODO(@fujitatomoya): this test excludes EventExecutor because it does not
-// support simulation time used for this test to relax the racy condition.
-// See more details for https://github.com/ros2/rclcpp/issues/2457.
-TYPED_TEST_SUITE(TestTimerCancelBehavior, MainExecutorTypes, ExecutorTypeNames);
-
-TYPED_TEST(TestTimerCancelBehavior, testTimer1CancelledWithExecutorSpin) {
-  // Validate that cancelling one timer yields no change in behavior for other
-  // timers. Specifically, this tests the behavior when using spin() to run the
-  // executor, which is the most common usecase.
-
-  // Cancel to stop the spin after some time.
-  this->sim_clock_node->sleep_for(50ms);
-  this->node->CancelTimer1();
-  this->sim_clock_node->sleep_for(150ms);
-  this->executor.cancel();
-
-  int t1_runs = this->node->GetTimer1Cnt();
-  int t2_runs = this->node->GetTimer2Cnt();
-  EXPECT_NE(t1_runs, t2_runs);
-  // Check that t2 has significantly more calls
-  EXPECT_LT(t1_runs + 50, t2_runs);
-}
-
-TYPED_TEST(TestTimerCancelBehavior, testTimer2CancelledWithExecutorSpin) {
-  // Validate that cancelling one timer yields no change in behavior for other
-  // timers. Specifically, this tests the behavior when using spin() to run the
-  // executor, which is the most common usecase.
-
-  // Cancel to stop the spin after some time.
-  this->sim_clock_node->sleep_for(50ms);
-  this->node->CancelTimer2();
-  this->sim_clock_node->sleep_for(150ms);
-  this->executor.cancel();
-
-  int t1_runs = this->node->GetTimer1Cnt();
-  int t2_runs = this->node->GetTimer2Cnt();
-  EXPECT_NE(t1_runs, t2_runs);
-  // Check that t1 has significantly more calls
-  EXPECT_LT(t2_runs + 50, t1_runs);
-}
-
-TYPED_TEST(TestTimerCancelBehavior, testHeadTimerCancelThenResetBehavior) {
-  // Validate that cancelling timer doesn't affect operation of other timers,
-  // and that the cancelled timer starts executing normally once reset manually.
-
-  // Cancel to stop the spin after some time.
-  this->sim_clock_node->sleep_for(50ms);
-  this->node->CancelTimer1();
-  this->sim_clock_node->sleep_for(150ms);
-  int t1_runs_initial = this->node->GetTimer1Cnt();
-  int t2_runs_initial = this->node->GetTimer2Cnt();
-
-  // Manually reset timer 1, then sleep again
-  // Counts should update.
-  this->node->ResetTimer1();
-  this->sim_clock_node->sleep_for(150ms);
-  int t1_runs_final = this->node->GetTimer1Cnt();
-  int t2_runs_final = this->node->GetTimer2Cnt();
-
-  this->executor.cancel();
-
-  // T1 should have been restarted, and execute about 15 additional times.
-  // Check 10 greater than initial, to account for some timing jitter.
-  EXPECT_LT(t1_runs_initial + 50, t1_runs_final);
-
-  EXPECT_LT(t1_runs_initial + 50, t2_runs_initial);
-  // Check that t2 has significantly more calls, and keeps getting called.
-  EXPECT_LT(t2_runs_initial + 50, t2_runs_final);
-}
-
-TYPED_TEST(TestTimerCancelBehavior, testBackTimerCancelThenResetBehavior) {
-  // Validate that cancelling timer doesn't affect operation of other timers,
-  // and that the cancelled timer starts executing normally once reset manually.
-
-  // Cancel to stop the spin after some time.
-  this->sim_clock_node->sleep_for(50ms);
-  this->node->CancelTimer2();
-  this->sim_clock_node->sleep_for(150ms);
-  int t1_runs_initial = this->node->GetTimer1Cnt();
-  int t2_runs_initial = this->node->GetTimer2Cnt();
-
-  // Manually reset timer 1, then sleep again
-  // Counts should update.
-  this->node->ResetTimer2();
-  this->sim_clock_node->sleep_for(150ms);
-  int t1_runs_final = this->node->GetTimer1Cnt();
-  int t2_runs_final = this->node->GetTimer2Cnt();
-
-  this->executor.cancel();
-
-  // T2 should have been restarted, and execute about 15 additional times.
-  // Check 10 greater than initial, to account for some timing jitter.
-  EXPECT_LT(t2_runs_initial + 50, t2_runs_final);
-
-  EXPECT_LT(t2_runs_initial + 50, t1_runs_initial);
-  // Check that t1 has significantly more calls, and keeps getting called.
-  EXPECT_LT(t1_runs_initial + 50, t1_runs_final);
-}
-
-TYPED_TEST(TestTimerCancelBehavior, testBothTimerCancelThenResetT1Behavior) {
-  // Validate behavior from cancelling 2 timers, then only re-enabling one of them.
-  // Ensure that only the reset timer is executed.
-
-  // Cancel to stop the spin after some time.
-  this->sim_clock_node->sleep_for(50ms);
-  this->node->CancelTimer1();
-  this->node->CancelTimer2();
-  this->sim_clock_node->sleep_for(150ms);
-  int t1_runs_initial = this->node->GetTimer1Cnt();
-  int t2_runs_initial = this->node->GetTimer2Cnt();
-
-  // Manually reset timer 1, then sleep again
-  // Counts should update.
-  this->node->ResetTimer1();
-  this->sim_clock_node->sleep_for(150ms);
-  int t1_runs_intermediate = this->node->GetTimer1Cnt();
-  int t2_runs_intermediate = this->node->GetTimer2Cnt();
-
-  this->node->ResetTimer2();
-  this->sim_clock_node->sleep_for(150ms);
-  int t1_runs_final = this->node->GetTimer1Cnt();
-  int t2_runs_final = this->node->GetTimer2Cnt();
-
-  this->executor.cancel();
-
-  // T1 and T2 should have the same initial count.
-  EXPECT_LE(std::abs(t1_runs_initial - t2_runs_initial), 1);
-
-  // Expect that T1 has up to 15 more calls than t2. Add some buffer
-  // to account for jitter.
-  EXPECT_EQ(t2_runs_initial, t2_runs_intermediate);
-  EXPECT_LT(t1_runs_initial + 50, t1_runs_intermediate);
-
-  // Expect that by end of test, both are running properly again.
-  EXPECT_LT(t1_runs_intermediate + 50, t1_runs_final);
-  EXPECT_LT(t2_runs_intermediate + 50, t2_runs_final);
-}
-
-TYPED_TEST(TestTimerCancelBehavior, testBothTimerCancelThenResetT2Behavior) {
-  // Validate behavior from cancelling 2 timers, then only re-enabling one of them.
-  // Ensure that only the reset timer is executed.
-
-  // Cancel to stop the spin after some time.
-  this->sim_clock_node->sleep_for(50ms);
-  this->node->CancelTimer1();
-  this->node->CancelTimer2();
-  this->sim_clock_node->sleep_for(150ms);
-  int t1_runs_initial = this->node->GetTimer1Cnt();
-  int t2_runs_initial = this->node->GetTimer2Cnt();
-
-  // Manually reset timer 1, then sleep again
-  // Counts should update.
-  this->node->ResetTimer2();
-  this->sim_clock_node->sleep_for(150ms);
-  int t1_runs_intermediate = this->node->GetTimer1Cnt();
-  int t2_runs_intermediate = this->node->GetTimer2Cnt();
-
-  this->node->ResetTimer1();
-  this->sim_clock_node->sleep_for(150ms);
-  int t1_runs_final = this->node->GetTimer1Cnt();
-  int t2_runs_final = this->node->GetTimer2Cnt();
-
-  this->executor.cancel();
-
-  // T1 and T2 should have the same initial count.
-  EXPECT_LE(std::abs(t1_runs_initial - t2_runs_initial), 1);
-
-  // Expect that T1 has up to 15 more calls than t2. Add some buffer
-  // to account for jitter.
-  EXPECT_EQ(t1_runs_initial, t1_runs_intermediate);
-  EXPECT_LT(t2_runs_initial + 50, t2_runs_intermediate);
-
-  // Expect that by end of test, both are running properly again.
-  EXPECT_LT(t1_runs_intermediate + 50, t1_runs_final);
-  EXPECT_LT(t2_runs_intermediate + 50, t2_runs_final);
-}