WIP: Reorganize test CMakeLists and add benchmark dir

rclcpp/CHANGELOG.rst

@@ -2,166 +2,6 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-8.0.0 (2021-03-23)
-------------------
-* Guard against integer overflow in duration conversion (`#1584 <https://github.com/ros2/rclcpp/issues/1584>`_)
-* Contributors: Jacob Perron
-
-7.0.1 (2021-03-22)
-------------------
-* get_parameters service should return empty if undeclared parameters are allowed (`#1514 <https://github.com/ros2/rclcpp/issues/1514>`_)
-* Made 'Context::shutdown_reason' function a const function (`#1578 <https://github.com/ros2/rclcpp/issues/1578>`_)
-* Contributors: Tomoya Fujita, suab321321
-
-7.0.0 (2021-03-18)
-------------------
-* Document design decisions that were made for statically typed parameters (`#1568 <https://github.com/ros2/rclcpp/issues/1568>`_)
-* Fix doc typo in CallbackGroup constructor (`#1582 <https://github.com/ros2/rclcpp/issues/1582>`_)
-* Enable qos parameter overrides for the /parameter_events topic  (`#1532 <https://github.com/ros2/rclcpp/issues/1532>`_)
-* Add support for rmw_connextdds (`#1574 <https://github.com/ros2/rclcpp/issues/1574>`_)
-* Remove 'struct' from the rcl_time_jump_t. (`#1577 <https://github.com/ros2/rclcpp/issues/1577>`_)
-* Add tests for declaring statically typed parameters when undeclared parameters are allowed (`#1575 <https://github.com/ros2/rclcpp/issues/1575>`_)
-* Quiet clang memory leak warning on "DoNotOptimize". (`#1571 <https://github.com/ros2/rclcpp/issues/1571>`_)
-* Add ParameterEventsSubscriber class (`#829 <https://github.com/ros2/rclcpp/issues/829>`_)
-* When a parameter change is rejected, the parameters map shouldn't be updated. (`#1567 <https://github.com/ros2/rclcpp/pull/1567>`_)
-* Fix when to throw the NoParameterOverrideProvided exception. (`#1567 <https://github.com/ros2/rclcpp/pull/1567>`_)
-* Fix SEGV caused by order of destruction of Node sub-interfaces (`#1469 <https://github.com/ros2/rclcpp/issues/1469>`_)
-* Fix benchmark test failure introduced in `#1522 <https://github.com/ros2/rclcpp/issues/1522>`_ (`#1564 <https://github.com/ros2/rclcpp/issues/1564>`_)
-* Fix documented example in create_publisher (`#1558 <https://github.com/ros2/rclcpp/issues/1558>`_)
-* Enforce static parameter types (`#1522 <https://github.com/ros2/rclcpp/issues/1522>`_)
-* Allow timers to keep up the intended rate in MultiThreadedExecutor (`#1516 <https://github.com/ros2/rclcpp/issues/1516>`_)
-* Fix UBSAN warnings in any_subscription_callback. (`#1551 <https://github.com/ros2/rclcpp/issues/1551>`_)
-* Fix runtime error: reference binding to null pointer of type (`#1547 <https://github.com/ros2/rclcpp/issues/1547>`_)
-* Contributors: Andrea Sorbini, Chris Lalancette, Colin MacKenzie, Ivan Santiago Paunovic, Jacob Perron, Steven! Ragnarök, bpwilcox, tomoya
-
-6.3.1 (2021-02-08)
-------------------
-* Reference test resources directly from source tree (`#1543 <https://github.com/ros2/rclcpp/issues/1543>`_)
-* clear statistics after window reset (`#1531 <https://github.com/ros2/rclcpp/issues/1531>`_) (`#1535 <https://github.com/ros2/rclcpp/issues/1535>`_)
-* Fix a minor string error in the topic_statistics test. (`#1541 <https://github.com/ros2/rclcpp/issues/1541>`_)
-* Avoid `Resource deadlock avoided` if use intra_process_comms (`#1530 <https://github.com/ros2/rclcpp/issues/1530>`_)
-* Avoid an object copy in parameter_value.cpp. (`#1538 <https://github.com/ros2/rclcpp/issues/1538>`_)
-* Assert that the publisher_list size is 1. (`#1537 <https://github.com/ros2/rclcpp/issues/1537>`_)
-* Don't access objects after they have been std::move (`#1536 <https://github.com/ros2/rclcpp/issues/1536>`_)
-* Update for checking correct variable (`#1534 <https://github.com/ros2/rclcpp/issues/1534>`_)
-* Destroy msg extracted from LoanedMessage. (`#1305 <https://github.com/ros2/rclcpp/issues/1305>`_)
-* Contributors: Chen Lihui, Chris Lalancette, Ivan Santiago Paunovic, Miaofei Mei, Scott K Logan, William Woodall, hsgwa
-
-6.3.0 (2021-01-25)
-------------------
-* Add instrumentation for linking a timer to a node (`#1500 <https://github.com/ros2/rclcpp/issues/1500>`_)
-* Fix error when using IPC with StaticSingleThreadExecutor (`#1520 <https://github.com/ros2/rclcpp/issues/1520>`_)
-* Change to using unique_ptrs for DummyExecutor. (`#1517 <https://github.com/ros2/rclcpp/issues/1517>`_)
-* Allow reconfiguring 'clock' topic qos (`#1512 <https://github.com/ros2/rclcpp/issues/1512>`_)
-* Allow to add/remove nodes thread safely in rclcpp::Executor  (`#1505 <https://github.com/ros2/rclcpp/issues/1505>`_)
-* Call rclcpp::shutdown in test_node for clean shutdown on Windows (`#1515 <https://github.com/ros2/rclcpp/issues/1515>`_)
-* Reapply "Add get_logging_directory method to rclcpp::Logger (`#1509 <https://github.com/ros2/rclcpp/issues/1509>`_)" (`#1513 <https://github.com/ros2/rclcpp/issues/1513>`_)
-* use describe_parameters of parameter client for test (`#1499 <https://github.com/ros2/rclcpp/issues/1499>`_)
-* Revert "Add get_logging_directory method to rclcpp::Logger (`#1509 <https://github.com/ros2/rclcpp/issues/1509>`_)" (`#1511 <https://github.com/ros2/rclcpp/issues/1511>`_)
-* Add get_logging_directory method to rclcpp::Logger (`#1509 <https://github.com/ros2/rclcpp/issues/1509>`_)
-* Contributors: Chris Lalancette, Christophe Bedard, Ivan Santiago Paunovic, eboasson, mauropasse, tomoya
-
-6.2.0 (2021-01-08)
-------------------
-* Better documentation for the QoS class (`#1508 <https://github.com/ros2/rclcpp/issues/1508>`_)
-* Modify excluding callback duration from topic statistics (`#1492 <https://github.com/ros2/rclcpp/issues/1492>`_)
-* Make the test of graph users more robust. (`#1504 <https://github.com/ros2/rclcpp/issues/1504>`_)
-* Make sure to wait for graph change events in test_node_graph. (`#1503 <https://github.com/ros2/rclcpp/issues/1503>`_)
-* add timeout to SyncParametersClient methods (`#1493 <https://github.com/ros2/rclcpp/issues/1493>`_)
-* Fix wrong test expectations (`#1497 <https://github.com/ros2/rclcpp/issues/1497>`_)
-* Update create_publisher/subscription documentation, clarifying when a parameters interface is required (`#1494 <https://github.com/ros2/rclcpp/issues/1494>`_)
-* Fix string literal warnings (`#1442 <https://github.com/ros2/rclcpp/issues/1442>`_)
-* support describe_parameters methods to parameter client. (`#1453 <https://github.com/ros2/rclcpp/issues/1453>`_)
-* Contributors: Audrow Nash, Chris Lalancette, Ivan Santiago Paunovic, Nikolai Morin, hsgwa, tomoya
-
-6.1.0 (2020-12-10)
-------------------
-* Add getters to rclcpp::qos and rclcpp::Policy enum classes (`#1467 <https://github.com/ros2/rclcpp/issues/1467>`_)
-* Change nullptr checks to use ASSERT_TRUE. (`#1486 <https://github.com/ros2/rclcpp/issues/1486>`_)
-* Adjust logic around finding and erasing guard_condition (`#1474 <https://github.com/ros2/rclcpp/issues/1474>`_)
-* Update QDs to QL 1 (`#1477 <https://github.com/ros2/rclcpp/issues/1477>`_)
-* Add performance tests for parameter transport (`#1463 <https://github.com/ros2/rclcpp/issues/1463>`_)
-* Contributors: Chris Lalancette, Ivan Santiago Paunovic, Scott K Logan, Stephen Brawner
-
-6.0.0 (2020-11-18)
-------------------
-* Move ownership of shutdown_guard_condition to executors/graph_listener (`#1404 <https://github.com/ros2/rclcpp/issues/1404>`_)
-* Add options to automatically declare qos parameters when creating a publisher/subscription (`#1465 <https://github.com/ros2/rclcpp/issues/1465>`_)
-* Add `take_data` to `Waitable` and `data` to `AnyExecutable` (`#1241 <https://github.com/ros2/rclcpp/issues/1241>`_)
-* Add benchmarks for node parameters interface (`#1444 <https://github.com/ros2/rclcpp/issues/1444>`_)
-* Remove allocation from executor::remove_node() (`#1448 <https://github.com/ros2/rclcpp/issues/1448>`_)
-* Fix test crashes on CentOS 7 (`#1449 <https://github.com/ros2/rclcpp/issues/1449>`_)
-* Bump rclcpp packages to Quality Level 2 (`#1445 <https://github.com/ros2/rclcpp/issues/1445>`_)
-* Added executor benchmark tests (`#1413 <https://github.com/ros2/rclcpp/issues/1413>`_)
-* Add fully-qualified namespace to WeakCallbackGroupsToNodesMap (`#1435 <https://github.com/ros2/rclcpp/issues/1435>`_)
-* Contributors: Alejandro Hernández Cordero, Audrow Nash, Chris Lalancette, Ivan Santiago Paunovic, Louise Poubel, Scott K Logan, brawner
-
-5.1.0 (2020-11-02)
-------------------
-* Deprecate Duration(rcl_duration_value_t) in favor of static Duration::from_nanoseconds(rcl_duration_value_t) (`#1432 <https://github.com/ros2/rclcpp/issues/1432>`_)
-* Avoid parsing arguments twice in `rclcpp::init_and_remove_ros_arguments` (`#1415 <https://github.com/ros2/rclcpp/issues/1415>`_)
-* Add service and client benchmarks (`#1425 <https://github.com/ros2/rclcpp/issues/1425>`_)
-* Set CMakeLists to only use default rmw for benchmarks (`#1427 <https://github.com/ros2/rclcpp/issues/1427>`_)
-* Update tracetools' QL in rclcpp's QD (`#1428 <https://github.com/ros2/rclcpp/issues/1428>`_)
-* Add missing locking to the rclcpp_action::ServerBase. (`#1421 <https://github.com/ros2/rclcpp/issues/1421>`_)
-* Initial benchmark tests for rclcpp::init/shutdown create/destroy node (`#1411 <https://github.com/ros2/rclcpp/issues/1411>`_)
-* Refactor test CMakeLists in prep for benchmarks (`#1422 <https://github.com/ros2/rclcpp/issues/1422>`_)
-* Add methods in topic and service interface to resolve a name (`#1410 <https://github.com/ros2/rclcpp/issues/1410>`_)
-* Update deprecated gtest macros (`#1370 <https://github.com/ros2/rclcpp/issues/1370>`_)
-* Clear members for StaticExecutorEntitiesCollector to avoid shared_ptr dependency (`#1303 <https://github.com/ros2/rclcpp/issues/1303>`_)
-* Increase test timeouts of slow running tests with rmw_connext_cpp (`#1400 <https://github.com/ros2/rclcpp/issues/1400>`_)
-* Avoid self dependency that not destoryed (`#1301 <https://github.com/ros2/rclcpp/issues/1301>`_)
-* Update maintainers (`#1384 <https://github.com/ros2/rclcpp/issues/1384>`_)
-* Add clock qos to node options (`#1375 <https://github.com/ros2/rclcpp/issues/1375>`_)
-* Fix NodeOptions copy constructor (`#1376 <https://github.com/ros2/rclcpp/issues/1376>`_)
-* Make sure to clean the external client/service handle. (`#1296 <https://github.com/ros2/rclcpp/issues/1296>`_)
-* Increase coverage of WaitSetTemplate (`#1368 <https://github.com/ros2/rclcpp/issues/1368>`_)
-* Increase coverage of guard_condition.cpp to 100% (`#1369 <https://github.com/ros2/rclcpp/issues/1369>`_)
-* Add coverage statement (`#1367 <https://github.com/ros2/rclcpp/issues/1367>`_)
-* Tests for LoanedMessage with mocked loaned message publisher (`#1366 <https://github.com/ros2/rclcpp/issues/1366>`_)
-* Add unit tests for qos and qos_event files (`#1352 <https://github.com/ros2/rclcpp/issues/1352>`_)
-* Finish coverage of publisher API (`#1365 <https://github.com/ros2/rclcpp/issues/1365>`_)
-* Finish API coverage on executors. (`#1364 <https://github.com/ros2/rclcpp/issues/1364>`_)
-* Add test for ParameterService (`#1355 <https://github.com/ros2/rclcpp/issues/1355>`_)
-* Add time API coverage tests (`#1347 <https://github.com/ros2/rclcpp/issues/1347>`_)
-* Add timer coverage tests (`#1363 <https://github.com/ros2/rclcpp/issues/1363>`_)
-* Add in additional tests for parameter_client.cpp coverage.
-* Minor fixes to the parameter_service.cpp file.
-* reset rcl_context shared_ptr after calling rcl_init sucessfully (`#1357 <https://github.com/ros2/rclcpp/issues/1357>`_)
-* Improved test publisher - zero qos history depth value exception (`#1360 <https://github.com/ros2/rclcpp/issues/1360>`_)
-* Covered resolve_use_intra_process (`#1359 <https://github.com/ros2/rclcpp/issues/1359>`_)
-* Improve test_subscription_options (`#1358 <https://github.com/ros2/rclcpp/issues/1358>`_)
-* Add in more tests for init_options coverage. (`#1353 <https://github.com/ros2/rclcpp/issues/1353>`_)
-* Test the remaining node public API (`#1342 <https://github.com/ros2/rclcpp/issues/1342>`_)
-* Complete coverage of Parameter and ParameterValue API (`#1344 <https://github.com/ros2/rclcpp/issues/1344>`_)
-* Add in more tests for the utilities. (`#1349 <https://github.com/ros2/rclcpp/issues/1349>`_)
-* Add in two more tests for expand_topic_or_service_name. (`#1350 <https://github.com/ros2/rclcpp/issues/1350>`_)
-* Add tests for node_options API (`#1343 <https://github.com/ros2/rclcpp/issues/1343>`_)
-* Add in more coverage for expand_topic_or_service_name. (`#1346 <https://github.com/ros2/rclcpp/issues/1346>`_)
-* Test exception in spin_until_future_complete. (`#1345 <https://github.com/ros2/rclcpp/issues/1345>`_)
-* Add coverage tests graph_listener (`#1330 <https://github.com/ros2/rclcpp/issues/1330>`_)
-* Add in unit tests for the Executor class.
-* Allow mimick patching of methods with up to 9 arguments.
-* Improve the error messages in the Executor class.
-* Add coverage for client API (`#1329 <https://github.com/ros2/rclcpp/issues/1329>`_)
-* Increase service coverage (`#1332 <https://github.com/ros2/rclcpp/issues/1332>`_)
-* Make more of the static entity collector API private.
-* Const-ify more of the static executor.
-* Add more tests for the static single threaded executor.
-* Many more tests for the static_executor_entities_collector.
-* Get one more line of code coverage in memory_strategy.cpp
-* Bugfix when adding callback group.
-* Fix typos in comments.
-* Remove deprecated executor::FutureReturnCode APIs. (`#1327 <https://github.com/ros2/rclcpp/issues/1327>`_)
-* Increase coverage of publisher/subscription API (`#1325 <https://github.com/ros2/rclcpp/issues/1325>`_)
-* Not finalize guard condition while destructing SubscriptionIntraProcess (`#1307 <https://github.com/ros2/rclcpp/issues/1307>`_)
-* Expose qos setting for /rosout (`#1247 <https://github.com/ros2/rclcpp/issues/1247>`_)
-* Add coverage for missing API (except executors) (`#1326 <https://github.com/ros2/rclcpp/issues/1326>`_)
-* Include topic name in QoS mismatch warning messages (`#1286 <https://github.com/ros2/rclcpp/issues/1286>`_)
-* Add coverage tests context functions (`#1321 <https://github.com/ros2/rclcpp/issues/1321>`_)
-* Increase coverage of node_interfaces, including with mocking rcl errors (`#1322 <https://github.com/ros2/rclcpp/issues/1322>`_)
-* Contributors: Ada-King, Alejandro Hernández Cordero, Audrow Nash, Barry Xu, Chen Lihui, Chris Lalancette, Christophe Bedard, Ivan Santiago Paunovic, Jorge Perez, Morgan Quigley, brawner
-
 5.0.0 (2020-09-18)
 ------------------
 * Make node_graph::count_graph_users() const (`#1320 <https://github.com/ros2/rclcpp/issues/1320>`_)

rclcpp/CMakeLists.txt

@@ -39,8 +39,6 @@ set(${PROJECT_NAME}_SRCS
   src/rclcpp/clock.cpp
   src/rclcpp/context.cpp
   src/rclcpp/contexts/default_context.cpp
-  src/rclcpp/detail/mutex_two_priorities.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
   src/rclcpp/detail/rmw_implementation_specific_subscription_payload.cpp
@@ -81,14 +79,12 @@ set(${PROJECT_NAME}_SRCS
   src/rclcpp/parameter.cpp
   src/rclcpp/parameter_value.cpp
   src/rclcpp/parameter_client.cpp
-  src/rclcpp/parameter_event_handler.cpp
   src/rclcpp/parameter_events_filter.cpp
   src/rclcpp/parameter_map.cpp
   src/rclcpp/parameter_service.cpp
   src/rclcpp/publisher_base.cpp
   src/rclcpp/qos.cpp
   src/rclcpp/qos_event.cpp
-  src/rclcpp/qos_overriding_options.cpp
   src/rclcpp/serialization.cpp
   src/rclcpp/serialized_message.cpp
   src/rclcpp/service.cpp
@@ -226,6 +222,12 @@ if(BUILD_TESTING)
   find_package(ament_lint_auto REQUIRED)
   ament_lint_auto_find_test_dependencies()
 
+  # For benchmark tests. Currently there is a bug where these targets can't be
+  # found if these calls are added to the CMakeLists.txt in test/rclcpp/benchmark
+  find_package(benchmark REQUIRED)
+  find_package(osrf_testing_tools_cpp REQUIRED)
+  find_package(performance_test_fixture REQUIRED)
+
   add_subdirectory(test)
 endif()
 

rclcpp/QUALITY_DECLARATION.md

@@ -2,7 +2,7 @@ This document is a declaration of software quality for the `rclcpp` package, bas
 
 # rclcpp Quality Declaration
 
-The package `rclcpp` claims to be in the **Quality Level 1** category when it is used with a **Quality Level 1** middleware.
+The package `rclcpp` claims to be in the **Quality Level 3** category.
 
 Below are the rationales, notes, and caveats for this claim, organized by each requirement listed in the [Package Quality Categories in REP-2004](https://index.ros.org/doc/ros2/Contributing/Developer-Guide/#package-quality-categories) of the ROS2 developer guide.
 
@@ -82,13 +82,13 @@ The API is publicly available in its [ROS 2 API documentation](http://docs.ros2.
 
 The license for `rclcpp` is Apache 2.0, and a summary is in each source file, the type is declared in the [`package.xml`](./package.xml) manifest file, and a full copy of the license is in the [`LICENSE`](../LICENSE) file.
 
-There is an automated test which runs a linter that ensures each file has a license statement. [Here](http://build.ros2.org/view/Rpr/job/Rpr__rclcpp__ubuntu_focal_amd64/lastCompletedBuild/testReport/rclcpp/) can be found a list with the latest results of the various linters being run on the package.
+There is an automated test which runs a linter that ensures each file has a license statement. [Here](http://build.ros2.org/view/Fpr/job/Fpr__rclcpp__ubuntu_focal_amd64/lastSuccessfulBuild/testReport/rclcpp/) can be found a list with the latest results of the various linters being run on the package.
 
 ### Copyright Statements [3.iv]
 
 The copyright holders each provide a statement of copyright in each source code file in `rclcpp`.
 
-There is an automated test which runs a linter that ensures each file has at least one copyright statement. Latest linter result report can be seen [here](http://build.ros2.org/view/Rpr/job/Rpr__rclcpp__ubuntu_focal_amd64/lastCompletedBuild/testReport/rclcpp/copyright/).
+There is an automated test which runs a linter that ensures each file has at least one copyright statement. Latest linter result report can be seen [here](http://build.ros2.org/view/Fpr/job/Fpr__rclcpp__ubuntu_focal_amd64/lastSuccessfulBuild/testReport/rclcpp/copyright/).
 
 ## Testing [4]
 
@@ -121,21 +121,13 @@ This includes:
 
 Changes are required to make a best effort to keep or increase coverage before being accepted, but decreases are allowed if properly justified and accepted by reviewers.
 
-Current coverage statistics can be viewed [here](https://ci.ros2.org/job/nightly_linux_coverage/lastCompletedBuild/cobertura/src_ros2_rclcpp_rclcpp_src_rclcpp/). A description of how coverage statistics are calculated is summarized in this page ["ROS 2 Onboarding Guide"](https://index.ros.org/doc/ros2/Contributing/ROS-2-On-boarding-Guide/#note-on-coverage-runs).
+Current coverage statistics can be viewed [here](https://ci.ros2.org/job/nightly_linux_coverage/lastSuccessfulBuild/cobertura/src_ros2_rclcpp_rclcpp_src_rclcpp/). A description of how coverage statistics are calculated is summarized in this page ["ROS 2 Onboarding Guide"](https://index.ros.org/doc/ros2/Contributing/ROS-2-On-boarding-Guide/#note-on-coverage-runs).
 
 `rclcpp` has a line coverage `>= 95%`, which is calculated over all directories within `rclcpp` with the exception of the `experimental` directory.
 
 ### Performance [4.iv]
 
-`rclcpp` follows the recommendations for performance testing of C/C++ code in the [ROS 2 Developer Guide](https://index.ros.org/doc/ros2/Contributing/Developer-Guide/#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/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/)
-* [Performance](http://build.ros2.org/view/Rci/job/Rci__nightly-performance_ubuntu_focal_amd64/lastCompletedBuild/)
-
-Changes that introduce regressions in performance must be adequately justified in order to be accepted and merged.
+It is not yet defined if this package requires performance testing and how addresses this topic.
 
 ### Linters and Static Analysis [4.v]
 
@@ -163,49 +155,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/master/QUALITY_DECLARATION.md).
+It is **Quality Level 3**, 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/master/rcl/QUALITY_DECLARATION.md).
+It is **Quality Level 3**, 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/master/rcl_yaml_param_parser/QUALITY_DECLARATION.md).
+It is **Quality Level 3**, 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/master/QUALITY_DECLARATION.md).
+It is **Quality Level 2**, 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/master/QUALITY_DECLARATION.md).
+It is **Quality Level 2**, 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/master/rmw/QUALITY_DECLARATION.md).
+It is **Quality Level 2**, 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/master/statistics_msgs/QUALITY_DECLARATION.md).
+It is **Quality Level 3**, 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://gitlab.com/ros-tracing/ros2_tracing/-/blob/master/tracetools/QUALITY_DECLARATION.md).
+It is **Quality Level 2**, see its [Quality Declaration document](https://gitlab.com/micro-ROS/ros_tracing/ros2_tracing/-/blob/master/tracetools/QUALITY_DECLARATION.md).
 
 ### Direct Runtime non-ROS Dependency [5.iii]
 

rclcpp/README.md

@@ -6,4 +6,4 @@ Visit the [rclcpp API documentation](http://docs.ros2.org/latest/api/rclcpp/) fo
 
 ## Quality Declaration
 
-This package claims to be in the **Quality Level 1** category, see the [Quality Declaration](QUALITY_DECLARATION.md) for more details.
+This package claims to be in the **Quality Level 3** category, see the [Quality Declaration](QUALITY_DECLARATION.md) for more details.

rclcpp/doc/notes_on_statically_typed_parameters.md

@@ -1,141 +0,0 @@
-# Notes on statically typed parameters
-
-## Introduction
-
-Until ROS 2 Foxy, all parameters could change type anytime, except if the user installed a parameter callback to reject a change.
-This could generate confusing errors, for example:
-
-```
-$ ros2 run demo_nodes_py listener &
-$ ros2 param set /listener use_sim_time not_a_boolean
-[ERROR] [1614712713.233733147] [listener]: use_sim_time parameter set to something besides a bool
-Set parameter successful
-$ ros2 param get /listener use_sim_time
-String value is: not_a_boolean
-```
-
-For most use cases, having static parameter types is enough.
-This article documents some of the decisions that were made when implementing static parameter types enforcement in:
-
-* https://github.com/ros2/rclcpp/pull/1522
-* https://github.com/ros2/rclpy/pull/683
-
-## Allowing dynamically typed parameters
-
-There might be some scenarios where dynamic typing is desired, so a `dynamic_typing` field was added to the [parameter descriptor](https://github.com/ros2/rcl_interfaces/blob/09b5ed93a733adb9deddc47f9a4a8c6e9f584667/rcl_interfaces/msg/ParameterDescriptor.msg#L25).
-It defaults to `false`.
-
-For example:
-
-```cpp
-rcl_interfaces::msg::ParameterDescriptor descriptor;
-descriptor.dynamic_typing = true;
-
-node->declare_parameter("dynamically_typed_parameter", rclcpp::ParameterValue{}, descriptor);
-```
-
-```py
-rcl_interfaces.msg.ParameterDescriptor descriptor;
-descriptor.dynamic_typing = True;
-
-node.declare_parameter("dynamically_typed_parameter", None, descriptor);
-```
-
-## How is the parameter type specified?
-
-The parameter type will be inferred from the default value provided when declaring it.
-
-## Statically typed parameters when allowing undeclared parameters
-
-When undeclared parameters are allowed and a parameter is set without a previous declaration, the parameter will be dynamically typed.
-This is consistent with other allowed behaviors when undeclared parameters are allowed, e.g. trying to get an undeclared parameter returns "NOT_SET".
-Parameter declarations will remain special and dynamic or static typing will be used based on the parameter descriptor (default to static).
-
-## Declaring a parameter without a default value
-
-There might be cases were a default value does not make sense and the user must always provide an override.
-In those cases, the parameter type can be specified explicitly:
-
-```cpp
-// method signature
-template<typename T>
-Node::declare_parameter<T>(std::string name, rcl_interfaces::msg::ParameterDescriptor = rcl_interfaces::msg::ParameterDescriptor{});
-// or alternatively
-Node::declare_parameter(std::string name, rclcpp::ParameterType type, rcl_interfaces::msg::ParameterDescriptor = rcl_interfaces::msg::ParameterDescriptor{});
-
-// examples
-node->declare_parameter<int64_t>("my_integer_parameter");  // declare an integer parameter
-node->declare_parameter("another_integer_parameter", rclcpp::ParameterType::PARAMETER_INTEGER);  // another way to do the same
-```
-
-```py
-# method signature
-Node.declare_parameter(name: str, param_type: rclpy.Parameter.Type, descriptor: rcl_interfaces.msg.ParameterDescriptor = rcl_interfaces.msg.ParameterDescriptor())
-
-# example
-node.declare_parameter('my_integer_parameter', rclpy.Parameter.Type.INTEGER);  # declare an integer parameter
-```
-
-If the parameter may be unused, but when used requires a parameter override, then you could conditionally declare it:
-
-```cpp
-auto mode = node->declare_parameter("mode", "modeA");  // "mode" parameter is an string
-if (mode == "modeB") {
-    node->declare_parameter<int64_t>("param_needed_when_mode_b");  // when "modeB", the user must provide "param_needed_when_mode_b"
-}
-```
-
-## Other migration notes
-
-Declaring a parameter with only a name is deprecated:
-
-```cpp
-node->declare_parameter("my_param");  // this generates a build warning
-```
-
-```py
-node.declare_parameter("my_param");  # this generates a python user warning
-```
-
-Before, you could initialize a parameter with the "NOT SET" value (in cpp `rclcpp::ParameterValue{}`, in python `None`).
-Now this will throw an exception in both cases:
-
-```cpp
-node->declare_parameter("my_param", rclcpp::ParameterValue{});  // not valid, will throw exception
-```
-
-```py
-node.declare_parameter("my_param", None);  # not valid, will raise error
-```
-
-## Possible improvements
-
-### Easier way to declare dynamically typed parameters
-
-Declaring a dynamically typed parameter in `rclcpp` could be considered to be a bit verbose:
-
-```cpp
-rcl_interfaces::msg::ParameterDescriptor descriptor;
-descriptor.dynamic_typing = true;
-
-node->declare_parameter(name, rclcpp::ParameterValue{}, descriptor);
-```
-
-the following ways could be supported to make it simpler:
-
-```cpp
-node->declare_parameter(name, rclcpp::PARAMETER_DYNAMIC);
-node->declare_parameter(name, default_value, rclcpp::PARAMETER_DYNAMIC);
-```
-
-or alternatively:
-
-```cpp
-node->declare_parameter(name, default_value, rclcpp::ParameterDescriptor{}.dynamic_typing());
-```
-
-For `rclpy`, there's already a short way to do it:
-
-```py
-node.declare_parameter(name, default_value, rclpy.ParameterDescriptor(dynamic_typing=true));
-```

rclcpp/include/rclcpp/any_executable.hpp

@@ -47,7 +47,6 @@ struct AnyExecutable
   // These are used to keep the scope on the containing items
   rclcpp::CallbackGroup::SharedPtr callback_group;
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base;
-  std::shared_ptr<void> data;
 };
 
 namespace executor

rclcpp/include/rclcpp/any_subscription_callback.hpp

@@ -65,9 +65,6 @@ public:
     const_shared_ptr_callback_(nullptr), const_shared_ptr_with_info_callback_(nullptr),
     unique_ptr_callback_(nullptr), unique_ptr_with_info_callback_(nullptr)
   {
-    if (allocator == nullptr) {
-      throw std::runtime_error("invalid allocator");
-    }
     message_allocator_ = std::make_shared<MessageAlloc>(*allocator.get());
     allocator::set_allocator_for_deleter(&message_deleter_, message_allocator_.get());
   }

rclcpp/include/rclcpp/callback_group.hpp

@@ -85,8 +85,8 @@ public:
    * group, or after, is irrelevant; the callback group will be automatically
    * added to the executor in either case.
    *
-   * \param[in] group_type The type of the callback group.
-   * \param[in] automatically_add_to_executor_with_node A boolean that
+   * \param[in] group_type They type of the callback group.
+   * \param[in] automatically_add_to_executor_with_node a boolean which
    *   determines whether a callback group is automatically added to an executor
    *   with the node with which it is associated.
    */

rclcpp/include/rclcpp/clock.hpp

@@ -136,7 +136,7 @@ private:
   RCLCPP_PUBLIC
   static void
   on_time_jump(
-    const rcl_time_jump_t * time_jump,
+    const struct rcl_time_jump_t * time_jump,
     bool before_jump,
     void * user_data);
 

rclcpp/include/rclcpp/context.hpp

@@ -150,7 +150,7 @@ public:
    */
   RCLCPP_PUBLIC
   std::string
-  shutdown_reason() const;
+  shutdown_reason();
 
   /// Shutdown the context, making it uninitialized and therefore invalid for derived entities.
   /**
@@ -248,6 +248,67 @@ public:
   void
   interrupt_all_sleep_for();
 
+  /// Get a handle to the guard condition which is triggered when interrupted.
+  /**
+   * This guard condition is triggered any time interrupt_all_wait_sets() is
+   * called, which may be called by the user, or shutdown().
+   * And in turn, shutdown() may be called by the user, the destructor of this
+   * context, or the signal handler if installed and shutdown_on_sigint is true
+   * for this context.
+   *
+   * The first time that this function is called for a given wait set a new guard
+   * condition will be created and returned; thereafter the same guard condition
+   * will be returned for the same wait set.
+   * This mechanism is designed to ensure that the same guard condition is not
+   * reused across wait sets (e.g., when using multiple executors in the same
+   * process).
+   * This method will throw an exception if initialization of the guard
+   * condition fails.
+   *
+   * The returned guard condition needs to be released with the
+   * release_interrupt_guard_condition() method in order to reclaim resources.
+   *
+   * \param[in] wait_set Pointer to the rcl_wait_set_t that will be using the
+   *   resulting guard condition.
+   * \return Pointer to the guard condition.
+   * \throws anything rclcpp::exceptions::throw_from_rcl_error can throw.
+   */
+  RCLCPP_PUBLIC
+  rcl_guard_condition_t *
+  get_interrupt_guard_condition(rcl_wait_set_t * wait_set);
+
+  /// Release the previously allocated guard condition which is triggered when interrupted.
+  /**
+   * If you previously called get_interrupt_guard_condition() for a given wait
+   * set to get a interrupt guard condition, then you should call
+   * release_interrupt_guard_condition() when you're done, to free that
+   * condition.
+   * Will throw an exception if get_interrupt_guard_condition() wasn't
+   * previously called for the given wait set.
+   *
+   * After calling this, the pointer returned by get_interrupt_guard_condition()
+   * for the given wait_set is invalid.
+   *
+   * \param[in] wait_set Pointer to the rcl_wait_set_t that was using the
+   *   resulting guard condition.
+   * \throws anything rclcpp::exceptions::throw_from_rcl_error can throw.
+   * \throws std::runtime_error if a nonexistent wait set is trying to release sigint guard condition.
+   */
+  RCLCPP_PUBLIC
+  void
+  release_interrupt_guard_condition(rcl_wait_set_t * wait_set);
+
+  /// Nothrow version of release_interrupt_guard_condition(), logs to RCLCPP_ERROR instead.
+  RCLCPP_PUBLIC
+  void
+  release_interrupt_guard_condition(rcl_wait_set_t * wait_set, const std::nothrow_t &) noexcept;
+
+  /// Interrupt any blocking executors, or wait sets associated with this context.
+  RCLCPP_PUBLIC
+  virtual
+  void
+  interrupt_all_wait_sets();
+
   /// Return a singleton instance for the SubContext type, constructing one if necessary.
   template<typename SubContext, typename ... Args>
   std::shared_ptr<SubContext>
@@ -286,7 +347,7 @@ private:
 
   // This mutex is recursive so that the destructor can ensure atomicity
   // between is_initialized and shutdown.
-  mutable std::recursive_mutex init_mutex_;
+  std::recursive_mutex init_mutex_;
   std::shared_ptr<rcl_context_t> rcl_context_;
   rclcpp::InitOptions init_options_;
   std::string shutdown_reason_;
@@ -307,6 +368,11 @@ private:
   /// Mutex for protecting the global condition variable.
   std::mutex interrupt_mutex_;
 
+  /// Mutex to protect sigint_guard_cond_handles_.
+  std::mutex interrupt_guard_cond_handles_mutex_;
+  /// Guard conditions for interrupting of associated wait sets on interrupt_all_wait_sets().
+  std::unordered_map<rcl_wait_set_t *, rcl_guard_condition_t> interrupt_guard_cond_handles_;
+
   /// Keep shared ownership of global vector of weak contexts
   std::shared_ptr<WeakContextsWrapper> weak_contexts_;
 };

rclcpp/include/rclcpp/create_publisher.hpp

@@ -17,7 +17,6 @@
 
 #include <memory>
 #include <string>
-#include <utility>
 
 #include "rclcpp/node_interfaces/get_node_topics_interface.hpp"
 #include "rclcpp/node_interfaces/node_topics_interface.hpp"
@@ -25,65 +24,15 @@
 #include "rclcpp/publisher_factory.hpp"
 #include "rclcpp/publisher_options.hpp"
 #include "rclcpp/qos.hpp"
-#include "rclcpp/qos_overriding_options.hpp"
-#include "rclcpp/detail/qos_parameters.hpp"
-
 #include "rmw/qos_profiles.h"
 
 namespace rclcpp
 {
 
-namespace detail
-{
-/// Create and return a publisher of the given MessageT type.
-template<
-  typename MessageT,
-  typename AllocatorT = std::allocator<void>,
-  typename PublisherT = rclcpp::Publisher<MessageT, AllocatorT>,
-  typename NodeParametersT,
-  typename NodeTopicsT>
-std::shared_ptr<PublisherT>
-create_publisher(
-  NodeParametersT & node_parameters,
-  NodeTopicsT & node_topics,
-  const std::string & topic_name,
-  const rclcpp::QoS & qos,
-  const rclcpp::PublisherOptionsWithAllocator<AllocatorT> & options = (
-    rclcpp::PublisherOptionsWithAllocator<AllocatorT>()
-  )
-)
-{
-  auto node_topics_interface = rclcpp::node_interfaces::get_node_topics_interface(node_topics);
-  const rclcpp::QoS & actual_qos = options.qos_overriding_options.get_policy_kinds().size() ?
-    rclcpp::detail::declare_qos_parameters(
-    options.qos_overriding_options, node_parameters,
-    node_topics_interface->resolve_topic_name(topic_name),
-    qos, rclcpp::detail::PublisherQosParametersTraits{}) :
-    qos;
-
-  // Create the publisher.
-  auto pub = node_topics_interface->create_publisher(
-    topic_name,
-    rclcpp::create_publisher_factory<MessageT, AllocatorT, PublisherT>(options),
-    actual_qos
-  );
-
-  // Add the publisher to the node topics interface.
-  node_topics_interface->add_publisher(pub, options.callback_group);
-
-  return std::dynamic_pointer_cast<PublisherT>(pub);
-}
-}  // namespace detail
-
-
 /// Create and return a publisher of the given MessageT type.
 /**
  * The NodeT type only needs to have a method called get_node_topics_interface()
  * which returns a shared_ptr to a NodeTopicsInterface.
- *
- * In case `options.qos_overriding_options` is enabling qos parameter overrides,
- * NodeT must also have a method called get_node_parameters_interface()
- * which returns a shared_ptr to a NodeParametersInterface.
  */
 template<
   typename MessageT,
@@ -100,28 +49,21 @@ create_publisher(
   )
 )
 {
-  return detail::create_publisher<MessageT, AllocatorT, PublisherT>(
-    node, node, topic_name, qos, options);
-}
+  // Extract the NodeTopicsInterface from the NodeT.
+  using rclcpp::node_interfaces::get_node_topics_interface;
+  auto node_topics = get_node_topics_interface(node);
 
-/// Create and return a publisher of the given MessageT type.
-template<
-  typename MessageT,
-  typename AllocatorT = std::allocator<void>,
-  typename PublisherT = rclcpp::Publisher<MessageT, AllocatorT>>
-std::shared_ptr<PublisherT>
-create_publisher(
-  rclcpp::node_interfaces::NodeParametersInterface::SharedPtr & node_parameters,
-  rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr & node_topics,
-  const std::string & topic_name,
-  const rclcpp::QoS & qos,
-  const rclcpp::PublisherOptionsWithAllocator<AllocatorT> & options = (
-    rclcpp::PublisherOptionsWithAllocator<AllocatorT>()
-  )
-)
-{
-  return detail::create_publisher<MessageT, AllocatorT, PublisherT>(
-    node_parameters, node_topics, topic_name, qos, options);
+  // Create the publisher.
+  auto pub = node_topics->create_publisher(
+    topic_name,
+    rclcpp::create_publisher_factory<MessageT, AllocatorT, PublisherT>(options),
+    qos
+  );
+
+  // Add the publisher to the node topics interface.
+  node_topics->add_publisher(pub, options.callback_group);
+
+  return std::dynamic_pointer_cast<PublisherT>(pub);
 }
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/create_subscription.hpp

@@ -41,115 +41,12 @@
 namespace rclcpp
 {
 
-namespace detail
-{
-template<
-  typename MessageT,
-  typename CallbackT,
-  typename AllocatorT,
-  typename CallbackMessageT,
-  typename SubscriptionT,
-  typename MessageMemoryStrategyT,
-  typename NodeParametersT,
-  typename NodeTopicsT>
-typename std::shared_ptr<SubscriptionT>
-create_subscription(
-  NodeParametersT & node_parameters,
-  NodeTopicsT & node_topics,
-  const std::string & topic_name,
-  const rclcpp::QoS & qos,
-  CallbackT && callback,
-  const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options = (
-    rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()
-  ),
-  typename MessageMemoryStrategyT::SharedPtr msg_mem_strat = (
-    MessageMemoryStrategyT::create_default()
-  )
-)
-{
-  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<CallbackMessageT>>
-  subscription_topic_stats = nullptr;
-
-  if (rclcpp::detail::resolve_enable_topic_statistics(
-      options,
-      *node_topics_interface->get_node_base_interface()))
-  {
-    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::shared_ptr<Publisher<statistics_msgs::msg::MetricsMessage>>
-    publisher = rclcpp::detail::create_publisher<statistics_msgs::msg::MetricsMessage>(
-      node_parameters,
-      node_topics_interface,
-      options.topic_stats_options.publish_topic,
-      qos);
-
-    subscription_topic_stats = std::make_shared<
-      rclcpp::topic_statistics::SubscriptionTopicStatistics<CallbackMessageT>
-      >(node_topics_interface->get_node_base_interface()->get_name(), publisher);
-
-    std::weak_ptr<
-      rclcpp::topic_statistics::SubscriptionTopicStatistics<CallbackMessageT>
-    > weak_subscription_topic_stats(subscription_topic_stats);
-    auto sub_call_back = [weak_subscription_topic_stats]() {
-        auto subscription_topic_stats = weak_subscription_topic_stats.lock();
-        if (subscription_topic_stats) {
-          subscription_topic_stats->publish_message_and_reset_measurements();
-        }
-      };
-
-    auto node_timer_interface = node_topics_interface->get_node_timers_interface();
-
-    auto timer = create_wall_timer(
-      std::chrono::duration_cast<std::chrono::nanoseconds>(
-        options.topic_stats_options.publish_period),
-      sub_call_back,
-      options.callback_group,
-      node_topics_interface->get_node_base_interface(),
-      node_timer_interface
-    );
-
-    subscription_topic_stats->set_publisher_timer(timer);
-  }
-
-  auto factory = rclcpp::create_subscription_factory<MessageT>(
-    std::forward<CallbackT>(callback),
-    options,
-    msg_mem_strat,
-    subscription_topic_stats
-  );
-
-  const rclcpp::QoS & actual_qos = options.qos_overriding_options.get_policy_kinds().size() ?
-    rclcpp::detail::declare_qos_parameters(
-    options.qos_overriding_options, node_parameters,
-    node_topics_interface->resolve_topic_name(topic_name),
-    qos, rclcpp::detail::SubscriptionQosParametersTraits{}) :
-    qos;
-
-  auto sub = node_topics_interface->create_subscription(topic_name, factory, actual_qos);
-  node_topics_interface->add_subscription(sub, options.callback_group);
-
-  return std::dynamic_pointer_cast<SubscriptionT>(sub);
-}
-}  // namespace detail
-
 /// Create and return a subscription of the given MessageT type.
 /**
  * The NodeT type only needs to have a method called get_node_topics_interface()
  * which returns a shared_ptr to a NodeTopicsInterface, or be a
  * NodeTopicsInterface pointer itself.
  *
- * In case `options.qos_overriding_options` is enabling qos parameter overrides,
- * NodeT must also have a method called get_node_parameters_interface()
- * which returns a shared_ptr to a NodeParametersInterface.
- *
  * \tparam MessageT
  * \tparam CallbackT
  * \tparam AllocatorT
@@ -181,7 +78,7 @@ template<
   typename NodeT>
 typename std::shared_ptr<SubscriptionT>
 create_subscription(
-  NodeT & node,
+  NodeT && node,
   const std::string & topic_name,
   const rclcpp::QoS & qos,
   CallbackT && callback,
@@ -193,45 +90,68 @@ create_subscription(
   )
 )
 {
-  return rclcpp::detail::create_subscription<
-    MessageT, CallbackT, AllocatorT, CallbackMessageT, SubscriptionT, MessageMemoryStrategyT>(
-    node, node, topic_name, qos, std::forward<CallbackT>(callback), options, msg_mem_strat);
-}
+  using rclcpp::node_interfaces::get_node_topics_interface;
+  auto node_topics = get_node_topics_interface(std::forward<NodeT>(node));
 
-/// Create and return a subscription of the given MessageT type.
-/**
- * See \ref create_subscription().
- */
-template<
-  typename MessageT,
-  typename CallbackT,
-  typename AllocatorT = std::allocator<void>,
-  typename CallbackMessageT =
-  typename rclcpp::subscription_traits::has_message_type<CallbackT>::type,
-  typename SubscriptionT = rclcpp::Subscription<CallbackMessageT, AllocatorT>,
-  typename MessageMemoryStrategyT = rclcpp::message_memory_strategy::MessageMemoryStrategy<
-    CallbackMessageT,
-    AllocatorT
-  >>
-typename std::shared_ptr<SubscriptionT>
-create_subscription(
-  rclcpp::node_interfaces::NodeParametersInterface::SharedPtr & node_parameters,
-  rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr & node_topics,
-  const std::string & topic_name,
-  const rclcpp::QoS & qos,
-  CallbackT && callback,
-  const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options = (
-    rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()
-  ),
-  typename MessageMemoryStrategyT::SharedPtr msg_mem_strat = (
-    MessageMemoryStrategyT::create_default()
-  )
-)
-{
-  return rclcpp::detail::create_subscription<
-    MessageT, CallbackT, AllocatorT, CallbackMessageT, SubscriptionT, MessageMemoryStrategyT>(
-    node_parameters, node_topics, topic_name, qos,
-    std::forward<CallbackT>(callback), options, msg_mem_strat);
+  std::shared_ptr<rclcpp::topic_statistics::SubscriptionTopicStatistics<CallbackMessageT>>
+  subscription_topic_stats = nullptr;
+
+  if (rclcpp::detail::resolve_enable_topic_statistics(
+      options,
+      *node_topics->get_node_base_interface()))
+  {
+    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::shared_ptr<Publisher<statistics_msgs::msg::MetricsMessage>> publisher =
+      create_publisher<statistics_msgs::msg::MetricsMessage>(
+      node,
+      options.topic_stats_options.publish_topic,
+      qos);
+
+    subscription_topic_stats = std::make_shared<
+      rclcpp::topic_statistics::SubscriptionTopicStatistics<CallbackMessageT>
+      >(node_topics->get_node_base_interface()->get_name(), publisher);
+
+    std::weak_ptr<
+      rclcpp::topic_statistics::SubscriptionTopicStatistics<CallbackMessageT>
+    > weak_subscription_topic_stats(subscription_topic_stats);
+    auto sub_call_back = [weak_subscription_topic_stats]() {
+        auto subscription_topic_stats = weak_subscription_topic_stats.lock();
+        if (subscription_topic_stats) {
+          subscription_topic_stats->publish_message();
+        }
+      };
+
+    auto node_timer_interface = node_topics->get_node_timers_interface();
+
+    auto timer = create_wall_timer(
+      std::chrono::duration_cast<std::chrono::nanoseconds>(
+        options.topic_stats_options.publish_period),
+      sub_call_back,
+      options.callback_group,
+      node_topics->get_node_base_interface(),
+      node_timer_interface
+    );
+
+    subscription_topic_stats->set_publisher_timer(timer);
+  }
+
+  auto factory = rclcpp::create_subscription_factory<MessageT>(
+    std::forward<CallbackT>(callback),
+    options,
+    msg_mem_strat,
+    subscription_topic_stats
+  );
+
+  auto sub = node_topics->create_subscription(topic_name, factory, qos);
+  node_topics->add_subscription(sub, options.callback_group);
+
+  return std::dynamic_pointer_cast<SubscriptionT>(sub);
 }
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/detail/mutex_two_priorities.hpp

@@ -1,75 +0,0 @@
-// Copyright 2021 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__DETAIL__MUTEX_TWO_PRIORITIES_HPP_
-#define RCLCPP__DETAIL__MUTEX_TWO_PRIORITIES_HPP_
-
-#include <mutex>
-
-namespace rclcpp
-{
-namespace detail
-{
-/// \internal A mutex that has two locking mechanism, one with higher priority than the other.
-/**
- * After the current mutex owner release the lock, a thread that used the high
- * priority mechanism will have priority over threads that used the low priority mechanism.
- */
-class MutexTwoPriorities
-{
-public:
-  class HighPriorityLockable
-  {
-public:
-    explicit HighPriorityLockable(MutexTwoPriorities & parent);
-
-    void lock();
-
-    void unlock();
-
-private:
-    MutexTwoPriorities & parent_;
-  };
-
-  class LowPriorityLockable
-  {
-public:
-    explicit LowPriorityLockable(MutexTwoPriorities & parent);
-
-    void lock();
-
-    void unlock();
-
-private:
-    MutexTwoPriorities & parent_;
-  };
-
-  HighPriorityLockable
-  get_high_priority_lockable();
-
-  LowPriorityLockable
-  get_low_priority_lockable();
-
-private:
-  // Implementation detail: the idea here is that only one low priority thread can be
-  // trying to take the data_ mutex while the others are excluded by the barrier_ mutex.
-  // All high priority threads are already waiting for the data_ mutex.
-  std::mutex barrier_;
-  std::mutex data_;
-};
-
-}  // namespace detail
-}  // namespace rclcpp
-
-#endif  // RCLCPP__DETAIL__MUTEX_TWO_PRIORITIES_HPP_

rclcpp/include/rclcpp/detail/qos_parameters.hpp

@@ -1,326 +0,0 @@
-// Copyright 2020 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__DETAIL__QOS_PARAMETERS_HPP_
-#define RCLCPP__DETAIL__QOS_PARAMETERS_HPP_
-
-#include <algorithm>
-#include <array>
-#include <functional>
-#include <initializer_list>
-#include <map>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#include "rcl_interfaces/msg/parameter_descriptor.hpp"
-#include "rcpputils/pointer_traits.hpp"
-#include "rmw/qos_string_conversions.h"
-
-#include "rclcpp/duration.hpp"
-#include "rclcpp/node_interfaces/get_node_parameters_interface.hpp"
-#include "rclcpp/node_interfaces/node_parameters_interface.hpp"
-#include "rclcpp/qos_overriding_options.hpp"
-
-namespace rclcpp
-{
-namespace detail
-{
-
-/// \internal Trait used to specialize `declare_qos_parameters()` for publishers.
-struct PublisherQosParametersTraits
-{
-  static constexpr const char * entity_type() {return "publisher";}
-  static constexpr auto allowed_policies()
-  {
-    return std::array<::rclcpp::QosPolicyKind, 9> {
-      QosPolicyKind::AvoidRosNamespaceConventions,
-      QosPolicyKind::Deadline,
-      QosPolicyKind::Durability,
-      QosPolicyKind::History,
-      QosPolicyKind::Depth,
-      QosPolicyKind::Lifespan,
-      QosPolicyKind::Liveliness,
-      QosPolicyKind::LivelinessLeaseDuration,
-      QosPolicyKind::Reliability,
-    };
-  }
-};
-
-/// \internal Trait used to specialize `declare_qos_parameters()` for subscriptions.
-struct SubscriptionQosParametersTraits
-{
-  static constexpr const char * entity_type() {return "subscription";}
-  static constexpr auto allowed_policies()
-  {
-    return std::array<::rclcpp::QosPolicyKind, 8> {
-      QosPolicyKind::AvoidRosNamespaceConventions,
-      QosPolicyKind::Deadline,
-      QosPolicyKind::Durability,
-      QosPolicyKind::History,
-      QosPolicyKind::Depth,
-      QosPolicyKind::Liveliness,
-      QosPolicyKind::LivelinessLeaseDuration,
-      QosPolicyKind::Reliability,
-    };
-  }
-};
-
-/// \internal Returns the given `policy` of the profile `qos` converted to a parameter value.
-inline
-::rclcpp::ParameterValue
-get_default_qos_param_value(rclcpp::QosPolicyKind policy, const rclcpp::QoS & qos);
-
-/// \internal Modify the given `policy` in `qos` to be `value`.
-inline
-void
-apply_qos_override(
-  rclcpp::QosPolicyKind policy, rclcpp::ParameterValue value, rclcpp::QoS & qos);
-
-inline
-rclcpp::ParameterValue
-declare_parameter_or_get(
-  rclcpp::node_interfaces::NodeParametersInterface & parameters_interface,
-  const std::string & param_name,
-  rclcpp::ParameterValue param_value,
-  rcl_interfaces::msg::ParameterDescriptor descriptor)
-{
-  try {
-    return parameters_interface.declare_parameter(
-      param_name, param_value, descriptor);
-  } catch (const rclcpp::exceptions::ParameterAlreadyDeclaredException &) {
-    return parameters_interface.get_parameter(param_name).get_parameter_value();
-  }
-}
-
-/// \internal Declare QoS parameters for the given entity.
-/**
- * \tparam NodeT Node pointer or reference type.
- * \tparam EntityQosParametersTraits A class with two static methods: `entity_type()` and
- *  `allowed_policies()`. See `PublisherQosParametersTraits` and `SubscriptionQosParametersTraits`.
- * \param options User provided options that indicate if QoS parameter overrides should be
- *  declared or not, which policy can have overrides, and optionally a callback to validate the profile.
- * \param node Parameters will be declared using this node.
- * \param topic_name Name of the topic of the entity.
- * \param default_qos User provided qos. It will be used as a default for the parameters declared.
- * \return qos profile based on the user provided parameter overrides.
- */
-template<typename NodeT, typename EntityQosParametersTraits>
-std::enable_if_t<
-  rclcpp::node_interfaces::has_node_parameters_interface<
-    decltype(std::declval<typename rcpputils::remove_pointer<NodeT>::type>())>::value ||
-  std::is_same<typename std::decay_t<NodeT>,
-  rclcpp::node_interfaces::NodeParametersInterface::SharedPtr>::value,
-  rclcpp::QoS>
-declare_qos_parameters(
-  const ::rclcpp::QosOverridingOptions & options,
-  NodeT & node,
-  const std::string & topic_name,
-  const ::rclcpp::QoS & default_qos,
-  EntityQosParametersTraits)
-{
-  auto & parameters_interface = *rclcpp::node_interfaces::get_node_parameters_interface(node);
-  std::string param_prefix;
-  const auto & id = options.get_id();
-  {
-    std::ostringstream oss{"qos_overrides.", std::ios::ate};
-    oss << topic_name << "." << EntityQosParametersTraits::entity_type();
-    if (!id.empty()) {
-      oss << "_" << id;
-    }
-    oss << ".";
-    param_prefix = oss.str();
-  }
-  std::string param_description_suffix;
-  {
-    std::ostringstream oss{"} for ", std::ios::ate};
-    oss << EntityQosParametersTraits::entity_type() << " {" << topic_name << "}";
-    if (!id.empty()) {
-      oss << " with id {" << id << "}";
-    }
-    param_description_suffix = oss.str();
-  }
-  rclcpp::QoS qos = default_qos;
-  for (auto policy : EntityQosParametersTraits::allowed_policies()) {
-    if (
-      std::count(options.get_policy_kinds().begin(), options.get_policy_kinds().end(), policy))
-    {
-      std::ostringstream param_name{param_prefix, std::ios::ate};
-      param_name << qos_policy_kind_to_cstr(policy);
-      std::ostringstream param_desciption{"qos policy {", std::ios::ate};
-      param_desciption << qos_policy_kind_to_cstr(policy) << param_description_suffix;
-      rcl_interfaces::msg::ParameterDescriptor descriptor{};
-      descriptor.description = param_desciption.str();
-      descriptor.read_only = true;
-      auto value = declare_parameter_or_get(
-        parameters_interface, param_name.str(),
-        get_default_qos_param_value(policy, qos), descriptor);
-      ::rclcpp::detail::apply_qos_override(policy, value, qos);
-    }
-  }
-  const auto & validation_callback = options.get_validation_callback();
-  if (validation_callback) {
-    auto result = validation_callback(qos);
-    if (!result.successful) {
-      throw rclcpp::exceptions::InvalidQosOverridesException{
-              "validation callback failed: " + result.reason};
-    }
-  }
-  return qos;
-}
-
-// TODO(ivanpauno): This overload cannot declare the QoS parameters, as a node parameters interface
-// was not provided.
-template<typename NodeT, typename EntityQosParametersTraits>
-std::enable_if_t<
-  !(rclcpp::node_interfaces::has_node_parameters_interface<
-    decltype(std::declval<typename rcpputils::remove_pointer<NodeT>::type>())>::value ||
-  std::is_same<typename std::decay_t<NodeT>,
-  rclcpp::node_interfaces::NodeParametersInterface::SharedPtr>::value),
-  rclcpp::QoS>
-declare_qos_parameters(
-  const ::rclcpp::QosOverridingOptions & options,
-  NodeT &,
-  const std::string &,
-  const ::rclcpp::QoS & default_qos,
-  EntityQosParametersTraits)
-{
-  if (options.get_policy_kinds().size()) {
-    std::runtime_error exc{
-      "passed non-default qos overriding options without providing a parameters interface"};
-    throw exc;
-  }
-  return default_qos;
-}
-
-/// \internal Helper function to get a rmw qos policy value from a string.
-#define RCLCPP_DETAIL_APPLY_QOS_OVERRIDE_FROM_PARAMETER_STRING( \
-    kind_lower, kind_upper, parameter_value, rclcpp_qos) \
-  do { \
-    auto policy_string = (parameter_value).get<std::string>(); \
-    auto policy_value = rmw_qos_ ## kind_lower ## _policy_from_str(policy_string.c_str()); \
-    if (RMW_QOS_POLICY_ ## kind_upper ## _UNKNOWN == policy_value) { \
-      throw std::invalid_argument{"unknown QoS policy " #kind_lower " value: " + policy_string}; \
-    } \
-    ((rclcpp_qos).kind_lower)(policy_value); \
-  } while (0)
-
-inline
-void
-apply_qos_override(
-  rclcpp::QosPolicyKind policy, rclcpp::ParameterValue value, rclcpp::QoS & qos)
-{
-  switch (policy) {
-    case QosPolicyKind::AvoidRosNamespaceConventions:
-      qos.avoid_ros_namespace_conventions(value.get<bool>());
-      break;
-    case QosPolicyKind::Deadline:
-      qos.deadline(::rclcpp::Duration::from_nanoseconds(value.get<int64_t>()));
-      break;
-    case QosPolicyKind::Durability:
-      RCLCPP_DETAIL_APPLY_QOS_OVERRIDE_FROM_PARAMETER_STRING(
-        durability, DURABILITY, value, qos);
-      break;
-    case QosPolicyKind::History:
-      RCLCPP_DETAIL_APPLY_QOS_OVERRIDE_FROM_PARAMETER_STRING(
-        history, HISTORY, value, qos);
-      break;
-    case QosPolicyKind::Depth:
-      qos.get_rmw_qos_profile().depth = static_cast<size_t>(value.get<int64_t>());
-      break;
-    case QosPolicyKind::Lifespan:
-      qos.lifespan(::rclcpp::Duration::from_nanoseconds(value.get<int64_t>()));
-      break;
-    case QosPolicyKind::Liveliness:
-      RCLCPP_DETAIL_APPLY_QOS_OVERRIDE_FROM_PARAMETER_STRING(
-        liveliness, LIVELINESS, value, qos);
-      break;
-    case QosPolicyKind::LivelinessLeaseDuration:
-      qos.liveliness_lease_duration(::rclcpp::Duration::from_nanoseconds(value.get<int64_t>()));
-      break;
-    case QosPolicyKind::Reliability:
-      RCLCPP_DETAIL_APPLY_QOS_OVERRIDE_FROM_PARAMETER_STRING(
-        reliability, RELIABILITY, value, qos);
-      break;
-    default:
-      throw std::invalid_argument{"unknown QosPolicyKind"};
-  }
-}
-
-/// Convert `rmw_time_t` to `int64_t` that can be used as a parameter value.
-inline
-int64_t
-rmw_duration_to_int64_t(rmw_time_t rmw_duration)
-{
-  return ::rclcpp::Duration(
-    static_cast<int32_t>(rmw_duration.sec),
-    static_cast<uint32_t>(rmw_duration.nsec)
-  ).nanoseconds();
-}
-
-/// \internal Throw an exception if `policy_value_stringified` is NULL.
-inline
-const char *
-check_if_stringified_policy_is_null(const char * policy_value_stringified, QosPolicyKind kind)
-{
-  if (!policy_value_stringified) {
-    std::ostringstream oss{"unknown value for policy kind {", std::ios::ate};
-    oss << kind << "}";
-    throw std::invalid_argument{oss.str()};
-  }
-  return policy_value_stringified;
-}
-
-inline
-::rclcpp::ParameterValue
-get_default_qos_param_value(rclcpp::QosPolicyKind kind, const rclcpp::QoS & qos)
-{
-  using ParameterValue = ::rclcpp::ParameterValue;
-  const auto & rmw_qos = qos.get_rmw_qos_profile();
-  switch (kind) {
-    case QosPolicyKind::AvoidRosNamespaceConventions:
-      return ParameterValue(rmw_qos.avoid_ros_namespace_conventions);
-    case QosPolicyKind::Deadline:
-      return ParameterValue(rmw_duration_to_int64_t(rmw_qos.deadline));
-    case QosPolicyKind::Durability:
-      return ParameterValue(
-        check_if_stringified_policy_is_null(
-          rmw_qos_durability_policy_to_str(rmw_qos.durability), kind));
-    case QosPolicyKind::History:
-      return ParameterValue(
-        check_if_stringified_policy_is_null(
-          rmw_qos_history_policy_to_str(rmw_qos.history), kind));
-    case QosPolicyKind::Depth:
-      return ParameterValue(static_cast<int64_t>(rmw_qos.depth));
-    case QosPolicyKind::Lifespan:
-      return ParameterValue(rmw_duration_to_int64_t(rmw_qos.lifespan));
-    case QosPolicyKind::Liveliness:
-      return ParameterValue(
-        check_if_stringified_policy_is_null(
-          rmw_qos_liveliness_policy_to_str(rmw_qos.liveliness), kind));
-    case QosPolicyKind::LivelinessLeaseDuration:
-      return ParameterValue(rmw_duration_to_int64_t(rmw_qos.liveliness_lease_duration));
-    case QosPolicyKind::Reliability:
-      return ParameterValue(
-        check_if_stringified_policy_is_null(
-          rmw_qos_reliability_policy_to_str(rmw_qos.reliability), kind));
-    default:
-      throw std::invalid_argument{"unknown QoS policy kind"};
-  }
-}
-
-}  // namespace detail
-}  // namespace rclcpp
-
-#endif  // RCLCPP__DETAIL__QOS_PARAMETERS_HPP_

rclcpp/include/rclcpp/duration.hpp

@@ -38,14 +38,10 @@ public:
    */
   Duration(int32_t seconds, uint32_t nanoseconds);
 
-  /// Construct duration from the specified nanoseconds.
-  [[deprecated(
-    "Use Duration::from_nanoseconds instead or std::chrono_literals. For example:"
-    "rclcpp::Duration::from_nanoseconds(int64_variable);"
-    "rclcpp::Duration(0ns);")]]
+  // This constructor matches any numeric value - ints or floats.
   explicit Duration(rcl_duration_value_t nanoseconds);
 
-  /// Construct duration from the specified std::chrono::nanoseconds.
+  // This constructor matches std::chrono::nanoseconds.
   explicit Duration(std::chrono::nanoseconds nanoseconds);
 
   // This constructor matches any std::chrono value other than nanoseconds
@@ -133,13 +129,6 @@ public:
   static Duration
   from_seconds(double seconds);
 
-  /// Create a duration object from an integer number representing nanoseconds
-  static Duration
-  from_nanoseconds(rcl_duration_value_t nanoseconds);
-
-  static Duration
-  from_rmw_time(rmw_time_t duration);
-
   /// Convert Duration into a std::chrono::Duration.
   template<class DurationT>
   DurationT
@@ -154,8 +143,6 @@ public:
 
 private:
   rcl_duration_t rcl_duration_;
-
-  Duration() = default;
 };
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/exceptions/exceptions.hpp

@@ -282,27 +282,6 @@ class ParameterModifiedInCallbackException : public std::runtime_error
   using std::runtime_error::runtime_error;
 };
 
-/// Thrown when a parameter override wasn't provided and one was required.
-class NoParameterOverrideProvided : public std::runtime_error
-{
-public:
-  /// Construct an instance.
-  /**
-   * \param[in] name the name of the parameter.
-   * \param[in] message custom exception message.
-   */
-  explicit NoParameterOverrideProvided(const std::string & name)
-  : std::runtime_error("parameter '" + name + "' requires an user provided parameter override")
-  {}
-};
-
-/// Thrown if the QoS overrides provided aren't valid.
-class InvalidQosOverridesException : public std::runtime_error
-{
-  // Inherit constructors from runtime_error.
-  using std::runtime_error::runtime_error;
-};
-
 }  // namespace exceptions
 }  // namespace rclcpp
 

rclcpp/include/rclcpp/executor.hpp

@@ -31,7 +31,6 @@
 #include "rcl/wait.h"
 
 #include "rclcpp/contexts/default_context.hpp"
-#include "rclcpp/guard_condition.hpp"
 #include "rclcpp/executor_options.hpp"
 #include "rclcpp/future_return_code.hpp"
 #include "rclcpp/memory_strategies.hpp"
@@ -448,7 +447,7 @@ protected:
   RCLCPP_PUBLIC
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr
   get_node_by_group(
-    const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes,
+    WeakCallbackGroupsToNodesMap weak_groups_to_nodes,
     rclcpp::CallbackGroup::SharedPtr group);
 
   /// Return true if the node has been added to this executor.
@@ -460,7 +459,7 @@ protected:
   bool
   has_node(
     const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
-    const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes) const;
+    WeakCallbackGroupsToNodesMap weak_groups_to_nodes) const;
 
   RCLCPP_PUBLIC
   rclcpp::CallbackGroup::SharedPtr
@@ -476,7 +475,7 @@ protected:
     rclcpp::CallbackGroup::SharedPtr group_ptr,
     rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
     WeakCallbackGroupsToNodesMap & weak_groups_to_nodes,
-    bool notify = true) RCPPUTILS_TSA_REQUIRES(mutex_);
+    bool notify = true);
 
   /// Remove a callback group from the executor.
   /**
@@ -487,7 +486,7 @@ protected:
   remove_callback_group_from_map(
     rclcpp::CallbackGroup::SharedPtr group_ptr,
     WeakCallbackGroupsToNodesMap & weak_groups_to_nodes,
-    bool notify = true) RCPPUTILS_TSA_REQUIRES(mutex_);
+    bool notify = true);
 
   RCLCPP_PUBLIC
   bool
@@ -497,7 +496,7 @@ protected:
   bool
   get_next_ready_executable_from_map(
     AnyExecutable & any_executable,
-    const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes);
+    WeakCallbackGroupsToNodesMap weak_groups_to_nodes);
 
   RCLCPP_PUBLIC
   bool
@@ -518,7 +517,7 @@ protected:
    */
   RCLCPP_PUBLIC
   virtual void
-  add_callback_groups_from_nodes_associated_to_executor() RCPPUTILS_TSA_REQUIRES(mutex_);
+  add_callback_groups_from_nodes_associated_to_executor();
 
   /// Spinning state, used to prevent multi threaded calls to spin and to cancel blocking spins.
   std::atomic_bool spinning;
@@ -526,17 +525,14 @@ protected:
   /// Guard condition for signaling the rmw layer to wake up for special events.
   rcl_guard_condition_t interrupt_guard_condition_ = rcl_get_zero_initialized_guard_condition();
 
-  std::shared_ptr<rclcpp::GuardCondition> shutdown_guard_condition_;
-
   /// Wait set for managing entities that the rmw layer waits on.
   rcl_wait_set_t wait_set_ = rcl_get_zero_initialized_wait_set();
 
   // Mutex to protect the subsequent memory_strategy_.
-  mutable std::mutex mutex_;
+  std::mutex memory_strategy_mutex_;
 
   /// The memory strategy: an interface for handling user-defined memory allocation strategies.
-  memory_strategy::MemoryStrategy::SharedPtr
-  memory_strategy_ RCPPUTILS_TSA_PT_GUARDED_BY(mutex_);
+  memory_strategy::MemoryStrategy::SharedPtr memory_strategy_;
 
   /// The context associated with this executor.
   std::shared_ptr<rclcpp::Context> context_;
@@ -553,24 +549,19 @@ protected:
     WeakNodesToGuardConditionsMap;
 
   /// maps nodes to guard conditions
-  WeakNodesToGuardConditionsMap
-  weak_nodes_to_guard_conditions_ RCPPUTILS_TSA_GUARDED_BY(mutex_);
+  WeakNodesToGuardConditionsMap weak_nodes_to_guard_conditions_;
 
   /// maps callback groups associated to nodes
-  WeakCallbackGroupsToNodesMap
-  weak_groups_associated_with_executor_to_nodes_ RCPPUTILS_TSA_GUARDED_BY(mutex_);
+  WeakCallbackGroupsToNodesMap weak_groups_associated_with_executor_to_nodes_;
 
   /// maps callback groups to nodes associated with executor
-  WeakCallbackGroupsToNodesMap
-  weak_groups_to_nodes_associated_with_executor_ RCPPUTILS_TSA_GUARDED_BY(mutex_);
+  WeakCallbackGroupsToNodesMap weak_groups_to_nodes_associated_with_executor_;
 
   /// maps all callback groups to nodes
-  WeakCallbackGroupsToNodesMap
-  weak_groups_to_nodes_ RCPPUTILS_TSA_GUARDED_BY(mutex_);
+  WeakCallbackGroupsToNodesMap weak_groups_to_nodes_;
 
   /// nodes that are associated with the executor
-  std::list<rclcpp::node_interfaces::NodeBaseInterface::WeakPtr>
-  weak_nodes_ RCPPUTILS_TSA_GUARDED_BY(mutex_);
+  std::list<rclcpp::node_interfaces::NodeBaseInterface::WeakPtr> weak_nodes_;
 };
 
 namespace executor

rclcpp/include/rclcpp/executors/multi_threaded_executor.hpp

@@ -22,7 +22,6 @@
 #include <thread>
 #include <unordered_map>
 
-#include "rclcpp/detail/mutex_two_priorities.hpp"
 #include "rclcpp/executor.hpp"
 #include "rclcpp/macros.hpp"
 #include "rclcpp/memory_strategies.hpp"
@@ -82,7 +81,7 @@ protected:
 private:
   RCLCPP_DISABLE_COPY(MultiThreadedExecutor)
 
-  detail::MutexTwoPriorities wait_mutex_;
+  std::mutex wait_mutex_;
   size_t number_of_threads_;
   bool yield_before_execute_;
   std::chrono::nanoseconds next_exec_timeout_;

rclcpp/include/rclcpp/executors/static_executor_entities_collector.hpp

@@ -72,19 +72,9 @@ public:
   void
   fini();
 
-  /// Execute the waitable.
   RCLCPP_PUBLIC
   void
-  execute(std::shared_ptr<void> & data) override;
-
-  /// Take the data so that it can be consumed with `execute`.
-  /**
-   * For `StaticExecutorEntitiesCollector`, this always return `nullptr`.
-   * \sa rclcpp::Waitable::take_data()
-   */
-  RCLCPP_PUBLIC
-  std::shared_ptr<void>
-  take_data() override;
+  execute() override;
 
   /// Function to add_handles_to_wait_set and wait for work and
   /**

rclcpp/include/rclcpp/experimental/intra_process_manager.hpp

@@ -207,7 +207,7 @@ public:
       sub_ids.take_shared_subscriptions.size() <= 1)
     {
       // There is at maximum 1 buffer that does not require ownership.
-      // So this case is equivalent to all the buffers requiring ownership
+      // So we this case is equivalent to all the buffers requiring ownership
 
       // Merge the two vector of ids into a unique one
       std::vector<uint64_t> concatenated_vector(sub_ids.take_shared_subscriptions);
@@ -307,7 +307,7 @@ private:
   {
     SubscriptionInfo() = default;
 
-    rclcpp::experimental::SubscriptionIntraProcessBase::WeakPtr subscription;
+    rclcpp::experimental::SubscriptionIntraProcessBase::SharedPtr subscription;
     rmw_qos_profile_t qos;
     const char * topic_name;
     bool use_take_shared_method;
@@ -361,16 +361,13 @@ private:
       if (subscription_it == subscriptions_.end()) {
         throw std::runtime_error("subscription has unexpectedly gone out of scope");
       }
-      auto subscription_base = subscription_it->second.subscription.lock();
-      if (subscription_base) {
-        auto subscription = std::static_pointer_cast<
-          rclcpp::experimental::SubscriptionIntraProcess<MessageT>
-          >(subscription_base);
+      auto subscription_base = subscription_it->second.subscription;
 
-        subscription->provide_intra_process_message(message);
-      } else {
-        subscriptions_.erase(id);
-      }
+      auto subscription = std::static_pointer_cast<
+        rclcpp::experimental::SubscriptionIntraProcess<MessageT>
+        >(subscription_base);
+
+      subscription->provide_intra_process_message(message);
     }
   }
 
@@ -392,27 +389,24 @@ private:
       if (subscription_it == subscriptions_.end()) {
         throw std::runtime_error("subscription has unexpectedly gone out of scope");
       }
-      auto subscription_base = subscription_it->second.subscription.lock();
-      if (subscription_base) {
-        auto subscription = std::static_pointer_cast<
-          rclcpp::experimental::SubscriptionIntraProcess<MessageT>
-          >(subscription_base);
+      auto subscription_base = subscription_it->second.subscription;
 
-        if (std::next(it) == subscription_ids.end()) {
-          // If this is the last subscription, give up ownership
-          subscription->provide_intra_process_message(std::move(message));
-        } else {
-          // Copy the message since we have additional subscriptions to serve
-          MessageUniquePtr copy_message;
-          Deleter deleter = message.get_deleter();
-          auto ptr = MessageAllocTraits::allocate(*allocator.get(), 1);
-          MessageAllocTraits::construct(*allocator.get(), ptr, *message);
-          copy_message = MessageUniquePtr(ptr, deleter);
+      auto subscription = std::static_pointer_cast<
+        rclcpp::experimental::SubscriptionIntraProcess<MessageT>
+        >(subscription_base);
 
-          subscription->provide_intra_process_message(std::move(copy_message));
-        }
+      if (std::next(it) == subscription_ids.end()) {
+        // If this is the last subscription, give up ownership
+        subscription->provide_intra_process_message(std::move(message));
       } else {
-        subscriptions_.erase(subscription_it);
+        // Copy the message since we have additional subscriptions to serve
+        MessageUniquePtr copy_message;
+        Deleter deleter = message.get_deleter();
+        auto ptr = MessageAllocTraits::allocate(*allocator.get(), 1);
+        MessageAllocTraits::construct(*allocator.get(), ptr, *message);
+        copy_message = MessageUniquePtr(ptr, deleter);
+
+        subscription->provide_intra_process_message(std::move(copy_message));
       }
     }
   }

rclcpp/include/rclcpp/experimental/subscription_intra_process.hpp

@@ -18,9 +18,7 @@
 #include <rmw/rmw.h>
 
 #include <functional>
-#include <map>
 #include <memory>
-#include <stdexcept>
 #include <string>
 #include <utility>
 
@@ -117,31 +115,13 @@ public:
   bool
   is_ready(rcl_wait_set_t * wait_set)
   {
-    (void) wait_set;
+    (void)wait_set;
     return buffer_->has_data();
   }
 
-  std::shared_ptr<void>
-  take_data()
+  void execute()
   {
-    ConstMessageSharedPtr shared_msg;
-    MessageUniquePtr unique_msg;
-
-    if (any_callback_.use_take_shared_method()) {
-      shared_msg = buffer_->consume_shared();
-    } else {
-      unique_msg = buffer_->consume_unique();
-    }
-    return std::static_pointer_cast<void>(
-      std::make_shared<std::pair<ConstMessageSharedPtr, MessageUniquePtr>>(
-        std::pair<ConstMessageSharedPtr, MessageUniquePtr>(
-          shared_msg, std::move(unique_msg)))
-    );
-  }
-
-  void execute(std::shared_ptr<void> & data)
-  {
-    execute_impl<CallbackMessageT>(data);
+    execute_impl<CallbackMessageT>();
   }
 
   void
@@ -174,35 +154,26 @@ private:
 
   template<typename T>
   typename std::enable_if<std::is_same<T, rcl_serialized_message_t>::value, void>::type
-  execute_impl(std::shared_ptr<void> & data)
+  execute_impl()
   {
-    (void)data;
     throw std::runtime_error("Subscription intra-process can't handle serialized messages");
   }
 
   template<class T>
   typename std::enable_if<!std::is_same<T, rcl_serialized_message_t>::value, void>::type
-  execute_impl(std::shared_ptr<void> & data)
+  execute_impl()
   {
-    if (!data) {
-      throw std::runtime_error("'data' is empty");
-    }
-
     rmw_message_info_t msg_info;
     msg_info.publisher_gid = {0, {0}};
     msg_info.from_intra_process = true;
 
-    auto shared_ptr = std::static_pointer_cast<std::pair<ConstMessageSharedPtr, MessageUniquePtr>>(
-      data);
-
     if (any_callback_.use_take_shared_method()) {
-      ConstMessageSharedPtr shared_msg = shared_ptr->first;
-      any_callback_.dispatch_intra_process(shared_msg, msg_info);
+      ConstMessageSharedPtr msg = buffer_->consume_shared();
+      any_callback_.dispatch_intra_process(msg, msg_info);
     } else {
-      MessageUniquePtr unique_msg = std::move(shared_ptr->second);
-      any_callback_.dispatch_intra_process(std::move(unique_msg), msg_info);
+      MessageUniquePtr msg = buffer_->consume_unique();
+      any_callback_.dispatch_intra_process(std::move(msg), msg_info);
     }
-    shared_ptr.reset();
   }
 
   AnySubscriptionCallback<CallbackMessageT, Alloc> any_callback_;

rclcpp/include/rclcpp/experimental/subscription_intra_process_base.hpp

@@ -56,12 +56,8 @@ public:
   virtual bool
   is_ready(rcl_wait_set_t * wait_set) = 0;
 
-  virtual
-  std::shared_ptr<void>
-  take_data() = 0;
-
   virtual void
-  execute(std::shared_ptr<void> & data) = 0;
+  execute() = 0;
 
   virtual bool
   use_take_shared_method() const = 0;

rclcpp/include/rclcpp/graph_listener.hpp

@@ -63,7 +63,7 @@ class GraphListener : public std::enable_shared_from_this<GraphListener>
 {
 public:
   RCLCPP_PUBLIC
-  explicit GraphListener(const rclcpp::Context::SharedPtr & parent_context);
+  explicit GraphListener(std::shared_ptr<rclcpp::Context> parent_context);
 
   RCLCPP_PUBLIC
   virtual ~GraphListener();
@@ -160,23 +160,14 @@ protected:
   void
   run_loop();
 
-  RCLCPP_PUBLIC
-  void
-  init_wait_set();
-
-  RCLCPP_PUBLIC
-  void
-  cleanup_wait_set();
-
 private:
   RCLCPP_DISABLE_COPY(GraphListener)
 
   /** \internal */
   void
-  __shutdown();
+  __shutdown(bool);
 
-  std::weak_ptr<rclcpp::Context> weak_parent_context_;
-  std::shared_ptr<rcl_context_t> rcl_parent_context_;
+  rclcpp::Context::WeakPtr parent_context_;
 
   std::thread listener_thread_;
   bool is_started_;
@@ -188,6 +179,7 @@ private:
   std::vector<rclcpp::node_interfaces::NodeGraphInterface *> node_graph_interfaces_;
 
   rcl_guard_condition_t interrupt_guard_condition_ = rcl_get_zero_initialized_guard_condition();
+  rcl_guard_condition_t * shutdown_guard_condition_;
   rcl_wait_set_t wait_set_ = rcl_get_zero_initialized_wait_set();
 };
 

rclcpp/include/rclcpp/loaned_message.hpp

@@ -183,30 +183,14 @@ public:
   /**
    * A call to `release()` will unmanage the memory for the ROS message.
    * That means that the destructor of this class will not free the memory on scope exit.
-   * If the message is loaned from the middleware but not be published, the user needs to call
-   * `rcl_return_loaned_message_from_publisher` manually.
-   * If the memory is from the local allocator, the memory is freed when the unique pointer
-   * goes out instead.
    *
-   * \return std::unique_ptr to the message instance.
+   * \return Raw pointer to the message instance.
    */
-  std::unique_ptr<MessageT, std::function<void(MessageT *)>>
-  release()
+  MessageT * release()
   {
     auto msg = message_;
     message_ = nullptr;
-
-    if (pub_.can_loan_messages()) {
-      return std::unique_ptr<MessageT, std::function<void(MessageT *)>>(msg, [](MessageT *) {});
-    }
-
-    return std::unique_ptr<MessageT, std::function<void(MessageT *)>>(
-      msg,
-      [allocator = message_allocator_](MessageT * msg_ptr) mutable {
-        // call destructor before deallocating
-        msg_ptr->~MessageT();
-        allocator.deallocate(msg_ptr, 1);
-      });
+    return msg;
   }
 
 protected:

rclcpp/include/rclcpp/logger.hpp

@@ -22,7 +22,6 @@
 
 #include "rcl/node.h"
 #include "rcutils/logging.h"
-#include "rcpputils/filesystem_helper.hpp"
 
 /**
  * \def RCLCPP_LOGGING_ENABLED
@@ -76,18 +75,6 @@ RCLCPP_PUBLIC
 Logger
 get_node_logger(const rcl_node_t * node);
 
-/// Get the current logging directory.
-/**
- * For more details of how the logging directory is determined,
- * see \ref rcl_logging_get_logging_directory.
- *
- * \returns the logging directory being used.
- * \throws rclcpp::exceptions::RCLError if an unexpected error occurs.
- */
-RCLCPP_PUBLIC
-rcpputils::fs::path
-get_logging_directory();
-
 class Logger
 {
 public:

rclcpp/include/rclcpp/node.hpp

@@ -163,7 +163,7 @@ public:
    * pub = node->create_publisher<MsgT>("chatter", QoS(10));  // implicitly KeepLast
    * pub = node->create_publisher<MsgT>("chatter", QoS(KeepLast(10)));
    * pub = node->create_publisher<MsgT>("chatter", QoS(KeepAll()));
-   * pub = node->create_publisher<MsgT>("chatter", QoS(1).best_effort().durability_volatile());
+   * pub = node->create_publisher<MsgT>("chatter", QoS(1).best_effort().volatile());
    * {
    *   rclcpp::QoS custom_qos(KeepLast(10), rmw_qos_profile_sensor_data);
    *   pub = node->create_publisher<MsgT>("chatter", custom_qos);
@@ -305,59 +305,16 @@ public:
    *   name is invalid.
    * \throws rclcpp::exceptions::InvalidParameterValueException if initial
    *   value fails to be set.
-   * \throws rclcpp::exceptions::InvalidParameterTypeException
-   *   if the type of the default value or override is wrong.
    */
   RCLCPP_PUBLIC
   const rclcpp::ParameterValue &
   declare_parameter(
     const std::string & name,
-    const rclcpp::ParameterValue & default_value,
+    const rclcpp::ParameterValue & default_value = rclcpp::ParameterValue(),
     const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
     rcl_interfaces::msg::ParameterDescriptor(),
     bool ignore_override = false);
 
-  /// Declare and initialize a parameter, return the effective value.
-  /**
-   * Same as the previous one, but a default value is not provided and the user
-   * must provide a parameter override of the correct type.
-   *
-   * \param[in] name The name of the parameter.
-   * \param[in] type Desired type of the parameter, which will enforced at runtime.
-   * \param[in] parameter_descriptor An optional, custom description for
-   *   the parameter.
-   * \param[in] ignore_override When `true`, the parameter override is ignored.
-   *    Default to `false`.
-   * \return A const reference to the value of the parameter.
-   * \throws Same as the previous overload taking a default value.
-   * \throws rclcpp::exceptions::InvalidParameterTypeException
-   *   if an override is not provided or the provided override is of the wrong type.
-   */
-  RCLCPP_PUBLIC
-  const rclcpp::ParameterValue &
-  declare_parameter(
-    const std::string & name,
-    rclcpp::ParameterType type,
-    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
-    rcl_interfaces::msg::ParameterDescriptor{},
-    bool ignore_override = false);
-
-  /// Declare a parameter
-  [[deprecated(
-    "declare_parameter() with only a name is deprecated and will be deleted in the future.\n" \
-    "If you want to declare a parameter that won't change type without a default value use:\n" \
-    "`node->declare_parameter<ParameterT>(name)`, where e.g. ParameterT=int64_t.\n\n" \
-    "If you want to declare a parameter that can dynamically change type use:\n" \
-    "```\n" \
-    "rcl_interfaces::msg::ParameterDescriptor descriptor;\n" \
-    "descriptor.dynamic_typing = true;\n" \
-    "node->declare_parameter(name, rclcpp::ParameterValue{}, descriptor);\n" \
-    "```"
-  )]]
-  RCLCPP_PUBLIC
-  const rclcpp::ParameterValue &
-  declare_parameter(const std::string & name);
-
   /// Declare and initialize a parameter with a type.
   /**
    * See the non-templated declare_parameter() on this class for details.
@@ -388,18 +345,6 @@ public:
     rcl_interfaces::msg::ParameterDescriptor(),
     bool ignore_override = false);
 
-  /// Declare and initialize a parameter with a type.
-  /**
-   * See the non-templated declare_parameter() on this class for details.
-   */
-  template<typename ParameterT>
-  auto
-  declare_parameter(
-    const std::string & name,
-    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
-    rcl_interfaces::msg::ParameterDescriptor(),
-    bool ignore_override = false);
-
   /// Declare and initialize several parameters with the same namespace and type.
   /**
    * For each key in the map, a parameter with a name of "namespace.key"

rclcpp/include/rclcpp/node_impl.hpp

@@ -172,24 +172,6 @@ Node::declare_parameter(
   }
 }
 
-template<typename ParameterT>
-auto
-Node::declare_parameter(
-  const std::string & name,
-  const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor,
-  bool ignore_override)
-{
-  // get advantage of parameter value template magic to get
-  // the correct rclcpp::ParameterType from ParameterT
-  rclcpp::ParameterValue value{ParameterT{}};
-  return this->declare_parameter(
-    name,
-    value.get_type(),
-    parameter_descriptor,
-    ignore_override
-  ).get<ParameterT>();
-}
-
 template<typename ParameterT>
 std::vector<ParameterT>
 Node::declare_parameters(

rclcpp/include/rclcpp/node_interfaces/node_base.hpp

@@ -118,10 +118,6 @@ public:
   bool
   get_enable_topic_statistics_default() const override;
 
-  std::string
-  resolve_topic_or_service_name(
-    const std::string & name, bool is_service, bool only_expand = false) const override;
-
 private:
   RCLCPP_DISABLE_COPY(NodeBase)
 

rclcpp/include/rclcpp/node_interfaces/node_base_interface.hpp

@@ -163,13 +163,6 @@ public:
   virtual
   bool
   get_enable_topic_statistics_default() const = 0;
-
-  /// Expand and remap a given topic or service name.
-  RCLCPP_PUBLIC
-  virtual
-  std::string
-  resolve_topic_or_service_name(
-    const std::string & name, bool is_service, bool only_expand = false) const = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_parameters.hpp

@@ -103,42 +103,13 @@ public:
   virtual
   ~NodeParameters();
 
-// This is overriding a deprecated method, so we need to ignore the deprecation warning here.
-// Users of the method will still get a warning!
-#ifndef _WIN32
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#else
-# pragma warning(push)
-# pragma warning(disable: 4996)
-#endif
-  [[deprecated(RCLCPP_INTERNAL_NODE_PARAMETERS_INTERFACE_DEPRECATE_DECLARE)]]
-  RCLCPP_PUBLIC
-  const rclcpp::ParameterValue &
-  declare_parameter(const std::string & name) override;
-#ifndef _WIN32
-# pragma GCC diagnostic pop
-#else
-# pragma warning(pop)
-#endif
-
   RCLCPP_PUBLIC
   const rclcpp::ParameterValue &
   declare_parameter(
     const std::string & name,
     const rclcpp::ParameterValue & default_value,
-    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
-    rcl_interfaces::msg::ParameterDescriptor{},
-    bool ignore_override = false) override;
-
-  RCLCPP_PUBLIC
-  const rclcpp::ParameterValue &
-  declare_parameter(
-    const std::string & name,
-    rclcpp::ParameterType type,
-    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
-    rcl_interfaces::msg::ParameterDescriptor(),
-    bool ignore_override = false) override;
+    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor,
+    bool ignore_override) override;
 
   RCLCPP_PUBLIC
   void

rclcpp/include/rclcpp/node_interfaces/node_parameters_interface.hpp

@@ -45,17 +45,6 @@ struct OnSetParametersCallbackHandle
   OnParametersSetCallbackType callback;
 };
 
-#define RCLCPP_INTERNAL_NODE_PARAMETERS_INTERFACE_DEPRECATE_DECLARE \
-  "declare_parameter() with only a name is deprecated and will be deleted in the future.\n" \
-  "If you want to declare a parameter that won't change type without a default value use:\n" \
-  "`node_params->declare_parameter(name, type)`, with e.g. type=rclcpp::PARAMETER_INTEGER.\n\n" \
-  "If you want to declare a parameter that can dynamically change type use:\n" \
-  "```\n" \
-  "rcl_interfaces::msg::ParameterDescriptor descriptor;\n" \
-  "descriptor.dynamic_typing = true;\n" \
-  "node_params->declare_parameter(name, rclcpp::ParameterValue{}, descriptor);\n" \
-  "```"
-
 /// Pure virtual interface class for the NodeParameters part of the Node API.
 class NodeParametersInterface
 {
@@ -66,15 +55,6 @@ public:
   virtual
   ~NodeParametersInterface() = default;
 
-  /// Declare a parameter.
-  /**
-   * \sa rclcpp::Node::declare_parameter
-   */
-  [[deprecated(RCLCPP_INTERNAL_NODE_PARAMETERS_INTERFACE_DEPRECATE_DECLARE)]]
-  virtual
-  const rclcpp::ParameterValue &
-  declare_parameter(const std::string & name) = 0;
-
   /// Declare and initialize a parameter.
   /**
    * \sa rclcpp::Node::declare_parameter
@@ -84,21 +64,7 @@ public:
   const rclcpp::ParameterValue &
   declare_parameter(
     const std::string & name,
-    const rclcpp::ParameterValue & default_value,
-    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
-    rcl_interfaces::msg::ParameterDescriptor(),
-    bool ignore_override = false) = 0;
-
-  /// Declare a parameter.
-  /**
-   * \sa rclcpp::Node::declare_parameter
-   */
-  RCLCPP_PUBLIC
-  virtual
-  const rclcpp::ParameterValue &
-  declare_parameter(
-    const std::string & name,
-    rclcpp::ParameterType type,
+    const rclcpp::ParameterValue & default_value = rclcpp::ParameterValue(),
     const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
     rcl_interfaces::msg::ParameterDescriptor(),
     bool ignore_override = false) = 0;

rclcpp/include/rclcpp/node_interfaces/node_services.hpp

@@ -15,8 +15,6 @@
 #ifndef RCLCPP__NODE_INTERFACES__NODE_SERVICES_HPP_
 #define RCLCPP__NODE_INTERFACES__NODE_SERVICES_HPP_
 
-#include <string>
-
 #include "rclcpp/callback_group.hpp"
 #include "rclcpp/client.hpp"
 #include "rclcpp/macros.hpp"
@@ -55,10 +53,6 @@ public:
     rclcpp::ServiceBase::SharedPtr service_base_ptr,
     rclcpp::CallbackGroup::SharedPtr group) override;
 
-  RCLCPP_PUBLIC
-  std::string
-  resolve_service_name(const std::string & name, bool only_expand = false) const override;
-
 private:
   RCLCPP_DISABLE_COPY(NodeServices)
 

rclcpp/include/rclcpp/node_interfaces/node_services_interface.hpp

@@ -15,8 +15,6 @@
 #ifndef RCLCPP__NODE_INTERFACES__NODE_SERVICES_INTERFACE_HPP_
 #define RCLCPP__NODE_INTERFACES__NODE_SERVICES_INTERFACE_HPP_
 
-#include <string>
-
 #include "rclcpp/callback_group.hpp"
 #include "rclcpp/client.hpp"
 #include "rclcpp/macros.hpp"
@@ -51,12 +49,6 @@ public:
   add_service(
     rclcpp::ServiceBase::SharedPtr service_base_ptr,
     rclcpp::CallbackGroup::SharedPtr group) = 0;
-
-  /// Get the remapped and expanded service name given a input name.
-  RCLCPP_PUBLIC
-  virtual
-  std::string
-  resolve_service_name(const std::string & name, bool only_expand = false) const = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_topics.hpp

@@ -81,10 +81,6 @@ public:
   rclcpp::node_interfaces::NodeTimersInterface *
   get_node_timers_interface() const override;
 
-  RCLCPP_PUBLIC
-  std::string
-  resolve_topic_name(const std::string & name, bool only_expand = false) const override;
-
 private:
   RCLCPP_DISABLE_COPY(NodeTopics)
 

rclcpp/include/rclcpp/node_interfaces/node_topics_interface.hpp

@@ -86,12 +86,6 @@ public:
   virtual
   rclcpp::node_interfaces::NodeTimersInterface *
   get_node_timers_interface() const = 0;
-
-  /// Get a remapped and expanded topic name given an input name.
-  RCLCPP_PUBLIC
-  virtual
-  std::string
-  resolve_topic_name(const std::string & name, bool only_expand = false) const = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/parameter_client.hpp

@@ -15,8 +15,6 @@
 #ifndef RCLCPP__PARAMETER_CLIENT_HPP_
 #define RCLCPP__PARAMETER_CLIENT_HPP_
 
-#include <functional>
-#include <future>
 #include <memory>
 #include <string>
 #include <utility>
@@ -122,14 +120,6 @@ public:
       void(std::shared_future<std::vector<rclcpp::Parameter>>)
     > callback = nullptr);
 
-  RCLCPP_PUBLIC
-  std::shared_future<std::vector<rcl_interfaces::msg::ParameterDescriptor>>
-  describe_parameters(
-    const std::vector<std::string> & names,
-    std::function<
-      void(std::shared_future<std::vector<rcl_interfaces::msg::ParameterDescriptor>>)
-    > callback = nullptr);
-
   RCLCPP_PUBLIC
   std::shared_future<std::vector<rclcpp::ParameterType>>
   get_parameter_types(
@@ -342,17 +332,9 @@ public:
       qos_profile);
   }
 
-  template<typename RepT = int64_t, typename RatioT = std::milli>
+  RCLCPP_PUBLIC
   std::vector<rclcpp::Parameter>
-  get_parameters(
-    const std::vector<std::string> & parameter_names,
-    std::chrono::duration<RepT, RatioT> timeout = std::chrono::duration<RepT, RatioT>(-1))
-  {
-    return get_parameters(
-      parameter_names,
-      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout)
-    );
-  }
+  get_parameters(const std::vector<std::string> & parameter_names);
 
   RCLCPP_PUBLIC
   bool
@@ -396,67 +378,23 @@ public:
     );
   }
 
-  template<typename RepT = int64_t, typename RatioT = std::milli>
-  std::vector<rcl_interfaces::msg::ParameterDescriptor>
-  describe_parameters(
-    const std::vector<std::string> & parameter_names,
-    std::chrono::duration<RepT, RatioT> timeout = std::chrono::duration<RepT, RatioT>(-1))
-  {
-    return describe_parameters(
-      parameter_names,
-      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout)
-    );
-  }
-
-  template<typename RepT = int64_t, typename RatioT = std::milli>
+  RCLCPP_PUBLIC
   std::vector<rclcpp::ParameterType>
-  get_parameter_types(
-    const std::vector<std::string> & parameter_names,
-    std::chrono::duration<RepT, RatioT> timeout = std::chrono::duration<RepT, RatioT>(-1))
-  {
-    return get_parameter_types(
-      parameter_names,
-      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout)
-    );
-  }
+  get_parameter_types(const std::vector<std::string> & parameter_names);
 
-  template<typename RepT = int64_t, typename RatioT = std::milli>
+  RCLCPP_PUBLIC
   std::vector<rcl_interfaces::msg::SetParametersResult>
-  set_parameters(
-    const std::vector<rclcpp::Parameter> & parameters,
-    std::chrono::duration<RepT, RatioT> timeout = std::chrono::duration<RepT, RatioT>(-1))
-  {
-    return set_parameters(
-      parameters,
-      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout)
-    );
-  }
+  set_parameters(const std::vector<rclcpp::Parameter> & parameters);
 
-  template<typename RepT = int64_t, typename RatioT = std::milli>
+  RCLCPP_PUBLIC
   rcl_interfaces::msg::SetParametersResult
-  set_parameters_atomically(
-    const std::vector<rclcpp::Parameter> & parameters,
-    std::chrono::duration<RepT, RatioT> timeout = std::chrono::duration<RepT, RatioT>(-1))
-  {
-    return set_parameters_atomically(
-      parameters,
-      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout)
-    );
-  }
+  set_parameters_atomically(const std::vector<rclcpp::Parameter> & parameters);
 
-  template<typename RepT = int64_t, typename RatioT = std::milli>
+  RCLCPP_PUBLIC
   rcl_interfaces::msg::ListParametersResult
   list_parameters(
     const std::vector<std::string> & parameter_prefixes,
-    uint64_t depth,
-    std::chrono::duration<RepT, RatioT> timeout = std::chrono::duration<RepT, RatioT>(-1))
-  {
-    return list_parameters(
-      parameter_prefixes,
-      depth,
-      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout)
-    );
-  }
+    uint64_t depth);
 
   template<typename CallbackT>
   typename rclcpp::Subscription<rcl_interfaces::msg::ParameterEvent>::SharedPtr
@@ -499,44 +437,6 @@ public:
     return async_parameters_client_->wait_for_service(timeout);
   }
 
-protected:
-  RCLCPP_PUBLIC
-  std::vector<rclcpp::Parameter>
-  get_parameters(
-    const std::vector<std::string> & parameter_names,
-    std::chrono::nanoseconds timeout);
-
-  RCLCPP_PUBLIC
-  std::vector<rcl_interfaces::msg::ParameterDescriptor>
-  describe_parameters(
-    const std::vector<std::string> & parameter_names,
-    std::chrono::nanoseconds timeout);
-
-  RCLCPP_PUBLIC
-  std::vector<rclcpp::ParameterType>
-  get_parameter_types(
-    const std::vector<std::string> & parameter_names,
-    std::chrono::nanoseconds timeout);
-
-  RCLCPP_PUBLIC
-  std::vector<rcl_interfaces::msg::SetParametersResult>
-  set_parameters(
-    const std::vector<rclcpp::Parameter> & parameters,
-    std::chrono::nanoseconds timeout);
-
-  RCLCPP_PUBLIC
-  rcl_interfaces::msg::SetParametersResult
-  set_parameters_atomically(
-    const std::vector<rclcpp::Parameter> & parameters,
-    std::chrono::nanoseconds timeout);
-
-  RCLCPP_PUBLIC
-  rcl_interfaces::msg::ListParametersResult
-  list_parameters(
-    const std::vector<std::string> & parameter_prefixes,
-    uint64_t depth,
-    std::chrono::nanoseconds timeout);
-
 private:
   rclcpp::Executor::SharedPtr executor_;
   const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base_interface_;

rclcpp/include/rclcpp/parameter_event_handler.hpp

@@ -1,338 +0,0 @@
-// Copyright 2019 Intel 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__PARAMETER_EVENT_HANDLER_HPP_
-#define RCLCPP__PARAMETER_EVENT_HANDLER_HPP_
-
-#include <list>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "rclcpp/create_subscription.hpp"
-#include "rclcpp/node_interfaces/get_node_base_interface.hpp"
-#include "rclcpp/node_interfaces/get_node_topics_interface.hpp"
-#include "rclcpp/node_interfaces/node_base_interface.hpp"
-#include "rclcpp/node_interfaces/node_topics_interface.hpp"
-#include "rclcpp/parameter.hpp"
-#include "rclcpp/qos.hpp"
-#include "rclcpp/subscription.hpp"
-#include "rclcpp/visibility_control.hpp"
-#include "rcl_interfaces/msg/parameter_event.hpp"
-
-namespace rclcpp
-{
-
-struct ParameterCallbackHandle
-{
-  RCLCPP_SMART_PTR_DEFINITIONS(ParameterCallbackHandle)
-
-  using ParameterCallbackType = std::function<void (const rclcpp::Parameter &)>;
-
-  std::string parameter_name;
-  std::string node_name;
-  ParameterCallbackType callback;
-};
-
-struct ParameterEventCallbackHandle
-{
-  RCLCPP_SMART_PTR_DEFINITIONS(ParameterEventCallbackHandle)
-
-  using ParameterEventCallbackType =
-    std::function<void (const rcl_interfaces::msg::ParameterEvent::SharedPtr &)>;
-
-  ParameterEventCallbackType callback;
-};
-
-/// A class used to "handle" (monitor and respond to) changes to parameters.
-/**
- * The ParameterEventHandler class allows for the monitoring of changes to node parameters,
- * either a node's own parameters or parameters owned by other nodes in the system.
- * Multiple parameter callbacks can be set and will be invoked when the specified parameter
- * changes.
- *
- * The first step is to instantiate a ParameterEventHandler, providing a ROS node to use
- * to create any required subscriptions:
- *
- *   auto param_handler = std::make_shared<rclcpp::ParameterEventHandler>(node);
- *
- * Next, you can supply a callback to the add_parameter_callback method, as follows:
- *
- *   auto cb1 = [&node](const rclcpp::Parameter & p) {
- *      RCLCPP_INFO(
- *        node->get_logger(),
- *        "cb1: Received an update to parameter \"%s\" of type %s: \"%ld\"",
- *        p.get_name().c_str(),
- *        p.get_type_name().c_str(),
- *        p.as_int());
- *   };
- *   auto handle1 = param_handler->add_parameter_callback("an_int_param", cb1);
- *
- * In this case, we didn't supply a node name (the third, optional, parameter) so the
- * default will be to monitor for changes to the "an_int_param" parameter associated with
- * the ROS node supplied in the ParameterEventHandler constructor.
- * The callback, a lambda function in this case, simply prints out the value of the parameter.
- *
- * You may also monitor for changes to parameters in other nodes by supplying the node
- * name to add_parameter_callback:
- *
- *   auto cb2 = [&node](const rclcpp::Parameter & p) {
- *       RCLCPP_INFO(
- *         node->get_logger(),
- *         "cb2: Received an update to parameter \"%s\" of type: %s: \"%s\"",
- *         p.get_name().c_str(),
- *         p.get_type_name().c_str(),
- *         p.as_string().c_str());
- *     };
- *   auto handle2 = param_handler->add_parameter_callback(
- *     "some_remote_param_name", cb2, "some_remote_node_name");
- *
- * In this case, the callback will be invoked whenever "some_remote_param_name" changes
- * on remote node "some_remote_node_name".
- *
- * To remove a parameter callback, call remove_parameter_callback, passing the handle returned
- * from add_parameter_callback:
- *
- *   param_handler->remove_parameter_callback(handle2);
- *
- * You can also monitor for *all* parameter changes, using add_parameter_event_callback.
- * In this case, the callback will be invoked whenever any parameter changes in the system.
- * You are likely interested in a subset of these parameter changes, so in the callback it
- * is convenient to use a regular expression on the node names or namespaces of interest.
- * For example:
- *
- *   auto cb3 =
- *     [fqn, remote_param_name, &node](const rcl_interfaces::msg::ParameterEvent::SharedPtr & event) {
- *       // Look for any updates to parameters in "/a_namespace" as well as any parameter changes
- *       // to our own node ("this_node")
- *       std::regex re("(/a_namespace/.*)|(/this_node)");
- *       if (regex_match(event->node, re)) {
- *         // Now that we know the event matches the regular expression we scanned for, we can
- *         // use 'get_parameter_from_event' to get a specific parameter name that we're looking for
- *         rclcpp::Parameter p;
- *         if (rclcpp::ParameterEventsSubscriber::get_parameter_from_event(
- *             *event, p, remote_param_name, fqn))
- *         {
- *           RCLCPP_INFO(
- *             node->get_logger(),
- *             "cb3: Received an update to parameter \"%s\" of type: %s: \"%s\"",
- *             p.get_name().c_str(),
- *             p.get_type_name().c_str(),
- *             p.as_string().c_str());
- *         }
- *
- *         // You can also use 'get_parameter*s*_from_event' to enumerate all changes that came
- *         // in on this event
- *         auto params = rclcpp::ParameterEventsSubscriber::get_parameters_from_event(*event);
- *         for (auto & p : params) {
- *           RCLCPP_INFO(
- *             node->get_logger(),
- *             "cb3: Received an update to parameter \"%s\" of type: %s: \"%s\"",
- *             p.get_name().c_str(),
- *             p.get_type_name().c_str(),
- *             p.value_to_string().c_str());
- *         }
- *       }
- *     };
- *   auto handle3 = param_handler->add_parameter_event_callback(cb3);
- *
- * For both parameter callbacks and parameter event callbacks, when multiple callbacks are added,
- * the callbacks are invoked last-in, first-called order (LIFO).
- *
- * To remove a parameter event callback, use:
- *
- *   param_handler->remove_event_parameter_callback(handle);
- */
-class ParameterEventHandler
-{
-public:
-  /// Construct a parameter events monitor.
-  /**
-   * \param[in] node The node to use to create any required subscribers.
-   * \param[in] qos The QoS settings to use for any subscriptions.
-   */
-  template<typename NodeT>
-  ParameterEventHandler(
-    NodeT node,
-    const rclcpp::QoS & qos =
-    rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(rmw_qos_profile_parameter_events)))
-  {
-    node_base_ = rclcpp::node_interfaces::get_node_base_interface(node);
-    auto node_topics = rclcpp::node_interfaces::get_node_topics_interface(node);
-
-    event_subscription_ = rclcpp::create_subscription<rcl_interfaces::msg::ParameterEvent>(
-      node_topics, "/parameter_events", qos,
-      std::bind(&ParameterEventHandler::event_callback, this, std::placeholders::_1));
-  }
-
-  using ParameterEventCallbackType =
-    ParameterEventCallbackHandle::ParameterEventCallbackType;
-
-  /// Set a callback for all parameter events.
-  /**
-   * This function may be called multiple times to set multiple parameter event callbacks.
-   *
-   * \param[in] callback Function callback to be invoked on parameter updates.
-   * \returns A handle used to refer to the callback.
-   */
-  RCLCPP_PUBLIC
-  ParameterEventCallbackHandle::SharedPtr
-  add_parameter_event_callback(
-    ParameterEventCallbackType callback);
-
-  /// Remove parameter event callback registered with add_parameter_event_callback.
-  /**
-   * \param[in] callback_handle Handle of the callback to remove.
-   */
-  RCLCPP_PUBLIC
-  void
-  remove_parameter_event_callback(
-    ParameterEventCallbackHandle::SharedPtr callback_handle);
-
-  using ParameterCallbackType = ParameterCallbackHandle::ParameterCallbackType;
-
-  /// Add a callback for a specified parameter.
-  /**
-   * If a node_name is not provided, defaults to the current node.
-   *
-   * \param[in] parameter_name Name of parameter to monitor.
-   * \param[in] callback Function callback to be invoked upon parameter update.
-   * \param[in] node_name Name of node which hosts the parameter.
-   * \returns A handle used to refer to the callback.
-   */
-  RCLCPP_PUBLIC
-  ParameterCallbackHandle::SharedPtr
-  add_parameter_callback(
-    const std::string & parameter_name,
-    ParameterCallbackType callback,
-    const std::string & node_name = "");
-
-  /// Remove a parameter callback registered with add_parameter_callback.
-  /**
-   * The parameter name and node name are inspected from the callback handle. The callback handle
-   * is erased from the list of callback handles on the {parameter_name, node_name} in the map.
-   * An error is thrown if the handle does not exist and/or was already removed.
-   *
-   * \param[in] callback_handle Handle of the callback to remove.
-   */
-  RCLCPP_PUBLIC
-  void
-  remove_parameter_callback(
-    ParameterCallbackHandle::SharedPtr callback_handle);
-
-  /// Get an rclcpp::Parameter from a parameter event.
-  /**
-   * If a node_name is not provided, defaults to the current node.
-   *
-   * \param[in] event Event msg to be inspected.
-   * \param[out] parameter Reference to rclcpp::Parameter to be assigned.
-   * \param[in] parameter_name Name of parameter.
-   * \param[in] node_name Name of node which hosts the parameter.
-   * \returns Output parameter is set with requested parameter info and returns true if
-   * requested parameter name and node is in event. Otherwise, returns false.
-   */
-  RCLCPP_PUBLIC
-  static bool
-  get_parameter_from_event(
-    const rcl_interfaces::msg::ParameterEvent & event,
-    rclcpp::Parameter & parameter,
-    const std::string parameter_name,
-    const std::string node_name = "");
-
-  /// Get an rclcpp::Parameter from parameter event
-  /**
-   * If a node_name is not provided, defaults to the current node.
-   *
-   * The user is responsible to check if the returned parameter has been properly assigned.
-   * By default, if the requested parameter is not found in the event, the returned parameter
-   * has parameter value of type rclcpp::PARAMETER_NOT_SET.
-   *
-   * \param[in] event Event msg to be inspected.
-   * \param[in] parameter_name Name of parameter.
-   * \param[in] node_name Name of node which hosts the parameter.
-   * \returns The resultant rclcpp::Parameter from the event.
-   */
-  RCLCPP_PUBLIC
-  static rclcpp::Parameter
-  get_parameter_from_event(
-    const rcl_interfaces::msg::ParameterEvent & event,
-    const std::string parameter_name,
-    const std::string node_name = "");
-
-  /// Get all rclcpp::Parameter values from a parameter event
-  /**
-   * \param[in] event Event msg to be inspected.
-   * \returns A vector rclcpp::Parameter values from the event.
-   */
-  RCLCPP_PUBLIC
-  static std::vector<rclcpp::Parameter>
-  get_parameters_from_event(
-    const rcl_interfaces::msg::ParameterEvent & event);
-
-  using CallbacksContainerType = std::list<ParameterCallbackHandle::WeakPtr>;
-
-protected:
-  /// Callback for parameter events subscriptions.
-  RCLCPP_PUBLIC
-  void
-  event_callback(const rcl_interfaces::msg::ParameterEvent::SharedPtr event);
-
-  // Utility function for resolving node path.
-  std::string resolve_path(const std::string & path);
-
-  // Node interface used for base functionality
-  std::shared_ptr<rclcpp::node_interfaces::NodeBaseInterface> node_base_;
-
-  // *INDENT-OFF* Uncrustify doesn't handle indented public/private labels
-  // Hash function for string pair required in std::unordered_map
-  // See: https://stackoverflow.com/questions/35985960/c-why-is-boosthash-combine-the-best-way-to-combine-hash-values
-  class StringPairHash
-  {
-  public:
-    template<typename T>
-    inline void hash_combine(std::size_t & seed, const T & v) const
-    {
-      std::hash<T> hasher;
-      seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-    }
-
-    inline size_t operator()(const std::pair<std::string, std::string> & s) const
-    {
-      size_t seed = 0;
-      hash_combine(seed, s.first);
-      hash_combine(seed, s.second);
-      return seed;
-    }
-  };
-  // *INDENT-ON*
-
-  // Map container for registered parameters
-  std::unordered_map<
-    std::pair<std::string, std::string>,
-    CallbacksContainerType,
-    StringPairHash
-  > parameter_callbacks_;
-
-  rclcpp::Subscription<rcl_interfaces::msg::ParameterEvent>::SharedPtr event_subscription_;
-
-  std::list<ParameterEventCallbackHandle::WeakPtr> event_callbacks_;
-
-  std::recursive_mutex mutex_;
-};
-
-}  // namespace rclcpp
-
-#endif  // RCLCPP__PARAMETER_EVENT_HANDLER_HPP_

rclcpp/include/rclcpp/publisher.hpp

@@ -261,7 +261,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(std::move(loaned_msg.release()));
+      this->do_loaned_message_publish(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.
@@ -310,9 +310,9 @@ protected:
   }
 
   void
-  do_loaned_message_publish(std::unique_ptr<MessageT, std::function<void(MessageT *)>> msg)
+  do_loaned_message_publish(MessageT * msg)
   {
-    auto status = rcl_publish_loaned_message(publisher_handle_.get(), msg.get(), nullptr);
+    auto status = rcl_publish_loaned_message(publisher_handle_.get(), msg, nullptr);
 
     if (RCL_RET_PUBLISHER_INVALID == status) {
       rcl_reset_error();  // next call will reset error message if not context

rclcpp/include/rclcpp/publisher_options.hpp

@@ -26,7 +26,6 @@
 #include "rclcpp/intra_process_setting.hpp"
 #include "rclcpp/qos.hpp"
 #include "rclcpp/qos_event.hpp"
-#include "rclcpp/qos_overriding_options.hpp"
 
 namespace rclcpp
 {
@@ -51,8 +50,6 @@ struct PublisherOptionsBase
   /// Optional RMW implementation specific payload to be used during creation of the publisher.
   std::shared_ptr<rclcpp::detail::RMWImplementationSpecificPublisherPayload>
   rmw_implementation_payload = nullptr;
-
-  QosOverridingOptions qos_overriding_options;
 };
 
 /// Structure containing optional configuration for Publishers.
@@ -95,7 +92,12 @@ struct PublisherOptionsWithAllocator : public PublisherOptionsBase
   get_allocator() const
   {
     if (!this->allocator) {
-      return std::make_shared<Allocator>();
+      // TODO(wjwwood): I would like to use the commented line instead, but
+      //   cppcheck 1.89 fails with:
+      //     Syntax Error: AST broken, binary operator '>' doesn't have two operands.
+      // return std::make_shared<Allocator>();
+      std::shared_ptr<Allocator> tmp(new Allocator());
+      return tmp;
     }
     return this->allocator;
   }

rclcpp/include/rclcpp/qos.hpp

@@ -30,38 +30,6 @@ namespace rclcpp
 RCLCPP_PUBLIC
 std::string qos_policy_name_from_kind(rmw_qos_policy_kind_t policy_kind);
 
-enum class HistoryPolicy
-{
-  KeepLast = RMW_QOS_POLICY_HISTORY_KEEP_LAST,
-  KeepAll = RMW_QOS_POLICY_HISTORY_KEEP_ALL,
-  SystemDefault = RMW_QOS_POLICY_HISTORY_SYSTEM_DEFAULT,
-  Unknown = RMW_QOS_POLICY_HISTORY_UNKNOWN,
-};
-
-enum class ReliabilityPolicy
-{
-  BestEffort = RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT,
-  Reliable = RMW_QOS_POLICY_RELIABILITY_RELIABLE,
-  SystemDefault = RMW_QOS_POLICY_RELIABILITY_SYSTEM_DEFAULT,
-  Unknown = RMW_QOS_POLICY_RELIABILITY_UNKNOWN,
-};
-
-enum class DurabilityPolicy
-{
-  Volatile = RMW_QOS_POLICY_DURABILITY_VOLATILE,
-  TransientLocal = RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL,
-  SystemDefault = RMW_QOS_POLICY_DURABILITY_SYSTEM_DEFAULT,
-  Unknown = RMW_QOS_POLICY_DURABILITY_UNKNOWN,
-};
-
-enum class LivelinessPolicy
-{
-  Automatic = RMW_QOS_POLICY_LIVELINESS_AUTOMATIC,
-  ManualByTopic = RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC,
-  SystemDefault = RMW_QOS_POLICY_LIVELINESS_SYSTEM_DEFAULT,
-  Unknown = RMW_QOS_POLICY_LIVELINESS_UNKNOWN,
-};
-
 /// QoS initialization values, cannot be created directly, use KeepAll or KeepLast instead.
 struct RCLCPP_PUBLIC QoSInitialization
 {
@@ -90,32 +58,10 @@ struct RCLCPP_PUBLIC KeepLast : public rclcpp::QoSInitialization
 };
 
 /// Encapsulation of Quality of Service settings.
-/**
- * Quality of Service settings control the behavior of publishers, subscriptions,
- * and other entities, and includes things like how data is sent or resent,
- * how data is buffered on the publishing and subscribing side, and other things.
- * See:
- *   <a href="https://index.ros.org/doc/ros2/Concepts/About-Quality-of-Service-Settings">
- *     https://index.ros.org/doc/ros2/Concepts/About-Quality-of-Service-Settings
- *   </a>
- */
 class RCLCPP_PUBLIC QoS
 {
 public:
-  /// Create a QoS by specifying only the history policy and history depth.
-  /**
-   * When using the default initial profile, the defaults will include:
-   *
-   *   - \link rclcpp::ReliabilityPolicy::Reliable ReliabilityPolicy::Reliable\endlink
-   *   - \link rclcpp::DurabilityPolicy::Volatile DurabilityPolicy::Volatile\endlink
-   *
-   * See rmw_qos_profile_default for a full list of default settings.
-   * If some other rmw_qos_profile_t is passed to initial_profile, then the defaults will derive from
-   * that profile instead.
-   *
-   * \param[in] qos_initialization Specifies history policy and history depth.
-   * \param[in] initial_profile The rmw_qos_profile_t instance on which to base the default settings.
-   */
+  /// Constructor which allows you to construct a QoS by giving the only required settings.
   explicit
   QoS(
     const QoSInitialization & qos_initialization,
@@ -123,11 +69,7 @@ public:
 
   /// Conversion constructor to ease construction in the common case of just specifying depth.
   /**
-   * This is a convenience constructor that calls QoS(KeepLast(history_depth)).
-   *
-   * \param[in] history_depth How many messages can be queued when publishing
-   *   with a Publisher, or how many messages can be queued before being replaced
-   *   by a Subscription.
+   * Convenience constructor, equivalent to QoS(KeepLast(history_depth)).
    */
   // cppcheck-suppress noExplicitConstructor
   QoS(size_t history_depth);  // NOLINT(runtime/explicit): conversion constructor
@@ -140,10 +82,6 @@ public:
   const rmw_qos_profile_t &
   get_rmw_qos_profile() const;
 
-  /// Set the history policy.
-  QoS &
-  history(HistoryPolicy history);
-
   /// Set the history policy.
   QoS &
   history(rmw_qos_history_policy_t history);
@@ -160,10 +98,6 @@ public:
   QoS &
   reliability(rmw_qos_reliability_policy_t reliability);
 
-  /// Set the reliability setting.
-  QoS &
-  reliability(ReliabilityPolicy reliability);
-
   /// Set the reliability setting to reliable.
   QoS &
   reliable();
@@ -176,10 +110,6 @@ public:
   QoS &
   durability(rmw_qos_durability_policy_t durability);
 
-  /// Set the durability setting.
-  QoS &
-  durability(DurabilityPolicy durability);
-
   /// Set the durability setting to volatile.
   /**
     * Note that this cannot be named `volatile` because it is a C++ keyword.
@@ -211,10 +141,6 @@ public:
   QoS &
   liveliness(rmw_qos_liveliness_policy_t liveliness);
 
-  /// Set the liveliness setting.
-  QoS &
-  liveliness(LivelinessPolicy liveliness);
-
   /// Set the liveliness_lease_duration setting.
   QoS &
   liveliness_lease_duration(rmw_time_t liveliness_lease_duration);
@@ -227,42 +153,6 @@ public:
   QoS &
   avoid_ros_namespace_conventions(bool avoid_ros_namespace_conventions);
 
-  /// Get the history qos policy.
-  HistoryPolicy
-  history() const;
-
-  /// Get the history depth.
-  size_t
-  depth() const;
-
-  /// Get the reliability policy.
-  ReliabilityPolicy
-  reliability() const;
-
-  /// Get the durability policy.
-  DurabilityPolicy
-  durability() const;
-
-  /// Get the deadline duration setting.
-  rclcpp::Duration
-  deadline() const;
-
-  /// Get the lifespan duration setting.
-  rclcpp::Duration
-  lifespan() const;
-
-  /// Get the liveliness policy.
-  LivelinessPolicy
-  liveliness() const;
-
-  /// Get the liveliness lease duration setting.
-  rclcpp::Duration
-  liveliness_lease_duration() const;
-
-  /// Get the `avoid ros namespace convention` setting.
-  bool
-  avoid_ros_namespace_conventions() const;
-
 private:
   rmw_qos_profile_t rmw_qos_profile_;
 };

rclcpp/include/rclcpp/qos_event.hpp

@@ -16,8 +16,6 @@
 #define RCLCPP__QOS_EVENT_HPP_
 
 #include <functional>
-#include <memory>
-#include <stdexcept>
 #include <string>
 
 #include "rcl/error_handling.h"
@@ -133,31 +131,21 @@ public:
     }
   }
 
-  /// Take data so that the callback cannot be scheduled again
-  std::shared_ptr<void>
-  take_data() override
+  /// Execute any entities of the Waitable that are ready.
+  void
+  execute() override
   {
     EventCallbackInfoT callback_info;
+
     rcl_ret_t ret = rcl_take_event(&event_handle_, &callback_info);
     if (ret != RCL_RET_OK) {
       RCUTILS_LOG_ERROR_NAMED(
         "rclcpp",
         "Couldn't take event info: %s", rcl_get_error_string().str);
-      return nullptr;
+      return;
     }
-    return std::static_pointer_cast<void>(std::make_shared<EventCallbackInfoT>(callback_info));
-  }
 
-  /// Execute any entities of the Waitable that are ready.
-  void
-  execute(std::shared_ptr<void> & data) override
-  {
-    if (!data) {
-      throw std::runtime_error("'data' is empty");
-    }
-    auto callback_ptr = std::static_pointer_cast<EventCallbackInfoT>(data);
-    event_callback_(*callback_ptr);
-    callback_ptr.reset();
+    event_callback_(callback_info);
   }
 
 private:

rclcpp/include/rclcpp/qos_overriding_options.hpp

@@ -1,154 +0,0 @@
-// Copyright 2020 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_OVERRIDING_OPTIONS_HPP_
-#define RCLCPP__QOS_OVERRIDING_OPTIONS_HPP_
-
-#include <functional>
-#include <initializer_list>
-#include <ostream>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "rclcpp/qos.hpp"
-#include "rclcpp/visibility_control.hpp"
-
-#include "rcl_interfaces/msg/set_parameters_result.hpp"
-#include "rmw/qos_policy_kind.h"
-
-namespace rclcpp
-{
-
-enum class RCLCPP_PUBLIC_TYPE QosPolicyKind
-{
-  AvoidRosNamespaceConventions = RMW_QOS_POLICY_AVOID_ROS_NAMESPACE_CONVENTIONS,
-  Deadline = RMW_QOS_POLICY_DEADLINE,
-  Depth = RMW_QOS_POLICY_DEPTH,
-  Durability = RMW_QOS_POLICY_DURABILITY,
-  History = RMW_QOS_POLICY_HISTORY,
-  Lifespan = RMW_QOS_POLICY_LIFESPAN,
-  Liveliness = RMW_QOS_POLICY_LIVELINESS,
-  LivelinessLeaseDuration = RMW_QOS_POLICY_LIVELINESS_LEASE_DURATION,
-  Reliability = RMW_QOS_POLICY_RELIABILITY,
-  Invalid = RMW_QOS_POLICY_INVALID,
-};
-
-RCLCPP_PUBLIC
-const char *
-qos_policy_kind_to_cstr(const QosPolicyKind & qpk);
-
-RCLCPP_PUBLIC
-std::ostream &
-operator<<(std::ostream & os, const QosPolicyKind & qpk);
-
-using QosCallbackResult = rcl_interfaces::msg::SetParametersResult;
-using QosCallback = std::function<QosCallbackResult(const rclcpp::QoS &)>;
-
-namespace detail
-{
-// forward declare
-template<typename T>
-class QosParameters;
-}
-
-/// Options that are passed in subscription/publisher constructor to specify QoSConfigurability.
-/**
- * This options struct allows configuring:
- * - Which policy kinds will have declared parameters.
- * - An optional callback, that will be called to validate the final qos profile.
- * - An optional id. In the case that different qos are desired for two publishers/subscriptions in
- *   the same topic, this id will allow disambiguating them.
- *
- * Example parameter file:
- *
- * ```yaml
- * my_node_name:
- *  ros__parameters:
- *    qos_overrides:
- *      /my/topic/name:
- *        publisher:  # publisher without provided id
- *          reliability: reliable
- *          depth: 100
- *        publisher_my_id:  # publisher with `id="my_id"
- *          reliability: reliable
- *          depth: 10
- * ```
- */
-class QosOverridingOptions
-{
-public:
-  /// Default constructor, no overrides allowed.
-  RCLCPP_PUBLIC
-  QosOverridingOptions() = default;
-
-  /// Construct passing a list of QoS policies and a verification callback.
-  /**
-   * This constructor is implicit, e.g.:
-   * ```cpp
-   * node->create_publisher(
-   *   "topic_name",
-   *   default_qos_profile,
-   *   {
-   *     {QosPolicyKind::Reliability},
-   *     [] (auto && qos) {return check_qos_validity(qos)},
-   *     "my_id"
-   *   });
-   * ```
-   * \param policy_kinds list of policy kinds that will be reconfigurable.
-   * \param validation_callback callbak that will be called to validate the validity of
-   *   the qos profile set by the user.
-   * \param id id of the entity.
-   */
-  RCLCPP_PUBLIC
-  QosOverridingOptions(
-    std::initializer_list<QosPolicyKind> policy_kinds,
-    QosCallback validation_callback = nullptr,
-    std::string id = {});
-
-  RCLCPP_PUBLIC
-  const std::string &
-  get_id() const;
-
-  RCLCPP_PUBLIC
-  const std::vector<QosPolicyKind> &
-  get_policy_kinds() const;
-
-  RCLCPP_PUBLIC
-  const QosCallback &
-  get_validation_callback() const;
-
-  /// Construct passing a list of QoS policies and a verification callback.
-  /**
-   * Same as `QosOverridingOptions` constructor, but only declares the default policies:
-   *
-   * History, Depth, Reliability.
-   */
-  RCLCPP_PUBLIC
-  static
-  QosOverridingOptions
-  with_default_policies(QosCallback validation_callback = nullptr, std::string id = {});
-
-private:
-  /// \internal Id of the entity requesting to create parameters.
-  std::string id_;
-  /// \internal Policy kinds that are allowed to be reconfigured.
-  std::vector<QosPolicyKind> policy_kinds_;
-  /// \internal Validation callback that will be called to verify the profile.
-  QosCallback validation_callback_;
-};
-
-}  // namespace rclcpp
-
-#endif  // RCLCPP__QOS_OVERRIDING_OPTIONS_HPP_

rclcpp/include/rclcpp/rclcpp.hpp

@@ -147,15 +147,14 @@
 #include "rclcpp/guard_condition.hpp"
 #include "rclcpp/logging.hpp"
 #include "rclcpp/node.hpp"
-#include "rclcpp/parameter_client.hpp"
-#include "rclcpp/parameter_event_handler.hpp"
 #include "rclcpp/parameter.hpp"
+#include "rclcpp/parameter_client.hpp"
 #include "rclcpp/parameter_service.hpp"
 #include "rclcpp/rate.hpp"
 #include "rclcpp/time.hpp"
 #include "rclcpp/utilities.hpp"
 #include "rclcpp/visibility_control.hpp"
-#include "rclcpp/waitable.hpp"
 #include "rclcpp/wait_set.hpp"
+#include "rclcpp/waitable.hpp"
 
 #endif  // RCLCPP__RCLCPP_HPP_

rclcpp/include/rclcpp/service.hpp

@@ -180,7 +180,7 @@ public:
     std::weak_ptr<rcl_node_t> weak_node_handle(node_handle_);
     // rcl does the static memory allocation here
     service_handle_ = std::shared_ptr<rcl_service_t>(
-      new rcl_service_t, [weak_node_handle, service_name](rcl_service_t * service)
+      new rcl_service_t, [weak_node_handle](rcl_service_t * service)
       {
         auto handle = weak_node_handle.lock();
         if (handle) {
@@ -192,10 +192,10 @@ public:
             rcl_reset_error();
           }
         } else {
-          RCLCPP_ERROR_STREAM(
+          RCLCPP_ERROR(
             rclcpp::get_logger("rclcpp"),
-            "Error in destruction of rcl service handle " << service_name <<
-              ": the Node Handle was destructed too early. You will leak memory");
+            "Error in destruction of rcl service handle: "
+            "the Node Handle was destructed too early. You will leak memory");
         }
         delete service;
       });

rclcpp/include/rclcpp/subscription.hpp

@@ -171,7 +171,11 @@ public:
 
       // First create a SubscriptionIntraProcess which will be given to the intra-process manager.
       auto context = node_base->get_context();
-      subscription_intra_process_ = std::make_shared<SubscriptionIntraProcessT>(
+      using SubscriptionIntraProcessT = rclcpp::experimental::SubscriptionIntraProcess<
+        CallbackMessageT,
+        AllocatorT,
+        typename MessageUniquePtr::deleter_type>;
+      auto subscription_intra_process = std::make_shared<SubscriptionIntraProcessT>(
         callback,
         options.get_allocator(),
         context,
@@ -181,12 +185,12 @@ public:
       TRACEPOINT(
         rclcpp_subscription_init,
         static_cast<const void *>(get_subscription_handle().get()),
-        static_cast<const void *>(subscription_intra_process_.get()));
+        static_cast<const void *>(subscription_intra_process.get()));
 
       // 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->add_subscription(subscription_intra_process_);
+      uint64_t intra_process_subscription_id = ipm->add_subscription(subscription_intra_process);
       this->setup_intra_process(intra_process_subscription_id, ipm);
     }
 
@@ -273,18 +277,11 @@ public:
       return;
     }
     auto typed_message = std::static_pointer_cast<CallbackMessageT>(message);
-
-    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();
-    }
-
     any_callback_.dispatch(typed_message, message_info);
 
     if (subscription_topic_statistics_) {
-      const auto nanos = std::chrono::time_point_cast<std::chrono::nanoseconds>(now);
+      const auto nanos = std::chrono::time_point_cast<std::chrono::nanoseconds>(
+        std::chrono::system_clock::now());
       const auto time = rclcpp::Time(nanos.time_since_epoch().count());
       subscription_topic_statistics_->handle_message(*typed_message, time);
     }
@@ -343,11 +340,6 @@ private:
     message_memory_strategy_;
   /// Component which computes and publishes topic statistics for this subscriber
   SubscriptionTopicStatisticsSharedPtr subscription_topic_statistics_{nullptr};
-  using SubscriptionIntraProcessT = rclcpp::experimental::SubscriptionIntraProcess<
-    CallbackMessageT,
-    AllocatorT,
-    typename MessageUniquePtr::deleter_type>;
-  std::shared_ptr<SubscriptionIntraProcessT> subscription_intra_process_;
 };
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/subscription_options.hpp

@@ -26,7 +26,6 @@
 #include "rclcpp/intra_process_setting.hpp"
 #include "rclcpp/qos.hpp"
 #include "rclcpp/qos_event.hpp"
-#include "rclcpp/qos_overriding_options.hpp"
 #include "rclcpp/topic_statistics_state.hpp"
 #include "rclcpp/visibility_control.hpp"
 
@@ -73,8 +72,6 @@ struct SubscriptionOptionsBase
   };
 
   TopicStatisticsOptions topic_stats_options;
-
-  QosOverridingOptions qos_overriding_options;
 };
 
 /// Structure containing optional configuration for Subscriptions.
@@ -104,7 +101,7 @@ struct SubscriptionOptionsWithAllocator : public SubscriptionOptionsBase
     rcl_subscription_options_t result = rcl_subscription_get_default_options();
     using AllocatorTraits = std::allocator_traits<Allocator>;
     using MessageAllocatorT = typename AllocatorTraits::template rebind_alloc<MessageT>;
-    auto message_alloc = std::make_shared<MessageAllocatorT>(*this->get_allocator().get());
+    auto message_alloc = std::make_shared<MessageAllocatorT>(*allocator.get());
     result.allocator = allocator::get_rcl_allocator<MessageT>(*message_alloc);
     result.qos = qos.get_rmw_qos_profile();
     result.rmw_subscription_options.ignore_local_publications = this->ignore_local_publications;

rclcpp/include/rclcpp/time_source.hpp

@@ -32,20 +32,6 @@ namespace rclcpp
 {
 class Clock;
 
-/**
- * Time source that will drive the attached clocks.
- *
- * If the attached node `use_sim_time` parameter is `true`, the attached clocks will
- * be updated based on messages received.
- *
- * The subscription to the clock topic created by the time source can have it's qos reconfigured
- * using parameter overrides, particularly the following ones are accepted:
- *
- * - qos_overrides./clock.depth
- * - qos_overrides./clock.durability
- * - qos_overrides./clock.history
- * - qos_overrides./clock.reliability
- */
 class TimeSource
 {
 public:

rclcpp/include/rclcpp/topic_statistics/subscription_topic_statistics.hpp

@@ -127,7 +127,7 @@ public:
   /**
    * This method acquires a lock to prevent race conditions to collectors list.
    */
-  virtual void publish_message_and_reset_measurements()
+  virtual void publish_message()
   {
     std::vector<MetricsMessage> msgs;
     rclcpp::Time window_end{get_current_nanoseconds_since_epoch()};
@@ -136,7 +136,6 @@ public:
       std::lock_guard<std::mutex> lock(mutex_);
       for (auto & collector : subscriber_statistics_collectors_) {
         const auto collected_stats = collector->GetStatisticsResults();
-        collector->ClearCurrentMeasurements();
 
         auto message = libstatistics_collector::collector::GenerateStatisticMessage(
           node_name_,

rclcpp/include/rclcpp/waitable.hpp

@@ -16,7 +16,6 @@
 #define RCLCPP__WAITABLE_HPP_
 
 #include <atomic>
-#include <memory>
 
 #include "rclcpp/macros.hpp"
 #include "rclcpp/visibility_control.hpp"
@@ -126,17 +125,8 @@ public:
   bool
   is_ready(rcl_wait_set_t * wait_set) = 0;
 
-  /// Take the data so that it can be consumed with `execute`.
+  /// Execute any entities of the Waitable that are ready.
   /**
-   * NOTE: take_data is a partial fix to a larger design issue with the
-   * multithreaded executor. This method is likely to be removed when
-   * a more permanent fix is implemented. A longterm fix is currently
-   * being discussed here: https://github.com/ros2/rclcpp/pull/1276
-   *
-   * This method takes the data from the underlying data structure and
-   * writes it to the void shared pointer `data` that is passed into the
-   * method. The `data` can then be executed with the `execute` method.
-   *
    * Before calling this method, the Waitable should be added to a wait set,
    * waited on, and then updated.
    *
@@ -153,41 +143,13 @@ public:
    * // Update the Waitable
    * waitable.update(wait_set);
    * // Execute any entities of the Waitable that may be ready
-   * std::shared_ptr<void> data = waitable.take_data();
-   * ```
-   */
-  RCLCPP_PUBLIC
-  virtual
-  std::shared_ptr<void>
-  take_data() = 0;
-
-  /// Execute data that is passed in.
-  /**
-   * Before calling this method, the Waitable should be added to a wait set,
-   * waited on, and then updated - and the `take_data` method should be
-   * called.
-   *
-   * Example usage:
-   *
-   * ```cpp
-   * // ... create a wait set and a Waitable
-   * // Add the Waitable to the wait set
-   * bool add_ret = waitable.add_to_wait_set(wait_set);
-   * // ... error handling
-   * // Wait
-   * rcl_ret_t wait_ret = rcl_wait(wait_set);
-   * // ... error handling
-   * // Update the Waitable
-   * waitable.update(wait_set);
-   * // Execute any entities of the Waitable that may be ready
-   * std::shared_ptr<void> data = waitable.take_data();
-   * waitable.execute(data);
+   * waitable.execute();
    * ```
    */
   RCLCPP_PUBLIC
   virtual
   void
-  execute(std::shared_ptr<void> & data) = 0;
+  execute() = 0;
 
   /// Exchange the "in use by wait set" state for this timer.
   /**

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>8.0.0</version>
+  <version>5.0.0</version>
   <description>The ROS client library in C++.</description>
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
   <maintainer email="mabel@openrobotics.org">Mabel Zhang</maintainer>

rclcpp/resource/logging.hpp.em

@@ -151,9 +151,10 @@ def get_rclcpp_suffix_from_features(features):
 @[ end if]@
       logger.get_name(), \
 @[ if 'stream' not in feature_combination]@
-      __VA_ARGS__); \
+      rclcpp::get_c_string(RCLCPP_FIRST_ARG(__VA_ARGS__, "")), \
+        RCLCPP_ALL_BUT_FIRST_ARGS(__VA_ARGS__,"")); \
 @[ else]@
-      "%s", ss.str().c_str()); \
+      "%s", rclcpp::get_c_string(ss.str())); \
 @[ end if]@
   } while (0)
 

rclcpp/src/rclcpp/clock.cpp

@@ -113,7 +113,7 @@ Clock::get_clock_mutex() noexcept
 
 void
 Clock::on_time_jump(
-  const rcl_time_jump_t * time_jump,
+  const struct rcl_time_jump_t * time_jump,
   bool before_jump,
   void * user_data)
 {

rclcpp/src/rclcpp/context.cpp

@@ -291,7 +291,7 @@ Context::get_domain_id() const
 }
 
 std::string
-Context::shutdown_reason() const
+Context::shutdown_reason()
 {
   std::lock_guard<std::recursive_mutex> lock(init_mutex_);
   return shutdown_reason_;
@@ -320,6 +320,7 @@ Context::shutdown(const std::string & reason)
   }
   // interrupt all blocking sleep_for() and all blocking executors or wait sets
   this->interrupt_all_sleep_for();
+  this->interrupt_all_wait_sets();
   // remove self from the global contexts
   weak_contexts_->remove_context(this);
   // shutdown logger
@@ -390,6 +391,75 @@ Context::interrupt_all_sleep_for()
   interrupt_condition_variable_.notify_all();
 }
 
+rcl_guard_condition_t *
+Context::get_interrupt_guard_condition(rcl_wait_set_t * wait_set)
+{
+  std::lock_guard<std::mutex> lock(interrupt_guard_cond_handles_mutex_);
+  auto kv = interrupt_guard_cond_handles_.find(wait_set);
+  if (kv != interrupt_guard_cond_handles_.end()) {
+    return &kv->second;
+  } else {
+    rcl_guard_condition_t handle = rcl_get_zero_initialized_guard_condition();
+    rcl_guard_condition_options_t options = rcl_guard_condition_get_default_options();
+    auto ret = rcl_guard_condition_init(&handle, this->get_rcl_context().get(), options);
+    if (RCL_RET_OK != ret) {
+      rclcpp::exceptions::throw_from_rcl_error(ret, "Couldn't initialize guard condition");
+    }
+    interrupt_guard_cond_handles_.emplace(wait_set, handle);
+    return &interrupt_guard_cond_handles_[wait_set];
+  }
+}
+
+void
+Context::release_interrupt_guard_condition(rcl_wait_set_t * wait_set)
+{
+  std::lock_guard<std::mutex> lock(interrupt_guard_cond_handles_mutex_);
+  auto kv = interrupt_guard_cond_handles_.find(wait_set);
+  if (kv != interrupt_guard_cond_handles_.end()) {
+    rcl_ret_t ret = rcl_guard_condition_fini(&kv->second);
+    if (RCL_RET_OK != ret) {
+      rclcpp::exceptions::throw_from_rcl_error(ret, "Failed to destroy sigint guard condition");
+    }
+    interrupt_guard_cond_handles_.erase(kv);
+  } else {
+    throw std::runtime_error("Tried to release sigint guard condition for nonexistent wait set");
+  }
+}
+
+void
+Context::release_interrupt_guard_condition(
+  rcl_wait_set_t * wait_set,
+  const std::nothrow_t &) noexcept
+{
+  try {
+    this->release_interrupt_guard_condition(wait_set);
+  } catch (const std::exception & exc) {
+    RCLCPP_ERROR(
+      rclcpp::get_logger("rclcpp"),
+      "caught %s exception when releasing interrupt guard condition: %s",
+      rmw::impl::cpp::demangle(exc).c_str(), exc.what());
+  } catch (...) {
+    RCLCPP_ERROR(
+      rclcpp::get_logger("rclcpp"),
+      "caught unknown exception when releasing interrupt guard condition");
+  }
+}
+
+void
+Context::interrupt_all_wait_sets()
+{
+  std::lock_guard<std::mutex> lock(interrupt_guard_cond_handles_mutex_);
+  for (auto & kv : interrupt_guard_cond_handles_) {
+    rcl_ret_t status = rcl_trigger_guard_condition(&(kv.second));
+    if (status != RCL_RET_OK) {
+      RCUTILS_LOG_ERROR_NAMED(
+        "rclcpp",
+        "failed to trigger guard condition in Context::interrupt_all_wait_sets(): %s",
+        rcl_get_error_string().str);
+    }
+  }
+}
+
 void
 Context::clean_up()
 {

rclcpp/src/rclcpp/detail/mutex_two_priorities.cpp

@@ -1,75 +0,0 @@
-// Copyright 2021 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/mutex_two_priorities.hpp"
-
-#include <mutex>
-
-namespace rclcpp
-{
-namespace detail
-{
-
-using LowPriorityLockable = MutexTwoPriorities::LowPriorityLockable;
-using HighPriorityLockable = MutexTwoPriorities::HighPriorityLockable;
-
-HighPriorityLockable::HighPriorityLockable(MutexTwoPriorities & parent)
-: parent_(parent)
-{}
-
-void
-HighPriorityLockable::lock()
-{
-  parent_.data_.lock();
-}
-
-void
-HighPriorityLockable::unlock()
-{
-  parent_.data_.unlock();
-}
-
-LowPriorityLockable::LowPriorityLockable(MutexTwoPriorities & parent)
-: parent_(parent)
-{}
-
-void
-LowPriorityLockable::lock()
-{
-  std::unique_lock<std::mutex> barrier_guard{parent_.barrier_};
-  parent_.data_.lock();
-  barrier_guard.release();
-}
-
-void
-LowPriorityLockable::unlock()
-{
-  std::lock_guard<std::mutex> barrier_guard{parent_.barrier_, std::adopt_lock};
-  parent_.data_.unlock();
-}
-
-HighPriorityLockable
-MutexTwoPriorities::get_high_priority_lockable()
-{
-  return HighPriorityLockable{*this};
-}
-
-LowPriorityLockable
-MutexTwoPriorities::get_low_priority_lockable()
-{
-  return LowPriorityLockable{*this};
-}
-
-}  // namespace detail
-}  // namespace rclcpp

rclcpp/src/rclcpp/detail/resolve_parameter_overrides.cpp

@@ -1,77 +0,0 @@
-// Copyright 2021 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 "./resolve_parameter_overrides.hpp"
-
-#include <string>
-#include <map>
-#include <vector>
-
-#include "rcl_yaml_param_parser/parser.h"
-
-#include "rclcpp/scope_exit.hpp"
-#include "rclcpp/parameter_map.hpp"
-
-std::map<std::string, rclcpp::ParameterValue>
-rclcpp::detail::resolve_parameter_overrides(
-  const std::string & node_fqn,
-  const std::vector<rclcpp::Parameter> & parameter_overrides,
-  const rcl_arguments_t * local_args,
-  const rcl_arguments_t * global_args)
-{
-  std::map<std::string, rclcpp::ParameterValue> result;
-
-  // global before local so that local overwrites global
-  std::array<const rcl_arguments_t *, 2> argument_sources = {global_args, local_args};
-
-  // Get fully qualified node name post-remapping to use to find node's params in yaml files
-
-  for (const rcl_arguments_t * source : argument_sources) {
-    if (!source) {
-      continue;
-    }
-    rcl_params_t * params = NULL;
-    rcl_ret_t ret = rcl_arguments_get_param_overrides(source, &params);
-    if (RCL_RET_OK != ret) {
-      rclcpp::exceptions::throw_from_rcl_error(ret);
-    }
-    if (params) {
-      auto cleanup_params = make_scope_exit(
-        [params]() {
-          rcl_yaml_node_struct_fini(params);
-        });
-      rclcpp::ParameterMap initial_map = rclcpp::parameter_map_from(params);
-
-      // Enforce wildcard matching precedence
-      // TODO(cottsay) implement further wildcard matching
-      const std::array<std::string, 2> node_matching_names{"/**", node_fqn};
-      for (const auto & node_name : node_matching_names) {
-        if (initial_map.count(node_name) > 0) {
-          // Combine parameter yaml files, overwriting values in older ones
-          for (const rclcpp::Parameter & param : initial_map.at(node_name)) {
-            result[param.get_name()] =
-              rclcpp::ParameterValue(param.get_value_message());
-          }
-        }
-      }
-    }
-  }
-
-  // parameter overrides passed to constructor will overwrite overrides from yaml file sources
-  for (auto & param : parameter_overrides) {
-    result[param.get_name()] =
-      rclcpp::ParameterValue(param.get_value_message());
-  }
-  return result;
-}

rclcpp/src/rclcpp/detail/resolve_parameter_overrides.hpp

@@ -1,44 +0,0 @@
-// Copyright 2021 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__DETAIL__RESOLVE_PARAMETER_OVERRIDES_HPP_
-#define RCLCPP__DETAIL__RESOLVE_PARAMETER_OVERRIDES_HPP_
-
-#include <string>
-#include <map>
-#include <vector>
-
-#include "rcl/arguments.h"
-
-#include "rclcpp/parameter.hpp"
-#include "rclcpp/parameter_value.hpp"
-#include "rclcpp/visibility_control.hpp"
-
-namespace rclcpp
-{
-namespace detail
-{
-/// \internal Get the parameter overrides from the arguments.
-RCLCPP_LOCAL
-std::map<std::string, rclcpp::ParameterValue>
-resolve_parameter_overrides(
-  const std::string & node_name,
-  const std::vector<rclcpp::Parameter> & parameter_overrides,
-  const rcl_arguments_t * local_args,
-  const rcl_arguments_t * global_args);
-
-}  // namespace detail
-}  // namespace rclcpp
-
-#endif  // RCLCPP__DETAIL__RESOLVE_PARAMETER_OVERRIDES_HPP_

rclcpp/src/rclcpp/duration.cpp

@@ -37,7 +37,7 @@ Duration::Duration(int32_t seconds, uint32_t nanoseconds)
   rcl_duration_.nanoseconds += nanoseconds;
 }
 
-Duration::Duration(rcl_duration_value_t nanoseconds)
+Duration::Duration(int64_t nanoseconds)
 {
   rcl_duration_.nanoseconds = nanoseconds;
 }
@@ -67,27 +67,13 @@ Duration::operator builtin_interfaces::msg::Duration() const
 {
   builtin_interfaces::msg::Duration msg_duration;
   constexpr rcl_duration_value_t kDivisor = RCL_S_TO_NS(1);
-  constexpr int32_t max_s = std::numeric_limits<int32_t>::max();
-  constexpr int32_t min_s = std::numeric_limits<int32_t>::min();
-  constexpr uint32_t max_ns = std::numeric_limits<uint32_t>::max();
   const auto result = std::div(rcl_duration_.nanoseconds, kDivisor);
   if (result.rem >= 0) {
-    // saturate if we will overflow
-    if (result.quot > max_s) {
-      msg_duration.sec = max_s;
-      msg_duration.nanosec = max_ns;
-    } else {
-      msg_duration.sec = static_cast<int32_t>(result.quot);
-      msg_duration.nanosec = static_cast<uint32_t>(result.rem);
-    }
+    msg_duration.sec = static_cast<std::int32_t>(result.quot);
+    msg_duration.nanosec = static_cast<std::uint32_t>(result.rem);
   } else {
-    if (result.quot <= min_s) {
-      msg_duration.sec = min_s;
-      msg_duration.nanosec = 0u;
-    } else {
-      msg_duration.sec = static_cast<int32_t>(result.quot - 1);
-      msg_duration.nanosec = static_cast<uint32_t>(kDivisor + result.rem);
-    }
+    msg_duration.sec = static_cast<std::int32_t>(result.quot - 1);
+    msg_duration.nanosec = static_cast<std::uint32_t>(kDivisor + result.rem);
   }
   return msg_duration;
 }
@@ -162,7 +148,7 @@ Duration::operator+(const rclcpp::Duration & rhs) const
     this->rcl_duration_.nanoseconds,
     rhs.rcl_duration_.nanoseconds,
     std::numeric_limits<rcl_duration_value_t>::max());
-  return Duration::from_nanoseconds(
+  return Duration(
     rcl_duration_.nanoseconds + rhs.rcl_duration_.nanoseconds);
 }
 
@@ -191,7 +177,7 @@ Duration::operator-(const rclcpp::Duration & rhs) const
     rhs.rcl_duration_.nanoseconds,
     std::numeric_limits<rcl_duration_value_t>::max());
 
-  return Duration::from_nanoseconds(
+  return Duration(
     rcl_duration_.nanoseconds - rhs.rcl_duration_.nanoseconds);
 }
 
@@ -222,7 +208,7 @@ Duration::operator*(double scale) const
     scale,
     std::numeric_limits<rcl_duration_value_t>::max());
   long double scale_ld = static_cast<long double>(scale);
-  return Duration::from_nanoseconds(
+  return Duration(
     static_cast<rcl_duration_value_t>(
       static_cast<long double>(rcl_duration_.nanoseconds) * scale_ld));
 }
@@ -252,52 +238,18 @@ Duration::to_rmw_time() const
     throw std::runtime_error("rmw_time_t cannot be negative");
   }
 
-  // Purposefully avoid creating from builtin_interfaces::msg::Duration
-  // to avoid possible overflow converting from int64_t to int32_t, then back to uint64_t
+  // reuse conversion logic from msg creation
+  builtin_interfaces::msg::Duration msg = *this;
   rmw_time_t result;
-  constexpr rcl_duration_value_t kDivisor = RCL_S_TO_NS(1);
-  const auto div_result = std::div(rcl_duration_.nanoseconds, kDivisor);
-  result.sec = static_cast<uint64_t>(div_result.quot);
-  result.nsec = static_cast<uint64_t>(div_result.rem);
-
+  result.sec = static_cast<uint64_t>(msg.sec);
+  result.nsec = static_cast<uint64_t>(msg.nanosec);
   return result;
 }
 
-Duration
-Duration::from_rmw_time(rmw_time_t duration)
-{
-  Duration ret;
-  constexpr rcl_duration_value_t limit_ns = std::numeric_limits<rcl_duration_value_t>::max();
-  constexpr rcl_duration_value_t limit_sec = RCL_NS_TO_S(limit_ns);
-  if (duration.sec > limit_sec || duration.nsec > limit_ns) {
-    // saturate if will overflow
-    ret.rcl_duration_.nanoseconds = limit_ns;
-    return ret;
-  }
-  uint64_t total_ns = RCL_S_TO_NS(duration.sec) + duration.nsec;
-  if (total_ns > limit_ns) {
-    // saturate if will overflow
-    ret.rcl_duration_.nanoseconds = limit_ns;
-    return ret;
-  }
-  ret.rcl_duration_.nanoseconds = static_cast<rcl_duration_value_t>(total_ns);
-  return ret;
-}
-
 Duration
 Duration::from_seconds(double seconds)
 {
-  Duration ret;
-  ret.rcl_duration_.nanoseconds = static_cast<int64_t>(RCL_S_TO_NS(seconds));
-  return ret;
-}
-
-Duration
-Duration::from_nanoseconds(rcl_duration_value_t nanoseconds)
-{
-  Duration ret;
-  ret.rcl_duration_.nanoseconds = nanoseconds;
-  return ret;
+  return Duration(static_cast<int64_t>(RCL_S_TO_NS(seconds)));
 }
 
 }  // namespace rclcpp

rclcpp/src/rclcpp/executor.cpp

@@ -25,8 +25,6 @@
 
 #include "rclcpp/exceptions.hpp"
 #include "rclcpp/executor.hpp"
-#include "rclcpp/guard_condition.hpp"
-#include "rclcpp/memory_strategy.hpp"
 #include "rclcpp/node.hpp"
 #include "rclcpp/scope_exit.hpp"
 #include "rclcpp/utilities.hpp"
@@ -43,35 +41,28 @@ using rclcpp::FutureReturnCode;
 
 Executor::Executor(const rclcpp::ExecutorOptions & options)
 : spinning(false),
-  shutdown_guard_condition_(std::make_shared<rclcpp::GuardCondition>(options.context)),
   memory_strategy_(options.memory_strategy)
 {
-  // Store the context for later use.
-  context_ = options.context;
-
   rcl_guard_condition_options_t guard_condition_options = rcl_guard_condition_get_default_options();
   rcl_ret_t ret = rcl_guard_condition_init(
-    &interrupt_guard_condition_, context_->get_rcl_context().get(), guard_condition_options);
+    &interrupt_guard_condition_, options.context->get_rcl_context().get(), guard_condition_options);
   if (RCL_RET_OK != ret) {
     throw_from_rcl_error(ret, "Failed to create interrupt guard condition in Executor constructor");
   }
 
-  context_->on_shutdown(
-    [weak_gc = std::weak_ptr<rclcpp::GuardCondition>{shutdown_guard_condition_}]() {
-      auto strong_gc = weak_gc.lock();
-      if (strong_gc) {
-        strong_gc->trigger();
-      }
-    });
-
   // The number of guard conditions is always at least 2: 1 for the ctrl-c guard cond,
   // and one for the executor's guard cond (interrupt_guard_condition_)
-  memory_strategy_->add_guard_condition(&shutdown_guard_condition_->get_rcl_guard_condition());
+
+  // Put the global ctrl-c guard condition in
+  memory_strategy_->add_guard_condition(options.context->get_interrupt_guard_condition(&wait_set_));
 
   // Put the executor's guard condition in
   memory_strategy_->add_guard_condition(&interrupt_guard_condition_);
   rcl_allocator_t allocator = memory_strategy_->get_allocator();
 
+  // Store the context for later use.
+  context_ = options.context;
+
   ret = rcl_wait_set_init(
     &wait_set_,
     0, 2, 0, 0, 0, 0,
@@ -137,14 +128,14 @@ Executor::~Executor()
     rcl_reset_error();
   }
   // Remove and release the sigint guard condition
-  memory_strategy_->remove_guard_condition(&shutdown_guard_condition_->get_rcl_guard_condition());
+  memory_strategy_->remove_guard_condition(context_->get_interrupt_guard_condition(&wait_set_));
+  context_->release_interrupt_guard_condition(&wait_set_, std::nothrow);
 }
 
 std::vector<rclcpp::CallbackGroup::WeakPtr>
 Executor::get_all_callback_groups()
 {
   std::vector<rclcpp::CallbackGroup::WeakPtr> groups;
-  std::lock_guard<std::mutex> guard{mutex_};
   for (const auto & group_node_ptr : weak_groups_associated_with_executor_to_nodes_) {
     groups.push_back(group_node_ptr.first);
   }
@@ -158,7 +149,6 @@ std::vector<rclcpp::CallbackGroup::WeakPtr>
 Executor::get_manually_added_callback_groups()
 {
   std::vector<rclcpp::CallbackGroup::WeakPtr> groups;
-  std::lock_guard<std::mutex> guard{mutex_};
   for (auto const & group_node_ptr : weak_groups_associated_with_executor_to_nodes_) {
     groups.push_back(group_node_ptr.first);
   }
@@ -169,7 +159,6 @@ std::vector<rclcpp::CallbackGroup::WeakPtr>
 Executor::get_automatically_added_callback_groups_from_nodes()
 {
   std::vector<rclcpp::CallbackGroup::WeakPtr> groups;
-  std::lock_guard<std::mutex> guard{mutex_};
   for (auto const & group_node_ptr : weak_groups_to_nodes_associated_with_executor_) {
     groups.push_back(group_node_ptr.first);
   }
@@ -206,7 +195,7 @@ void
 Executor::add_callback_group_to_map(
   rclcpp::CallbackGroup::SharedPtr group_ptr,
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
-  rclcpp::memory_strategy::MemoryStrategy::WeakCallbackGroupsToNodesMap & weak_groups_to_nodes,
+  WeakCallbackGroupsToNodesMap & weak_groups_to_nodes,
   bool notify)
 {
   // If the callback_group already has an executor
@@ -236,6 +225,7 @@ Executor::add_callback_group_to_map(
       }
     }
     // Add the node's notify condition to the guard condition handles
+    std::unique_lock<std::mutex> lock(memory_strategy_mutex_);
     memory_strategy_->add_guard_condition(node_ptr->get_notify_guard_condition());
   }
 }
@@ -246,7 +236,6 @@ Executor::add_callback_group(
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
   bool notify)
 {
-  std::lock_guard<std::mutex> guard{mutex_};
   this->add_callback_group_to_map(
     group_ptr,
     node_ptr,
@@ -262,7 +251,6 @@ Executor::add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_pt
   if (has_executor.exchange(true)) {
     throw std::runtime_error("Node has already been added to an executor.");
   }
-  std::lock_guard<std::mutex> guard{mutex_};
   for (auto & weak_group : node_ptr->get_callback_groups()) {
     auto group_ptr = weak_group.lock();
     if (group_ptr != nullptr && !group_ptr->get_associated_with_executor_atomic().load() &&
@@ -281,7 +269,7 @@ Executor::add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_pt
 void
 Executor::remove_callback_group_from_map(
   rclcpp::CallbackGroup::SharedPtr group_ptr,
-  rclcpp::memory_strategy::MemoryStrategy::WeakCallbackGroupsToNodesMap & weak_groups_to_nodes,
+  WeakCallbackGroupsToNodesMap & weak_groups_to_nodes,
   bool notify)
 {
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr;
@@ -311,6 +299,7 @@ Executor::remove_callback_group_from_map(
         throw_from_rcl_error(ret, "Failed to trigger guard condition on callback group remove");
       }
     }
+    std::unique_lock<std::mutex> lock(memory_strategy_mutex_);
     memory_strategy_->remove_guard_condition(node_ptr->get_notify_guard_condition());
   }
 }
@@ -320,7 +309,6 @@ Executor::remove_callback_group(
   rclcpp::CallbackGroup::SharedPtr group_ptr,
   bool notify)
 {
-  std::lock_guard<std::mutex> guard{mutex_};
   this->remove_callback_group_from_map(
     group_ptr,
     weak_groups_associated_with_executor_to_nodes_,
@@ -340,7 +328,6 @@ Executor::remove_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node
     throw std::runtime_error("Node needs to be associated with an executor.");
   }
 
-  std::lock_guard<std::mutex> guard{mutex_};
   bool found_node = false;
   auto node_it = weak_nodes_.begin();
   while (node_it != weak_nodes_.end()) {
@@ -355,24 +342,27 @@ Executor::remove_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node
   if (!found_node) {
     throw std::runtime_error("Node needs to be associated with this executor.");
   }
-
-  for (auto it = weak_groups_to_nodes_associated_with_executor_.begin();
-    it != weak_groups_to_nodes_associated_with_executor_.end(); )
-  {
-    auto weak_node_ptr = it->second;
-    auto shared_node_ptr = weak_node_ptr.lock();
-    auto group_ptr = it->first.lock();
-
-    // Increment iterator before removing in case it's invalidated
-    it++;
-    if (shared_node_ptr == node_ptr) {
+  std::vector<rclcpp::CallbackGroup::SharedPtr> found_group_ptrs;
+  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) {
+      auto weak_node_ptr = key_value_pair.second;
+      auto shared_node_ptr = weak_node_ptr.lock();
+      auto group_ptr = key_value_pair.first.lock();
+      if (shared_node_ptr == node_ptr) {
+        found_group_ptrs.push_back(group_ptr);
+      }
+    });
+  std::for_each(
+    found_group_ptrs.begin(), found_group_ptrs.end(), [this, notify]
+      (rclcpp::CallbackGroup::SharedPtr group_ptr) {
       remove_callback_group_from_map(
         group_ptr,
         weak_groups_to_nodes_associated_with_executor_,
         notify);
-    }
-  }
-
+    });
   std::atomic_bool & has_executor = node_ptr->get_associated_with_executor_atomic();
   has_executor.store(false);
 }
@@ -494,7 +484,6 @@ Executor::set_memory_strategy(rclcpp::memory_strategy::MemoryStrategy::SharedPtr
   if (memory_strategy == nullptr) {
     throw std::runtime_error("Received NULL memory strategy in executor.");
   }
-  std::lock_guard<std::mutex> guard{mutex_};
   memory_strategy_ = memory_strategy;
 }
 
@@ -517,7 +506,7 @@ Executor::execute_any_executable(AnyExecutable & any_exec)
     execute_client(any_exec.client);
   }
   if (any_exec.waitable) {
-    any_exec.waitable->execute(any_exec.data);
+    any_exec.waitable->execute();
   }
   // Reset the callback_group, regardless of type
   any_exec.callback_group->can_be_taken_from().store(true);
@@ -668,7 +657,7 @@ void
 Executor::wait_for_work(std::chrono::nanoseconds timeout)
 {
   {
-    std::lock_guard<std::mutex> guard(mutex_);
+    std::unique_lock<std::mutex> lock(memory_strategy_mutex_);
 
     // Check weak_nodes_ to find any callback group that is not owned
     // by an executor and add it to the list of callbackgroups for
@@ -689,11 +678,8 @@ Executor::wait_for_work(std::chrono::nanoseconds timeout)
         if (weak_group_ptr.expired() || weak_node_ptr.expired()) {
           invalid_group_ptrs.push_back(weak_group_ptr);
           auto node_guard_pair = weak_nodes_to_guard_conditions_.find(weak_node_ptr);
-          if (node_guard_pair != weak_nodes_to_guard_conditions_.end()) {
-            auto guard_condition = node_guard_pair->second;
-            weak_nodes_to_guard_conditions_.erase(weak_node_ptr);
-            memory_strategy_->remove_guard_condition(guard_condition);
-          }
+          weak_nodes_to_guard_conditions_.erase(weak_node_ptr);
+          memory_strategy_->remove_guard_condition(node_guard_pair->second);
         }
       }
       std::for_each(
@@ -747,14 +733,12 @@ Executor::wait_for_work(std::chrono::nanoseconds timeout)
 
   // check the null handles in the wait set and remove them from the handles in memory strategy
   // for callback-based entities
-  std::lock_guard<std::mutex> guard(mutex_);
   memory_strategy_->remove_null_handles(&wait_set_);
 }
 
 rclcpp::node_interfaces::NodeBaseInterface::SharedPtr
 Executor::get_node_by_group(
-  const rclcpp::memory_strategy::MemoryStrategy::WeakCallbackGroupsToNodesMap &
-  weak_groups_to_nodes,
+  WeakCallbackGroupsToNodesMap weak_groups_to_nodes,
   rclcpp::CallbackGroup::SharedPtr group)
 {
   if (!group) {
@@ -772,7 +756,6 @@ Executor::get_node_by_group(
 rclcpp::CallbackGroup::SharedPtr
 Executor::get_group_by_timer(rclcpp::TimerBase::SharedPtr timer)
 {
-  std::lock_guard<std::mutex> guard{mutex_};
   for (const auto & pair : weak_groups_associated_with_executor_to_nodes_) {
     auto group = pair.first.lock();
     if (!group) {
@@ -813,11 +796,9 @@ Executor::get_next_ready_executable(AnyExecutable & any_executable)
 bool
 Executor::get_next_ready_executable_from_map(
   AnyExecutable & any_executable,
-  const rclcpp::memory_strategy::MemoryStrategy::WeakCallbackGroupsToNodesMap &
-  weak_groups_to_nodes)
+  WeakCallbackGroupsToNodesMap weak_groups_to_nodes)
 {
   bool success = false;
-  std::lock_guard<std::mutex> guard{mutex_};
   // Check the timers to see if there are any that are ready
   memory_strategy_->get_next_timer(any_executable, weak_groups_to_nodes);
   if (any_executable.timer) {
@@ -848,7 +829,6 @@ Executor::get_next_ready_executable_from_map(
     // Check the waitables to see if there are any that are ready
     memory_strategy_->get_next_waitable(any_executable, weak_groups_to_nodes);
     if (any_executable.waitable) {
-      any_executable.data = any_executable.waitable->take_data();
       success = true;
     }
   }
@@ -904,8 +884,7 @@ Executor::get_next_executable(AnyExecutable & any_executable, std::chrono::nanos
 bool
 Executor::has_node(
   const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
-  const rclcpp::memory_strategy::MemoryStrategy::WeakCallbackGroupsToNodesMap &
-  weak_groups_to_nodes) const
+  WeakCallbackGroupsToNodesMap weak_groups_to_nodes) const
 {
   return std::find_if(
     weak_groups_to_nodes.begin(),

rclcpp/src/rclcpp/executors/multi_threaded_executor.cpp

@@ -22,7 +22,6 @@
 #include "rclcpp/utilities.hpp"
 #include "rclcpp/scope_exit.hpp"
 
-using rclcpp::detail::MutexTwoPriorities;
 using rclcpp::executors::MultiThreadedExecutor;
 
 MultiThreadedExecutor::MultiThreadedExecutor(
@@ -52,8 +51,7 @@ MultiThreadedExecutor::spin()
   std::vector<std::thread> threads;
   size_t thread_id = 0;
   {
-    auto low_priority_wait_mutex = wait_mutex_.get_low_priority_lockable();
-    std::lock_guard<MutexTwoPriorities::LowPriorityLockable> wait_lock(low_priority_wait_mutex);
+    std::lock_guard<std::mutex> wait_lock(wait_mutex_);
     for (; thread_id < number_of_threads_ - 1; ++thread_id) {
       auto func = std::bind(&MultiThreadedExecutor::run, this, thread_id);
       threads.emplace_back(func);
@@ -78,8 +76,7 @@ MultiThreadedExecutor::run(size_t)
   while (rclcpp::ok(this->context_) && spinning.load()) {
     rclcpp::AnyExecutable any_exec;
     {
-      auto low_priority_wait_mutex = wait_mutex_.get_low_priority_lockable();
-      std::lock_guard<MutexTwoPriorities::LowPriorityLockable> wait_lock(low_priority_wait_mutex);
+      std::lock_guard<std::mutex> wait_lock(wait_mutex_);
       if (!rclcpp::ok(this->context_) || !spinning.load()) {
         return;
       }
@@ -106,8 +103,7 @@ MultiThreadedExecutor::run(size_t)
     execute_any_executable(any_exec);
 
     if (any_exec.timer) {
-      auto high_priority_wait_mutex = wait_mutex_.get_high_priority_lockable();
-      std::lock_guard<MutexTwoPriorities::HighPriorityLockable> wait_lock(high_priority_wait_mutex);
+      std::lock_guard<std::mutex> wait_lock(wait_mutex_);
       auto it = scheduled_timers_.find(any_exec.timer);
       if (it != scheduled_timers_.end()) {
         scheduled_timers_.erase(it);

rclcpp/src/rclcpp/executors/static_executor_entities_collector.cpp

@@ -77,8 +77,7 @@ StaticExecutorEntitiesCollector::init(
   // Add executor's guard condition
   memory_strategy_->add_guard_condition(executor_guard_condition);
   // Get memory strategy and executable list. Prepare wait_set_
-  std::shared_ptr<void> shared_ptr;
-  execute(shared_ptr);
+  execute();
 }
 
 void
@@ -88,16 +87,9 @@ StaticExecutorEntitiesCollector::fini()
   exec_list_.clear();
 }
 
-std::shared_ptr<void>
-StaticExecutorEntitiesCollector::take_data()
-{
-  return nullptr;
-}
-
 void
-StaticExecutorEntitiesCollector::execute(std::shared_ptr<void> & data)
+StaticExecutorEntitiesCollector::execute()
 {
-  (void) data;
   // Fill memory strategy with entities coming from weak_nodes_
   fill_memory_strategy();
   // Fill exec_list_ with entities coming from weak_nodes_ (same as memory strategy)
@@ -163,8 +155,7 @@ StaticExecutorEntitiesCollector::fill_executable_list()
 }
 void
 StaticExecutorEntitiesCollector::fill_executable_list_from_map(
-  const rclcpp::memory_strategy::MemoryStrategy::WeakCallbackGroupsToNodesMap &
-  weak_groups_to_nodes)
+  const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes)
 {
   for (const auto & pair : weak_groups_to_nodes) {
     auto group = pair.first.lock();
@@ -306,7 +297,7 @@ bool
 StaticExecutorEntitiesCollector::add_callback_group(
   rclcpp::CallbackGroup::SharedPtr group_ptr,
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
-  rclcpp::memory_strategy::MemoryStrategy::WeakCallbackGroupsToNodesMap & weak_groups_to_nodes)
+  WeakCallbackGroupsToNodesMap & weak_groups_to_nodes)
 {
   // If the callback_group already has an executor
   std::atomic_bool & has_executor = group_ptr->get_associated_with_executor_atomic();
@@ -323,7 +314,8 @@ StaticExecutorEntitiesCollector::add_callback_group(
     throw std::runtime_error("Callback group was already added to executor.");
   }
   if (is_new_node) {
-    weak_nodes_to_guard_conditions_[node_ptr] = node_ptr->get_notify_guard_condition();
+    rclcpp::node_interfaces::NodeBaseInterface::WeakPtr node_weak_ptr(node_ptr);
+    weak_nodes_to_guard_conditions_[node_weak_ptr] = node_ptr->get_notify_guard_condition();
     return true;
   }
   return false;
@@ -349,7 +341,7 @@ StaticExecutorEntitiesCollector::remove_callback_group(
 bool
 StaticExecutorEntitiesCollector::remove_callback_group_from_map(
   rclcpp::CallbackGroup::SharedPtr group_ptr,
-  rclcpp::memory_strategy::MemoryStrategy::WeakCallbackGroupsToNodesMap & weak_groups_to_nodes)
+  WeakCallbackGroupsToNodesMap & weak_groups_to_nodes)
 {
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr;
   rclcpp::CallbackGroup::WeakPtr weak_group_ptr = group_ptr;
@@ -445,8 +437,7 @@ StaticExecutorEntitiesCollector::is_ready(rcl_wait_set_t * p_wait_set)
 bool
 StaticExecutorEntitiesCollector::has_node(
   const rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
-  const rclcpp::memory_strategy::MemoryStrategy::WeakCallbackGroupsToNodesMap &
-  weak_groups_to_nodes) const
+  const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes) const
 {
   return std::find_if(
     weak_groups_to_nodes.begin(),

rclcpp/src/rclcpp/executors/static_single_threaded_executor.cpp

@@ -175,10 +175,8 @@ StaticSingleThreadedExecutor::execute_ready_executables()
   }
   // Execute all the ready waitables
   for (size_t i = 0; i < entities_collector_->get_number_of_waitables(); ++i) {
-    auto waitable = entities_collector_->get_waitable(i);
-    if (waitable->is_ready(&wait_set_)) {
-      auto data = waitable->take_data();
-      waitable->execute(data);
+    if (entities_collector_->get_waitable(i)->is_ready(&wait_set_)) {
+      entities_collector_->get_waitable(i)->execute();
     }
   }
 }

rclcpp/src/rclcpp/graph_listener.cpp

@@ -36,11 +36,11 @@ namespace rclcpp
 namespace graph_listener
 {
 
-GraphListener::GraphListener(const std::shared_ptr<Context> & parent_context)
-: weak_parent_context_(parent_context),
-  rcl_parent_context_(parent_context->get_rcl_context()),
+GraphListener::GraphListener(std::shared_ptr<rclcpp::Context> parent_context)
+: parent_context_(parent_context),
   is_started_(false),
-  is_shutdown_(false)
+  is_shutdown_(false),
+  shutdown_guard_condition_(nullptr)
 {
   // TODO(wjwwood): make a guard condition class in rclcpp so this can be tracked
   //   automatically with the rcl guard condition
@@ -48,11 +48,13 @@ GraphListener::GraphListener(const std::shared_ptr<Context> & parent_context)
   // guard condition is using it.
   rcl_ret_t ret = rcl_guard_condition_init(
     &interrupt_guard_condition_,
-    rcl_parent_context_.get(),
+    parent_context->get_rcl_context().get(),
     rcl_guard_condition_get_default_options());
   if (RCL_RET_OK != ret) {
     throw_from_rcl_error(ret, "failed to create interrupt guard condition");
   }
+
+  shutdown_guard_condition_ = parent_context->get_interrupt_guard_condition(&wait_set_);
 }
 
 GraphListener::~GraphListener()
@@ -60,23 +62,6 @@ GraphListener::~GraphListener()
   this->shutdown(std::nothrow);
 }
 
-void GraphListener::init_wait_set()
-{
-  rcl_ret_t ret = rcl_wait_set_init(
-    &wait_set_,
-    0,  // number_of_subscriptions
-    2,  // number_of_guard_conditions
-    0,  // number_of_timers
-    0,  // number_of_clients
-    0,  // number_of_services
-    0,  // number_of_events
-    rcl_parent_context_.get(),
-    rcl_get_default_allocator());
-  if (RCL_RET_OK != ret) {
-    throw_from_rcl_error(ret, "failed to initialize wait set");
-  }
-}
-
 void
 GraphListener::start_if_not_started()
 {
@@ -84,13 +69,30 @@ GraphListener::start_if_not_started()
   if (is_shutdown_.load()) {
     throw GraphListenerShutdownError();
   }
-  auto parent_context = weak_parent_context_.lock();
-  if (!is_started_ && parent_context) {
+  if (!is_started_) {
+    // Initialize the wait set before starting.
+    auto parent_context = parent_context_.lock();
+    if (!parent_context) {
+      throw std::runtime_error("parent context was destroyed");
+    }
+    rcl_ret_t ret = rcl_wait_set_init(
+      &wait_set_,
+      0,  // number_of_subscriptions
+      2,  // number_of_guard_conditions
+      0,  // number_of_timers
+      0,  // number_of_clients
+      0,  // number_of_services
+      0,  // number_of_events
+      parent_context->get_rcl_context().get(),
+      rcl_get_default_allocator());
+    if (RCL_RET_OK != ret) {
+      throw_from_rcl_error(ret, "failed to initialize wait set");
+    }
     // Register an on_shutdown hook to shtudown the graph listener.
     // This is important to ensure that the wait set is finalized before
     // destruction of static objects occurs.
     std::weak_ptr<GraphListener> weak_this = shared_from_this();
-    parent_context->on_shutdown(
+    rclcpp::on_shutdown(
       [weak_this]() {
         auto shared_this = weak_this.lock();
         if (shared_this) {
@@ -98,8 +100,6 @@ GraphListener::start_if_not_started()
           shared_this->shutdown(std::nothrow);
         }
       });
-    // Initialize the wait set before starting.
-    init_wait_set();
     // Start the listener thread.
     listener_thread_ = std::thread(&GraphListener::run, this);
     is_started_ = true;
@@ -144,6 +144,14 @@ GraphListener::run_loop()
     }
     // This lock is released when the loop continues or exits.
     std::lock_guard<std::mutex> nodes_lock(node_graph_interfaces_mutex_, std::adopt_lock);
+    // Ensure that the context doesn't go out of scope.
+    auto parent_context = parent_context_.lock();
+    if (!parent_context) {
+      // The parent context may be destroyed before this loop is stopped.
+      // In that case, the loop is broken and the function just returns silently.
+      return;
+    }
+
     // Resize the wait set if necessary.
     const size_t node_graph_interfaces_size = node_graph_interfaces_.size();
     // Add 2 for the interrupt and shutdown guard conditions
@@ -163,7 +171,13 @@ GraphListener::run_loop()
     if (RCL_RET_OK != ret) {
       throw_from_rcl_error(ret, "failed to add interrupt guard condition to wait set");
     }
-
+    // Put the shutdown guard condition in the wait set.
+    size_t shutdown_guard_condition_index = 0u;
+    ret = rcl_wait_set_add_guard_condition(
+      &wait_set_, shutdown_guard_condition_, &shutdown_guard_condition_index);
+    if (RCL_RET_OK != ret) {
+      throw_from_rcl_error(ret, "failed to add shutdown guard condition to wait set");
+    }
     // Put graph guard conditions for each node into the wait set.
     std::vector<size_t> graph_gc_indexes(node_graph_interfaces_size, 0u);
     for (size_t i = 0u; i < node_graph_interfaces_size; ++i) {
@@ -192,6 +206,9 @@ GraphListener::run_loop()
       throw_from_rcl_error(ret, "failed to wait on wait set");
     }
 
+    // Check to see if the shutdown guard condition has been triggered.
+    bool shutdown_guard_condition_triggered =
+      (shutdown_guard_condition_ == wait_set_.guard_conditions[shutdown_guard_condition_index]);
     // Notify nodes who's guard conditions are set (triggered).
     for (size_t i = 0u; i < node_graph_interfaces_size; ++i) {
       const auto node_ptr = node_graph_interfaces_[i];
@@ -202,7 +219,7 @@ GraphListener::run_loop()
       if (graph_gc == wait_set_.guard_conditions[graph_gc_indexes[i]]) {
         node_ptr->notify_graph_change();
       }
-      if (is_shutdown_) {
+      if (shutdown_guard_condition_triggered) {
         // If shutdown, then notify the node of this as well.
         node_ptr->notify_shutdown();
       }
@@ -334,16 +351,7 @@ GraphListener::remove_node(rclcpp::node_interfaces::NodeGraphInterface * node_gr
 }
 
 void
-GraphListener::cleanup_wait_set()
-{
-  rcl_ret_t ret = rcl_wait_set_fini(&wait_set_);
-  if (RCL_RET_OK != ret) {
-    throw_from_rcl_error(ret, "failed to finalize wait set");
-  }
-}
-
-void
-GraphListener::__shutdown()
+GraphListener::__shutdown(bool should_throw)
 {
   std::lock_guard<std::mutex> shutdown_lock(shutdown_mutex_);
   if (!is_shutdown_.exchange(true)) {
@@ -355,8 +363,33 @@ GraphListener::__shutdown()
     if (RCL_RET_OK != ret) {
       throw_from_rcl_error(ret, "failed to finalize interrupt guard condition");
     }
+    if (shutdown_guard_condition_) {
+      auto parent_context_ptr = parent_context_.lock();
+      if (parent_context_ptr) {
+        if (should_throw) {
+          parent_context_ptr->release_interrupt_guard_condition(&wait_set_);
+        } else {
+          parent_context_ptr->release_interrupt_guard_condition(&wait_set_, std::nothrow);
+        }
+      } else {
+        ret = rcl_guard_condition_fini(shutdown_guard_condition_);
+        if (RCL_RET_OK != ret) {
+          if (should_throw) {
+            throw_from_rcl_error(ret, "failed to finalize shutdown guard condition");
+          } else {
+            RCLCPP_ERROR(
+              rclcpp::get_logger("rclcpp"),
+              "failed to finalize shutdown guard condition");
+          }
+        }
+      }
+      shutdown_guard_condition_ = nullptr;
+    }
     if (is_started_) {
-      cleanup_wait_set();
+      ret = rcl_wait_set_fini(&wait_set_);
+      if (RCL_RET_OK != ret) {
+        throw_from_rcl_error(ret, "failed to finalize wait set");
+      }
     }
   }
 }
@@ -364,14 +397,14 @@ GraphListener::__shutdown()
 void
 GraphListener::shutdown()
 {
-  this->__shutdown();
+  this->__shutdown(true);
 }
 
 void
 GraphListener::shutdown(const std::nothrow_t &) noexcept
 {
   try {
-    this->__shutdown();
+    this->__shutdown(false);
   } catch (const std::exception & exc) {
     RCLCPP_ERROR(
       rclcpp::get_logger("rclcpp"),

rclcpp/src/rclcpp/intra_process_manager.cpp

@@ -157,13 +157,7 @@ IntraProcessManager::get_subscription_intra_process(uint64_t intra_process_subsc
   if (subscription_it == subscriptions_.end()) {
     return nullptr;
   } else {
-    auto subscription = subscription_it->second.subscription.lock();
-    if (subscription) {
-      return subscription;
-    } else {
-      subscriptions_.erase(subscription_it);
-      return nullptr;
-    }
+    return subscription_it->second.subscription;
   }
 }
 

rclcpp/src/rclcpp/logger.cpp

@@ -14,8 +14,6 @@
 
 #include <string>
 
-#include "rcl_logging_interface/rcl_logging_interface.h"
-
 #include "rclcpp/exceptions.hpp"
 #include "rclcpp/logger.hpp"
 #include "rclcpp/logging.hpp"
@@ -40,28 +38,12 @@ get_node_logger(const rcl_node_t * node)
   const char * logger_name = rcl_node_get_logger_name(node);
   if (nullptr == logger_name) {
     auto logger = rclcpp::get_logger("rclcpp");
-    RCLCPP_ERROR(
-      logger, "failed to get logger name from node at address %p",
-      static_cast<void *>(const_cast<rcl_node_t *>(node)));
+    RCLCPP_ERROR(logger, "failed to get logger name from node at address %p", node);
     return logger;
   }
   return rclcpp::get_logger(logger_name);
 }
 
-rcpputils::fs::path
-get_logging_directory()
-{
-  char * log_dir = NULL;
-  auto allocator = rcutils_get_default_allocator();
-  rcl_logging_ret_t ret = rcl_logging_get_logging_directory(allocator, &log_dir);
-  if (RCL_LOGGING_RET_OK != ret) {
-    rclcpp::exceptions::throw_from_rcl_error(ret);
-  }
-  std::string path{log_dir};
-  allocator.deallocate(log_dir, allocator.state);
-  return path;
-}
-
 void
 Logger::set_level(Level level)
 {

rclcpp/src/rclcpp/node.cpp

@@ -13,7 +13,6 @@
 // limitations under the License.
 
 #include <algorithm>
-#include <array>
 #include <limits>
 #include <map>
 #include <memory>
@@ -21,9 +20,6 @@
 #include <utility>
 #include <vector>
 
-#include "rcl/arguments.h"
-
-#include "rclcpp/detail/qos_parameters.hpp"
 #include "rclcpp/exceptions.hpp"
 #include "rclcpp/graph_listener.hpp"
 #include "rclcpp/node.hpp"
@@ -37,12 +33,9 @@
 #include "rclcpp/node_interfaces/node_timers.hpp"
 #include "rclcpp/node_interfaces/node_topics.hpp"
 #include "rclcpp/node_interfaces/node_waitables.hpp"
-#include "rclcpp/qos_overriding_options.hpp"
 
 #include "rmw/validate_namespace.h"
 
-#include "./detail/resolve_parameter_overrides.hpp"
-
 using rclcpp::Node;
 using rclcpp::NodeOptions;
 using rclcpp::exceptions::throw_from_rcl_error;
@@ -101,45 +94,6 @@ Node::Node(
 {
 }
 
-static
-rclcpp::QoS
-get_parameter_events_qos(
-  rclcpp::node_interfaces::NodeBaseInterface & node_base,
-  const rclcpp::NodeOptions & options)
-{
-  auto final_qos = options.parameter_event_qos();
-  const rcl_arguments_t * global_args = nullptr;
-  auto * rcl_options = options.get_rcl_node_options();
-  if (rcl_options->use_global_arguments) {
-    auto context_ptr = node_base.get_context()->get_rcl_context();
-    global_args = &(context_ptr->global_arguments);
-  }
-
-  auto parameter_overrides = rclcpp::detail::resolve_parameter_overrides(
-    node_base.get_fully_qualified_name(),
-    options.parameter_overrides(),
-    &rcl_options->arguments,
-    global_args);
-
-  auto final_topic_name = node_base.resolve_topic_or_service_name("/parameter_events", false);
-  auto prefix = "qos_overrides." + final_topic_name + ".";
-  std::array<rclcpp::QosPolicyKind, 4> policies = {
-    rclcpp::QosPolicyKind::Depth,
-    rclcpp::QosPolicyKind::Durability,
-    rclcpp::QosPolicyKind::History,
-    rclcpp::QosPolicyKind::Reliability,
-  };
-  for (const auto & policy : policies) {
-    auto param_name = prefix + rclcpp::qos_policy_kind_to_cstr(policy);
-    auto it = parameter_overrides.find(param_name);
-    auto value = it != parameter_overrides.end() ?
-      it->second :
-      rclcpp::detail::get_default_qos_param_value(policy, options.parameter_event_qos());
-    rclcpp::detail::apply_qos_override(policy, value, final_qos);
-  }
-  return final_qos;
-}
-
 Node::Node(
   const std::string & node_name,
   const std::string & namespace_,
@@ -172,9 +126,7 @@ Node::Node(
       options.parameter_overrides(),
       options.start_parameter_services(),
       options.start_parameter_event_publisher(),
-      // This is needed in order to apply parameter overrides to the qos profile provided in
-      // options.
-      get_parameter_events_qos(*node_base_, options),
+      options.parameter_event_qos(),
       options.parameter_event_publisher_options(),
       options.allow_undeclared_parameters(),
       options.automatically_declare_parameters_from_overrides()
@@ -194,20 +146,6 @@ Node::Node(
   sub_namespace_(""),
   effective_namespace_(create_effective_namespace(this->get_namespace(), sub_namespace_))
 {
-  // we have got what we wanted directly from the overrides,
-  // but declare the parameters anyway so they are visible.
-  rclcpp::detail::declare_qos_parameters(
-    rclcpp::QosOverridingOptions
-  {
-    QosPolicyKind::Depth,
-    QosPolicyKind::Durability,
-    QosPolicyKind::History,
-    QosPolicyKind::Reliability,
-  },
-    node_parameters_,
-    node_topics_->resolve_topic_name("/parameter_events"),
-    options.parameter_event_qos(),
-    rclcpp::detail::PublisherQosParametersTraits{});
 }
 
 Node::Node(
@@ -247,18 +185,7 @@ Node::Node(
 }
 
 Node::~Node()
-{
-  // release sub-interfaces in an order that allows them to consult with node_base during tear-down
-  node_waitables_.reset();
-  node_time_source_.reset();
-  node_parameters_.reset();
-  node_clock_.reset();
-  node_services_.reset();
-  node_topics_.reset();
-  node_timers_.reset();
-  node_logging_.reset();
-  node_graph_.reset();
-}
+{}
 
 const char *
 Node::get_name() const
@@ -292,24 +219,6 @@ Node::create_callback_group(
   return node_base_->create_callback_group(group_type, automatically_add_to_executor_with_node);
 }
 
-const rclcpp::ParameterValue &
-Node::declare_parameter(const std::string & name)
-{
-#ifndef _WIN32
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#else
-# pragma warning(push)
-# pragma warning(disable: 4996)
-#endif
-  return this->node_parameters_->declare_parameter(name);
-#ifndef _WIN32
-# pragma GCC diagnostic pop
-#else
-# pragma warning(pop)
-#endif
-}
-
 const rclcpp::ParameterValue &
 Node::declare_parameter(
   const std::string & name,
@@ -324,20 +233,6 @@ Node::declare_parameter(
     ignore_override);
 }
 
-const rclcpp::ParameterValue &
-Node::declare_parameter(
-  const std::string & name,
-  rclcpp::ParameterType type,
-  const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor,
-  bool ignore_override)
-{
-  return this->node_parameters_->declare_parameter(
-    name,
-    type,
-    parameter_descriptor,
-    ignore_override);
-}
-
 void
 Node::undeclare_parameter(const std::string & name)
 {

rclcpp/src/rclcpp/node_interfaces/node_base.cpp

@@ -70,7 +70,6 @@ NodeBase::NodeBase(
   std::shared_ptr<std::recursive_mutex> logging_mutex = get_global_logging_mutex();
   {
     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.
@@ -289,24 +288,3 @@ NodeBase::get_enable_topic_statistics_default() const
 {
   return enable_topic_statistics_default_;
 }
-
-std::string
-NodeBase::resolve_topic_or_service_name(
-  const std::string & name, bool is_service, bool only_expand) const
-{
-  char * output_cstr = NULL;
-  auto allocator = rcl_get_default_allocator();
-  rcl_ret_t ret = rcl_node_resolve_name(
-    node_handle_.get(),
-    name.c_str(),
-    allocator,
-    is_service,
-    only_expand,
-    &output_cstr);
-  if (RCL_RET_OK != ret) {
-    throw_from_rcl_error(ret, "failed to resolve name", rcl_get_error_state());
-  }
-  std::string output{output_cstr};
-  allocator.deallocate(output_cstr, allocator.state);
-  return output;
-}

rclcpp/src/rclcpp/node_interfaces/node_parameters.cpp

@@ -16,10 +16,8 @@
 
 #include <rcl_yaml_param_parser/parser.h>
 
-#include <array>
 #include <cmath>
 #include <cstdlib>
-#include <cstring>
 #include <functional>
 #include <limits>
 #include <map>
@@ -36,8 +34,6 @@
 #include "rcutils/logging_macros.h"
 #include "rmw/qos_profiles.h"
 
-#include "../detail/resolve_parameter_overrides.hpp"
-
 using rclcpp::node_interfaces::NodeParameters;
 
 NodeParameters::NodeParameters(
@@ -71,7 +67,6 @@ NodeParameters::NodeParameters(
   }
 
   if (start_parameter_event_publisher) {
-    // TODO(ivanpauno): Qos of the `/parameters_event` topic should be somehow overridable.
     events_publisher_ = rclcpp::create_publisher<MessageT, AllocatorT, PublisherT>(
       node_topics,
       "/parameter_events",
@@ -89,27 +84,60 @@ NodeParameters::NodeParameters(
     throw std::runtime_error("Need valid node options in NodeParameters");
   }
 
-  const rcl_arguments_t * global_args = nullptr;
+  std::vector<const rcl_arguments_t *> argument_sources;
+  // global before local so that local overwrites global
   if (options->use_global_arguments) {
     auto context_ptr = node_base->get_context()->get_rcl_context();
-    global_args = &(context_ptr->global_arguments);
+    argument_sources.push_back(&(context_ptr->global_arguments));
   }
+  argument_sources.push_back(&options->arguments);
+
+  // Get fully qualified node name post-remapping to use to find node's params in yaml files
   combined_name_ = node_base->get_fully_qualified_name();
 
-  parameter_overrides_ = rclcpp::detail::resolve_parameter_overrides(
-    combined_name_, parameter_overrides, &options->arguments, global_args);
+  for (const rcl_arguments_t * source : argument_sources) {
+    rcl_params_t * params = NULL;
+    rcl_ret_t ret = rcl_arguments_get_param_overrides(source, &params);
+    if (RCL_RET_OK != ret) {
+      rclcpp::exceptions::throw_from_rcl_error(ret);
+    }
+    if (params) {
+      auto cleanup_params = make_scope_exit(
+        [params]() {
+          rcl_yaml_node_struct_fini(params);
+        });
+      rclcpp::ParameterMap initial_map = rclcpp::parameter_map_from(params);
+
+      // Enforce wildcard matching precedence
+      // TODO(cottsay) implement further wildcard matching
+      const std::vector<std::string> node_matching_names{"/**", combined_name_};
+      for (const auto & node_name : node_matching_names) {
+        if (initial_map.count(node_name) > 0) {
+          // Combine parameter yaml files, overwriting values in older ones
+          for (const rclcpp::Parameter & param : initial_map.at(node_name)) {
+            parameter_overrides_[param.get_name()] =
+              rclcpp::ParameterValue(param.get_value_message());
+          }
+        }
+      }
+    }
+  }
+
+  // parameter overrides passed to constructor will overwrite overrides from yaml file sources
+  for (auto & param : parameter_overrides) {
+    parameter_overrides_[param.get_name()] =
+      rclcpp::ParameterValue(param.get_value_message());
+  }
 
   // If asked, initialize any parameters that ended up in the initial parameter values,
   // but did not get declared explcitily by this point.
   if (automatically_declare_parameters_from_overrides) {
-    rcl_interfaces::msg::ParameterDescriptor descriptor;
-    descriptor.dynamic_typing = true;
     for (const auto & pair : this->get_parameter_overrides()) {
       if (!this->has_parameter(pair.first)) {
         this->declare_parameter(
           pair.first,
           pair.second,
-          descriptor,
+          rcl_interfaces::msg::ParameterDescriptor(),
           true);
       }
     }
@@ -136,13 +164,14 @@ __are_doubles_equal(double x, double y, double ulp = 100.0)
   return std::abs(x - y) <= std::numeric_limits<double>::epsilon() * std::abs(x + y) * ulp;
 }
 
-static
-std::string
-format_range_reason(const std::string & name, const char * range_type)
+RCLCPP_LOCAL
+inline
+void
+format_reason(std::string & reason, const std::string & name, const char * range_type)
 {
   std::ostringstream ss;
   ss << "Parameter {" << name << "} doesn't comply with " << range_type << " range.";
-  return ss.str();
+  reason = ss.str();
 }
 
 RCLCPP_LOCAL
@@ -161,7 +190,7 @@ __check_parameter_value_in_range(
     }
     if ((v < integer_range.from_value) || (v > integer_range.to_value)) {
       result.successful = false;
-      result.reason = format_range_reason(descriptor.name, "integer");
+      format_reason(result.reason, descriptor.name, "integer");
       return result;
     }
     if (integer_range.step == 0) {
@@ -171,7 +200,7 @@ __check_parameter_value_in_range(
       return result;
     }
     result.successful = false;
-    result.reason = format_range_reason(descriptor.name, "integer");
+    format_reason(result.reason, descriptor.name, "integer");
     return result;
   }
 
@@ -183,7 +212,7 @@ __check_parameter_value_in_range(
     }
     if ((v < fp_range.from_value) || (v > fp_range.to_value)) {
       result.successful = false;
-      result.reason = format_range_reason(descriptor.name, "floating point");
+      format_reason(result.reason, descriptor.name, "floating point");
       return result;
     }
     if (fp_range.step == 0.0) {
@@ -194,62 +223,29 @@ __check_parameter_value_in_range(
       return result;
     }
     result.successful = false;
-    result.reason = format_range_reason(descriptor.name, "floating point");
+    format_reason(result.reason, descriptor.name, "floating point");
     return result;
   }
   return result;
 }
 
-static
-std::string
-format_type_reason(
-  const std::string & name, const std::string & old_type, const std::string & new_type)
-{
-  std::ostringstream ss;
-  // WARN: A condition later depends on this message starting with "Wrong parameter type",
-  // check `declare_parameter` if you modify this!
-  ss << "Wrong parameter type, parameter {" << name << "} is of type {" << old_type <<
-    "}, setting it to {" << new_type << "} is not allowed.";
-  return ss.str();
-}
-
 // Return true if parameter values comply with the descriptors in parameter_infos.
 RCLCPP_LOCAL
 rcl_interfaces::msg::SetParametersResult
 __check_parameters(
   std::map<std::string, rclcpp::node_interfaces::ParameterInfo> & parameter_infos,
-  const std::vector<rclcpp::Parameter> & parameters,
-  bool allow_undeclared)
+  const std::vector<rclcpp::Parameter> & parameters)
 {
   rcl_interfaces::msg::SetParametersResult result;
   result.successful = true;
   for (const rclcpp::Parameter & parameter : parameters) {
-    std::string name = parameter.get_name();
-    rcl_interfaces::msg::ParameterDescriptor descriptor;
-    if (allow_undeclared) {
-      auto it = parameter_infos.find(name);
-      if (it != parameter_infos.cend()) {
-        descriptor = it->second.descriptor;
-      } else {
-        // implicitly declared parameters are dinamically typed!
-        descriptor.dynamic_typing = true;
-      }
-    } else {
-      descriptor = parameter_infos[name].descriptor;
-    }
-    const auto new_type = parameter.get_type();
-    const auto specified_type = static_cast<rclcpp::ParameterType>(descriptor.type);
-    result.successful = descriptor.dynamic_typing || specified_type == new_type;
-    if (!result.successful) {
-      result.reason = format_type_reason(
-        name, rclcpp::to_string(specified_type), rclcpp::to_string(new_type));
-      return result;
-    }
+    const rcl_interfaces::msg::ParameterDescriptor & descriptor =
+      parameter_infos[parameter.get_name()].descriptor;
     result = __check_parameter_value_in_range(
       descriptor,
       parameter.get_parameter_value());
     if (!result.successful) {
-      return result;
+      break;
     }
   }
   return result;
@@ -296,8 +292,7 @@ __set_parameters_atomically_common(
   const std::vector<rclcpp::Parameter> & parameters,
   std::map<std::string, rclcpp::node_interfaces::ParameterInfo> & parameter_infos,
   CallbacksContainerType & callback_container,
-  const OnParametersSetCallbackType & callback,
-  bool allow_undeclared = false)
+  const OnParametersSetCallbackType & callback)
 {
   // Call the user callback to see if the new value(s) are allowed.
   rcl_interfaces::msg::SetParametersResult result =
@@ -306,7 +301,7 @@ __set_parameters_atomically_common(
     return result;
   }
   // Check if the value being set complies with the descriptor.
-  result = __check_parameters(parameter_infos, parameters, allow_undeclared);
+  result = __check_parameters(parameter_infos, parameters);
   if (!result.successful) {
     return result;
   }
@@ -357,10 +352,6 @@ __declare_parameter_common(
     callback_container,
     callback);
 
-  if (!result.successful) {
-    return result;
-  }
-
   // Add declared parameters to storage.
   parameters_out[name] = parameter_infos.at(name);
 
@@ -372,158 +363,54 @@ __declare_parameter_common(
   return result;
 }
 
-static
 const rclcpp::ParameterValue &
-declare_parameter_helper(
+NodeParameters::declare_parameter(
   const std::string & name,
-  rclcpp::ParameterType type,
   const rclcpp::ParameterValue & default_value,
-  rcl_interfaces::msg::ParameterDescriptor parameter_descriptor,
-  bool ignore_override,
-  std::map<std::string, rclcpp::node_interfaces::ParameterInfo> & parameters,
-  const std::map<std::string, rclcpp::ParameterValue> & overrides,
-  CallbacksContainerType & callback_container,
-  const OnParametersSetCallbackType & callback,
-  rclcpp::Publisher<rcl_interfaces::msg::ParameterEvent> * events_publisher,
-  const std::string & combined_name,
-  rclcpp::node_interfaces::NodeClockInterface & node_clock)
+  const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor,
+  bool ignore_override)
 {
+  std::lock_guard<std::recursive_mutex> lock(mutex_);
+
+  ParameterMutationRecursionGuard guard(parameter_modification_enabled_);
+
   // TODO(sloretz) parameter name validation
   if (name.empty()) {
     throw rclcpp::exceptions::InvalidParametersException("parameter name must not be empty");
   }
 
   // Error if this parameter has already been declared and is different
-  if (__lockless_has_parameter(parameters, name)) {
+  if (__lockless_has_parameter(parameters_, name)) {
     throw rclcpp::exceptions::ParameterAlreadyDeclaredException(
             "parameter '" + name + "' has already been declared");
   }
 
-  if (!parameter_descriptor.dynamic_typing) {
-    if (rclcpp::PARAMETER_NOT_SET == type) {
-      type = default_value.get_type();
-    }
-    if (rclcpp::PARAMETER_NOT_SET == type) {
-      throw rclcpp::exceptions::InvalidParameterTypeException{
-              name,
-              "cannot declare a statically typed parameter with an uninitialized value"
-      };
-    }
-    parameter_descriptor.type = static_cast<uint8_t>(type);
-  }
-
-  if (
-    rclcpp::PARAMETER_NOT_SET == default_value.get_type() &&
-    overrides.find(name) == overrides.end() &&
-    parameter_descriptor.dynamic_typing == false)
-  {
-    throw rclcpp::exceptions::NoParameterOverrideProvided(name);
-  }
-
   rcl_interfaces::msg::ParameterEvent parameter_event;
   auto result = __declare_parameter_common(
     name,
     default_value,
     parameter_descriptor,
-    parameters,
-    overrides,
-    callback_container,
-    callback,
+    parameters_,
+    parameter_overrides_,
+    on_parameters_set_callback_container_,
+    on_parameters_set_callback_,
     &parameter_event,
     ignore_override);
 
   // If it failed to be set, then throw an exception.
   if (!result.successful) {
-    constexpr const char type_error_msg_start[] = "Wrong parameter type";
-    if (
-      0u == std::strncmp(
-        result.reason.c_str(), type_error_msg_start, sizeof(type_error_msg_start) - 1))
-    {
-      // TODO(ivanpauno): Refactor the logic so we don't need the above `strncmp` and we can
-      // detect between both exceptions more elegantly.
-      throw rclcpp::exceptions::InvalidParameterTypeException(name, result.reason);
-    }
     throw rclcpp::exceptions::InvalidParameterValueException(
             "parameter '" + name + "' could not be set: " + result.reason);
   }
 
   // Publish if events_publisher_ is not nullptr, which may be if disabled in the constructor.
-  if (nullptr != events_publisher) {
-    parameter_event.node = combined_name;
-    parameter_event.stamp = node_clock.get_clock()->now();
-    events_publisher->publish(parameter_event);
+  if (nullptr != events_publisher_) {
+    parameter_event.node = combined_name_;
+    parameter_event.stamp = node_clock_->get_clock()->now();
+    events_publisher_->publish(parameter_event);
   }
 
-  return parameters.at(name).value;
-}
-
-const rclcpp::ParameterValue &
-NodeParameters::declare_parameter(const std::string & name)
-{
-  rcl_interfaces::msg::ParameterDescriptor descriptor;
-  descriptor.dynamic_typing = true;
-  return this->declare_parameter(name, rclcpp::ParameterValue{}, descriptor, false);
-}
-
-const rclcpp::ParameterValue &
-NodeParameters::declare_parameter(
-  const std::string & name,
-  const rclcpp::ParameterValue & default_value,
-  const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor,
-  bool ignore_override)
-{
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  ParameterMutationRecursionGuard guard(parameter_modification_enabled_);
-
-  return declare_parameter_helper(
-    name,
-    rclcpp::PARAMETER_NOT_SET,
-    default_value,
-    parameter_descriptor,
-    ignore_override,
-    parameters_,
-    parameter_overrides_,
-    on_parameters_set_callback_container_,
-    on_parameters_set_callback_,
-    events_publisher_.get(),
-    combined_name_,
-    *node_clock_);
-}
-
-const rclcpp::ParameterValue &
-NodeParameters::declare_parameter(
-  const std::string & name,
-  rclcpp::ParameterType type,
-  const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor,
-  bool ignore_override)
-{
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  ParameterMutationRecursionGuard guard(parameter_modification_enabled_);
-
-  if (rclcpp::PARAMETER_NOT_SET == type) {
-    throw std::invalid_argument{
-            "declare_parameter(): the provided parameter type cannot be rclcpp::PARAMETER_NOT_SET"};
-  }
-
-  if (parameter_descriptor.dynamic_typing == true) {
-    throw std::invalid_argument{
-            "declare_parameter(): cannot declare parameter of specific type and pass descriptor"
-            "with `dynamic_typing=true`"};
-  }
-
-  return declare_parameter_helper(
-    name,
-    type,
-    rclcpp::ParameterValue{},
-    parameter_descriptor,
-    ignore_override,
-    parameters_,
-    parameter_overrides_,
-    on_parameters_set_callback_container_,
-    on_parameters_set_callback_,
-    events_publisher_.get(),
-    combined_name_,
-    *node_clock_);
+  return parameters_.at(name).value;
 }
 
 void
@@ -543,10 +430,6 @@ NodeParameters::undeclare_parameter(const std::string & name)
     throw rclcpp::exceptions::ParameterImmutableException(
             "cannot undeclare parameter '" + name + "' because it is read-only");
   }
-  if (!parameter_info->second.descriptor.dynamic_typing) {
-    throw rclcpp::exceptions::InvalidParameterTypeException{
-            name, "cannot undeclare an statically typed parameter"};
-  }
 
   parameters_.erase(parameter_info);
 }
@@ -640,17 +523,13 @@ NodeParameters::set_parameters_atomically(const std::vector<rclcpp::Parameter> &
   rcl_interfaces::msg::ParameterEvent parameter_event_msg;
   parameter_event_msg.node = combined_name_;
   CallbacksContainerType empty_callback_container;
-
-  // Implicit declare uses dynamic type descriptor.
-  rcl_interfaces::msg::ParameterDescriptor descriptor;
-  descriptor.dynamic_typing = true;
   for (auto parameter_to_be_declared : parameters_to_be_declared) {
     // This should not throw, because we validated the name and checked that
     // the parameter was not already declared.
     result = __declare_parameter_common(
       parameter_to_be_declared->get_name(),
       parameter_to_be_declared->get_parameter_value(),
-      descriptor,
+      rcl_interfaces::msg::ParameterDescriptor(),  // Implicit declare uses default descriptor.
       staged_parameter_changes,
       parameter_overrides_,
       // Only call callbacks once below
@@ -699,11 +578,6 @@ NodeParameters::set_parameters_atomically(const std::vector<rclcpp::Parameter> &
     if (rclcpp::PARAMETER_NOT_SET == parameter.get_type()) {
       auto it = parameters_.find(parameter.get_name());
       if (it != parameters_.end() && rclcpp::PARAMETER_NOT_SET != it->second.value.get_type()) {
-        if (!it->second.descriptor.dynamic_typing) {
-          result.reason = "cannot undeclare an statically typed parameter";
-          result.successful = false;
-          return result;
-        }
         parameters_to_be_undeclared.push_back(&parameter);
       }
     }
@@ -719,8 +593,7 @@ NodeParameters::set_parameters_atomically(const std::vector<rclcpp::Parameter> &
     on_parameters_set_callback_container_,
     // These callbacks are called once. When a callback returns an unsuccessful result,
     // the remaining aren't called.
-    on_parameters_set_callback_,
-    allow_undeclared_);  // allow undeclared
+    on_parameters_set_callback_);
 
   // If not successful, then stop here.
   if (!result.successful) {

rclcpp/src/rclcpp/node_interfaces/node_services.cpp

@@ -78,9 +78,3 @@ NodeServices::add_client(
     }
   }
 }
-
-std::string
-NodeServices::resolve_service_name(const std::string & name, bool only_expand) const
-{
-  return node_base_->resolve_topic_or_service_name(name, true, only_expand);
-}

rclcpp/src/rclcpp/node_interfaces/node_timers.cpp

@@ -16,8 +16,6 @@
 
 #include <string>
 
-#include "tracetools/tracetools.h"
-
 using rclcpp::node_interfaces::NodeTimers;
 
 NodeTimers::NodeTimers(rclcpp::node_interfaces::NodeBaseInterface * node_base)
@@ -46,8 +44,4 @@ NodeTimers::add_timer(
             std::string("Failed to notify wait set on timer creation: ") +
             rmw_get_error_string().str);
   }
-  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

@@ -129,9 +129,3 @@ NodeTopics::get_node_timers_interface() const
 {
   return node_timers_;
 }
-
-std::string
-NodeTopics::resolve_topic_name(const std::string & name, bool only_expand) const
-{
-  return node_base_->resolve_topic_or_service_name(name, false, only_expand);
-}

rclcpp/src/rclcpp/parameter_client.cpp

@@ -144,35 +144,6 @@ AsyncParametersClient::get_parameters(
   return future_result;
 }
 
-std::shared_future<std::vector<rcl_interfaces::msg::ParameterDescriptor>>
-AsyncParametersClient::describe_parameters(
-  const std::vector<std::string> & names,
-  std::function<
-    void(std::shared_future<std::vector<rcl_interfaces::msg::ParameterDescriptor>>)
-  > callback)
-{
-  auto promise_result =
-    std::make_shared<std::promise<std::vector<rcl_interfaces::msg::ParameterDescriptor>>>();
-  auto future_result = promise_result->get_future().share();
-
-  auto request = std::make_shared<rcl_interfaces::srv::DescribeParameters::Request>();
-  request->names = names;
-
-  describe_parameters_client_->async_send_request(
-    request,
-    [promise_result, future_result, callback](
-      rclcpp::Client<rcl_interfaces::srv::DescribeParameters>::SharedFuture cb_f)
-    {
-      promise_result->set_value(cb_f.get()->descriptors);
-      if (callback != nullptr) {
-        callback(future_result);
-      }
-    }
-  );
-
-  return future_result;
-}
-
 std::shared_future<std::vector<rclcpp::ParameterType>>
 AsyncParametersClient::get_parameter_types(
   const std::vector<std::string> & names,
@@ -342,16 +313,14 @@ AsyncParametersClient::wait_for_service_nanoseconds(std::chrono::nanoseconds tim
 }
 
 std::vector<rclcpp::Parameter>
-SyncParametersClient::get_parameters(
-  const std::vector<std::string> & parameter_names,
-  std::chrono::nanoseconds timeout)
+SyncParametersClient::get_parameters(const std::vector<std::string> & parameter_names)
 {
   auto f = async_parameters_client_->get_parameters(parameter_names);
   using rclcpp::executors::spin_node_until_future_complete;
   if (
     spin_node_until_future_complete(
-      *executor_, node_base_interface_, f,
-      timeout) == rclcpp::FutureReturnCode::SUCCESS)
+      *executor_, node_base_interface_,
+      f) == rclcpp::FutureReturnCode::SUCCESS)
   {
     return f.get();
   }
@@ -368,34 +337,16 @@ SyncParametersClient::has_parameter(const std::string & parameter_name)
   return vars.names.size() > 0;
 }
 
-std::vector<rcl_interfaces::msg::ParameterDescriptor>
-SyncParametersClient::describe_parameters(
-  const std::vector<std::string> & parameter_names,
-  std::chrono::nanoseconds timeout)
-{
-  auto f = async_parameters_client_->describe_parameters(parameter_names);
-
-  using rclcpp::executors::spin_node_until_future_complete;
-  rclcpp::FutureReturnCode future =
-    spin_node_until_future_complete(*executor_, node_base_interface_, f, timeout);
-  if (future == rclcpp::FutureReturnCode::SUCCESS) {
-    return f.get();
-  }
-  return std::vector<rcl_interfaces::msg::ParameterDescriptor>();
-}
-
 std::vector<rclcpp::ParameterType>
-SyncParametersClient::get_parameter_types(
-  const std::vector<std::string> & parameter_names,
-  std::chrono::nanoseconds timeout)
+SyncParametersClient::get_parameter_types(const std::vector<std::string> & parameter_names)
 {
   auto f = async_parameters_client_->get_parameter_types(parameter_names);
 
   using rclcpp::executors::spin_node_until_future_complete;
   if (
     spin_node_until_future_complete(
-      *executor_, node_base_interface_, f,
-      timeout) == rclcpp::FutureReturnCode::SUCCESS)
+      *executor_, node_base_interface_,
+      f) == rclcpp::FutureReturnCode::SUCCESS)
   {
     return f.get();
   }
@@ -404,16 +355,15 @@ SyncParametersClient::get_parameter_types(
 
 std::vector<rcl_interfaces::msg::SetParametersResult>
 SyncParametersClient::set_parameters(
-  const std::vector<rclcpp::Parameter> & parameters,
-  std::chrono::nanoseconds timeout)
+  const std::vector<rclcpp::Parameter> & parameters)
 {
   auto f = async_parameters_client_->set_parameters(parameters);
 
   using rclcpp::executors::spin_node_until_future_complete;
   if (
     spin_node_until_future_complete(
-      *executor_, node_base_interface_, f,
-      timeout) == rclcpp::FutureReturnCode::SUCCESS)
+      *executor_, node_base_interface_,
+      f) == rclcpp::FutureReturnCode::SUCCESS)
   {
     return f.get();
   }
@@ -422,16 +372,15 @@ SyncParametersClient::set_parameters(
 
 rcl_interfaces::msg::SetParametersResult
 SyncParametersClient::set_parameters_atomically(
-  const std::vector<rclcpp::Parameter> & parameters,
-  std::chrono::nanoseconds timeout)
+  const std::vector<rclcpp::Parameter> & parameters)
 {
   auto f = async_parameters_client_->set_parameters_atomically(parameters);
 
   using rclcpp::executors::spin_node_until_future_complete;
   if (
     spin_node_until_future_complete(
-      *executor_, node_base_interface_, f,
-      timeout) == rclcpp::FutureReturnCode::SUCCESS)
+      *executor_, node_base_interface_,
+      f) == rclcpp::FutureReturnCode::SUCCESS)
   {
     return f.get();
   }
@@ -442,16 +391,15 @@ SyncParametersClient::set_parameters_atomically(
 rcl_interfaces::msg::ListParametersResult
 SyncParametersClient::list_parameters(
   const std::vector<std::string> & parameter_prefixes,
-  uint64_t depth,
-  std::chrono::nanoseconds timeout)
+  uint64_t depth)
 {
   auto f = async_parameters_client_->list_parameters(parameter_prefixes, depth);
 
   using rclcpp::executors::spin_node_until_future_complete;
   if (
     spin_node_until_future_complete(
-      *executor_, node_base_interface_, f,
-      timeout) == rclcpp::FutureReturnCode::SUCCESS)
+      *executor_, node_base_interface_,
+      f) == rclcpp::FutureReturnCode::SUCCESS)
   {
     return f.get();
   }

rclcpp/src/rclcpp/parameter_event_handler.cpp

@@ -1,222 +0,0 @@
-// Copyright 2019 Intel 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 <functional>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "rclcpp/parameter_event_handler.hpp"
-#include "rcpputils/join.hpp"
-
-namespace rclcpp
-{
-
-ParameterEventCallbackHandle::SharedPtr
-ParameterEventHandler::add_parameter_event_callback(
-  ParameterEventCallbackType callback)
-{
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  auto handle = std::make_shared<ParameterEventCallbackHandle>();
-  handle->callback = callback;
-  event_callbacks_.emplace_front(handle);
-
-  return handle;
-}
-
-template<typename CallbackHandleT>
-struct HandleCompare
-  : public std::unary_function<typename CallbackHandleT::WeakPtr, bool>
-{
-  explicit HandleCompare(const CallbackHandleT * const base)
-  : base_(base) {}
-  bool operator()(const typename CallbackHandleT::WeakPtr & handle)
-  {
-    auto shared_handle = handle.lock();
-    if (base_ == shared_handle.get()) {
-      return true;
-    }
-    return false;
-  }
-  const CallbackHandleT * const base_;
-};
-
-void
-ParameterEventHandler::remove_parameter_event_callback(
-  ParameterEventCallbackHandle::SharedPtr callback_handle)
-{
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  auto it = std::find_if(
-    event_callbacks_.begin(),
-    event_callbacks_.end(),
-    HandleCompare<ParameterEventCallbackHandle>(callback_handle.get()));
-  if (it != event_callbacks_.end()) {
-    event_callbacks_.erase(it);
-  } else {
-    throw std::runtime_error("Callback doesn't exist");
-  }
-}
-
-ParameterCallbackHandle::SharedPtr
-ParameterEventHandler::add_parameter_callback(
-  const std::string & parameter_name,
-  ParameterCallbackType callback,
-  const std::string & node_name)
-{
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  auto full_node_name = resolve_path(node_name);
-
-  auto handle = std::make_shared<ParameterCallbackHandle>();
-  handle->callback = callback;
-  handle->parameter_name = parameter_name;
-  handle->node_name = full_node_name;
-  // the last callback registered is executed first.
-  parameter_callbacks_[{parameter_name, full_node_name}].emplace_front(handle);
-
-  return handle;
-}
-
-void
-ParameterEventHandler::remove_parameter_callback(
-  ParameterCallbackHandle::SharedPtr callback_handle)
-{
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  auto handle = callback_handle.get();
-  auto & container = parameter_callbacks_[{handle->parameter_name, handle->node_name}];
-  auto it = std::find_if(
-    container.begin(),
-    container.end(),
-    HandleCompare<ParameterCallbackHandle>(handle));
-  if (it != container.end()) {
-    container.erase(it);
-    if (container.empty()) {
-      parameter_callbacks_.erase({handle->parameter_name, handle->node_name});
-    }
-  } else {
-    throw std::runtime_error("Callback doesn't exist");
-  }
-}
-
-bool
-ParameterEventHandler::get_parameter_from_event(
-  const rcl_interfaces::msg::ParameterEvent & event,
-  rclcpp::Parameter & parameter,
-  const std::string parameter_name,
-  const std::string node_name)
-{
-  if (event.node != node_name) {
-    return false;
-  }
-
-  for (auto & new_parameter : event.new_parameters) {
-    if (new_parameter.name == parameter_name) {
-      parameter = rclcpp::Parameter::from_parameter_msg(new_parameter);
-      return true;
-    }
-  }
-
-  for (auto & changed_parameter : event.changed_parameters) {
-    if (changed_parameter.name == parameter_name) {
-      parameter = rclcpp::Parameter::from_parameter_msg(changed_parameter);
-      return true;
-    }
-  }
-
-  return false;
-}
-
-rclcpp::Parameter
-ParameterEventHandler::get_parameter_from_event(
-  const rcl_interfaces::msg::ParameterEvent & event,
-  const std::string parameter_name,
-  const std::string node_name)
-{
-  rclcpp::Parameter p;
-  if (!get_parameter_from_event(event, p, parameter_name, node_name)) {
-    throw std::runtime_error(
-            "Parameter '" + parameter_name + "' of node '" + node_name +
-            "' is not part of parameter event");
-  }
-  return p;
-}
-
-std::vector<rclcpp::Parameter>
-ParameterEventHandler::get_parameters_from_event(
-  const rcl_interfaces::msg::ParameterEvent & event)
-{
-  std::vector<rclcpp::Parameter> params;
-
-  for (auto & new_parameter : event.new_parameters) {
-    params.push_back(rclcpp::Parameter::from_parameter_msg(new_parameter));
-  }
-
-  for (auto & changed_parameter : event.changed_parameters) {
-    params.push_back(rclcpp::Parameter::from_parameter_msg(changed_parameter));
-  }
-
-  return params;
-}
-
-void
-ParameterEventHandler::event_callback(
-  const rcl_interfaces::msg::ParameterEvent::SharedPtr event)
-{
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  for (auto it = parameter_callbacks_.begin(); it != parameter_callbacks_.end(); ++it) {
-    rclcpp::Parameter p;
-    if (get_parameter_from_event(*event, p, it->first.first, it->first.second)) {
-      for (auto cb = it->second.begin(); cb != it->second.end(); ++cb) {
-        auto shared_handle = cb->lock();
-        if (nullptr != shared_handle) {
-          shared_handle->callback(p);
-        } else {
-          cb = it->second.erase(cb);
-        }
-      }
-    }
-  }
-
-  for (auto event_cb = event_callbacks_.begin(); event_cb != event_callbacks_.end(); ++event_cb) {
-    auto shared_event_handle = event_cb->lock();
-    if (nullptr != shared_event_handle) {
-      shared_event_handle->callback(event);
-    } else {
-      event_cb = event_callbacks_.erase(event_cb);
-    }
-  }
-}
-
-std::string
-ParameterEventHandler::resolve_path(const std::string & path)
-{
-  std::string full_path;
-
-  if (path == "") {
-    full_path = node_base_->get_fully_qualified_name();
-  } else {
-    full_path = path;
-    if (*path.begin() != '/') {
-      auto ns = node_base_->get_namespace();
-      const std::vector<std::string> paths{ns, path};
-      full_path = (ns == std::string("/")) ? ns + path : rcpputils::join(paths, "/");
-    }
-  }
-
-  return full_path;
-}
-
-}  // namespace rclcpp

rclcpp/src/rclcpp/parameter_service.cpp

@@ -41,13 +41,12 @@ ParameterService::ParameterService(
       const std::shared_ptr<rcl_interfaces::srv::GetParameters::Request> request,
       std::shared_ptr<rcl_interfaces::srv::GetParameters::Response> response)
     {
-      try {
-        auto parameters = node_params->get_parameters(request->names);
-        for (const auto param : parameters) {
-          response->values.push_back(param.get_value_message());
-        }
-      } catch (const rclcpp::exceptions::ParameterNotDeclaredException & ex) {
-        RCLCPP_DEBUG(rclcpp::get_logger("rclcpp"), "Failed to get parameters: %s", ex.what());
+      for (const auto & name : request->names) {
+        // Default construct param to NOT_SET
+        rclcpp::Parameter param;
+        node_params->get_parameter(name, param);
+        // push back NOT_SET when get_parameter() call fails
+        response->values.push_back(param.get_value_message());
       }
     },
     qos_profile, nullptr);
@@ -68,7 +67,7 @@ ParameterService::ParameterService(
             return static_cast<rclcpp::ParameterType>(type);
           });
       } catch (const rclcpp::exceptions::ParameterNotDeclaredException & ex) {
-        RCLCPP_DEBUG(rclcpp::get_logger("rclcpp"), "Failed to get parameter types: %s", ex.what());
+        RCLCPP_WARN(rclcpp::get_logger("rclcpp"), "Failed to get parameter types: %s", ex.what());
       }
     },
     qos_profile, nullptr);
@@ -89,7 +88,7 @@ ParameterService::ParameterService(
           result = node_params->set_parameters_atomically(
             {rclcpp::Parameter::from_parameter_msg(p)});
         } catch (const rclcpp::exceptions::ParameterNotDeclaredException & ex) {
-          RCLCPP_DEBUG(rclcpp::get_logger("rclcpp"), "Failed to set parameter: %s", ex.what());
+          RCLCPP_WARN(rclcpp::get_logger("rclcpp"), "Failed to set parameter: %s", ex.what());
           result.successful = false;
           result.reason = ex.what();
         }
@@ -117,7 +116,7 @@ ParameterService::ParameterService(
         auto result = node_params->set_parameters_atomically(pvariants);
         response->result = result;
       } catch (const rclcpp::exceptions::ParameterNotDeclaredException & ex) {
-        RCLCPP_DEBUG(
+        RCLCPP_WARN(
           rclcpp::get_logger("rclcpp"), "Failed to set parameters atomically: %s", ex.what());
         response->result.successful = false;
         response->result.reason = "One or more parameters were not declared before setting";
@@ -137,7 +136,7 @@ ParameterService::ParameterService(
         auto descriptors = node_params->describe_parameters(request->names);
         response->descriptors = descriptors;
       } catch (const rclcpp::exceptions::ParameterNotDeclaredException & ex) {
-        RCLCPP_DEBUG(rclcpp::get_logger("rclcpp"), "Failed to describe parameters: %s", ex.what());
+        RCLCPP_WARN(rclcpp::get_logger("rclcpp"), "Failed to describe parameters: %s", ex.what());
       }
     },
     qos_profile, nullptr);

rclcpp/src/rclcpp/parameter_value.cpp

@@ -67,7 +67,7 @@ array_to_string(
   type_array << "[";
   type_array.setf(format_flags, std::ios_base::basefield | std::ios::boolalpha);
   type_array << std::showbase;
-  for (const ValType & value : array) {
+  for (const ValType value : array) {
     if (!first_item) {
       type_array << ", ";
     } else {

rclcpp/src/rclcpp/qos.cpp

@@ -99,13 +99,6 @@ QoS::history(rmw_qos_history_policy_t history)
   return *this;
 }
 
-QoS &
-QoS::history(HistoryPolicy history)
-{
-  rmw_qos_profile_.history = static_cast<rmw_qos_history_policy_t>(history);
-  return *this;
-}
-
 QoS &
 QoS::keep_last(size_t depth)
 {
@@ -129,13 +122,6 @@ QoS::reliability(rmw_qos_reliability_policy_t reliability)
   return *this;
 }
 
-QoS &
-QoS::reliability(ReliabilityPolicy reliability)
-{
-  rmw_qos_profile_.reliability = static_cast<rmw_qos_reliability_policy_t>(reliability);
-  return *this;
-}
-
 QoS &
 QoS::reliable()
 {
@@ -155,13 +141,6 @@ QoS::durability(rmw_qos_durability_policy_t durability)
   return *this;
 }
 
-QoS &
-QoS::durability(DurabilityPolicy durability)
-{
-  rmw_qos_profile_.durability = static_cast<rmw_qos_durability_policy_t>(durability);
-  return *this;
-}
-
 QoS &
 QoS::durability_volatile()
 {
@@ -207,14 +186,6 @@ QoS::liveliness(rmw_qos_liveliness_policy_t liveliness)
   return *this;
 }
 
-QoS &
-QoS::liveliness(LivelinessPolicy liveliness)
-{
-  rmw_qos_profile_.liveliness = static_cast<rmw_qos_liveliness_policy_t>(liveliness);
-  return *this;
-}
-
-
 QoS &
 QoS::liveliness_lease_duration(rmw_time_t liveliness_lease_duration)
 {
@@ -235,51 +206,6 @@ QoS::avoid_ros_namespace_conventions(bool avoid_ros_namespace_conventions)
   return *this;
 }
 
-HistoryPolicy
-QoS::history() const
-{
-  return static_cast<HistoryPolicy>(rmw_qos_profile_.history);
-}
-
-size_t
-QoS::depth() const {return rmw_qos_profile_.depth;}
-
-ReliabilityPolicy
-QoS::reliability() const
-{
-  return static_cast<ReliabilityPolicy>(rmw_qos_profile_.reliability);
-}
-
-DurabilityPolicy
-QoS::durability() const
-{
-  return static_cast<DurabilityPolicy>(rmw_qos_profile_.durability);
-}
-
-Duration
-QoS::deadline() const {return Duration::from_rmw_time(rmw_qos_profile_.deadline);}
-
-Duration
-QoS::lifespan() const {return Duration::from_rmw_time(rmw_qos_profile_.lifespan);}
-
-LivelinessPolicy
-QoS::liveliness() const
-{
-  return static_cast<LivelinessPolicy>(rmw_qos_profile_.liveliness);
-}
-
-Duration
-QoS::liveliness_lease_duration() const
-{
-  return Duration::from_rmw_time(rmw_qos_profile_.liveliness_lease_duration);
-}
-
-bool
-QoS::avoid_ros_namespace_conventions() const
-{
-  return rmw_qos_profile_.avoid_ros_namespace_conventions;
-}
-
 namespace
 {
 /// Check if two rmw_time_t have the same values.

rclcpp/src/rclcpp/qos_overriding_options.cpp

@@ -1,84 +0,0 @@
-// Copyright 2020 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/qos_overriding_options.hpp"
-
-#include <initializer_list>
-#include <ostream>
-#include <stdexcept>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "rmw/qos_policy_kind.h"
-#include "rmw/qos_string_conversions.h"
-
-namespace rclcpp
-{
-
-const char *
-qos_policy_kind_to_cstr(const QosPolicyKind & qpk)
-{
-  const char * ret = rmw_qos_policy_kind_to_str(static_cast<rmw_qos_policy_kind_t>(qpk));
-  if (!ret) {
-    throw std::invalid_argument{"unknown QoS policy kind"};
-  }
-  return ret;
-}
-
-std::ostream &
-operator<<(std::ostream & oss, const QosPolicyKind & qpk)
-{
-  return oss << qos_policy_kind_to_cstr(qpk);
-}
-
-static std::initializer_list<QosPolicyKind> kDefaultPolicies =
-{QosPolicyKind::History, QosPolicyKind::Depth, QosPolicyKind::Reliability};
-
-QosOverridingOptions::QosOverridingOptions(
-  std::initializer_list<QosPolicyKind> policy_kinds,
-  QosCallback validation_callback,
-  std::string id)
-: id_{std::move(id)},
-  policy_kinds_{policy_kinds},
-  validation_callback_{std::move(validation_callback)}
-{}
-
-QosOverridingOptions
-QosOverridingOptions::with_default_policies(
-  QosCallback validation_callback,
-  std::string id)
-{
-  return QosOverridingOptions{kDefaultPolicies, validation_callback, id};
-}
-
-const std::string &
-QosOverridingOptions::get_id() const
-{
-  return id_;
-}
-
-const std::vector<QosPolicyKind> &
-QosOverridingOptions::get_policy_kinds() const
-{
-  return policy_kinds_;
-}
-
-const QosCallback &
-QosOverridingOptions::get_validation_callback() const
-{
-  return validation_callback_;
-}
-
-}  // namespace rclcpp

rclcpp/src/rclcpp/signal_handler.cpp

@@ -243,7 +243,7 @@ SignalHandler::deferred_signal_handler()
             get_logger(),
             "deferred_signal_handler(): "
             "shutting down rclcpp::Context @ %p, because it had shutdown_on_sigint == true",
-            static_cast<void *>(context_ptr.get()));
+            context_ptr.get());
           context_ptr->shutdown("signal handler");
         }
       }

rclcpp/src/rclcpp/time.cpp

@@ -199,7 +199,7 @@ Time::operator-(const rclcpp::Time & rhs) const
     throw std::underflow_error("time subtraction leads to int64_t underflow");
   }
 
-  return Duration::from_nanoseconds(rcl_time_.nanoseconds - rhs.rcl_time_.nanoseconds);
+  return Duration(rcl_time_.nanoseconds - rhs.rcl_time_.nanoseconds);
 }
 
 Time

rclcpp/src/rclcpp/time_source.cpp

@@ -233,22 +233,11 @@ void TimeSource::create_clock_sub()
     return;
   }
 
-  rclcpp::SubscriptionOptions options;
-  options.qos_overriding_options = rclcpp::QosOverridingOptions(
-    {
-      rclcpp::QosPolicyKind::Depth,
-      rclcpp::QosPolicyKind::Durability,
-      rclcpp::QosPolicyKind::History,
-      rclcpp::QosPolicyKind::Reliability,
-    });
-
   clock_subscription_ = rclcpp::create_subscription<rosgraph_msgs::msg::Clock>(
-    node_parameters_,
     node_topics_,
     "/clock",
     rclcpp::QoS(KeepLast(1)).best_effort(),
-    std::bind(&TimeSource::clock_cb, this, std::placeholders::_1),
-    options
+    std::bind(&TimeSource::clock_cb, this, std::placeholders::_1)
   );
 }
 

rclcpp/src/rclcpp/utilities.cpp

@@ -21,7 +21,6 @@
 
 #include "./signal_handler.hpp"
 #include "rclcpp/contexts/default_context.hpp"
-#include "rclcpp/detail/utilities.hpp"
 #include "rclcpp/exceptions.hpp"
 
 #include "rcl/error_handling.h"
@@ -57,47 +56,6 @@ uninstall_signal_handlers()
   return SignalHandler::get_global_signal_handler().uninstall();
 }
 
-static
-std::vector<std::string>
-_remove_ros_arguments(
-  char const * const argv[],
-  const rcl_arguments_t * args,
-  rcl_allocator_t alloc)
-{
-  rcl_ret_t ret;
-  int nonros_argc = 0;
-  const char ** nonros_argv = NULL;
-
-  ret = rcl_remove_ros_arguments(
-    argv,
-    args,
-    alloc,
-    &nonros_argc,
-    &nonros_argv);
-
-  if (RCL_RET_OK != ret || nonros_argc < 0) {
-    // Not using throw_from_rcl_error, because we may need to append deallocation failures.
-    exceptions::RCLError exc(ret, rcl_get_error_state(), "");
-    rcl_reset_error();
-    if (NULL != nonros_argv) {
-      alloc.deallocate(nonros_argv, alloc.state);
-    }
-    throw exc;
-  }
-
-  std::vector<std::string> return_arguments(static_cast<size_t>(nonros_argc));
-
-  for (size_t ii = 0; ii < static_cast<size_t>(nonros_argc); ++ii) {
-    return_arguments[ii] = std::string(nonros_argv[ii]);
-  }
-
-  if (NULL != nonros_argv) {
-    alloc.deallocate(nonros_argv, alloc.state);
-  }
-
-  return return_arguments;
-}
-
 std::vector<std::string>
 init_and_remove_ros_arguments(
   int argc,
@@ -105,10 +63,7 @@ init_and_remove_ros_arguments(
   const InitOptions & init_options)
 {
   init(argc, argv, init_options);
-
-  using rclcpp::contexts::get_global_default_context;
-  auto rcl_context = get_global_default_context()->get_rcl_context();
-  return _remove_ros_arguments(argv, &(rcl_context->global_arguments), rcl_get_default_allocator());
+  return remove_ros_arguments(argc, argv);
 }
 
 std::vector<std::string>
@@ -124,17 +79,40 @@ remove_ros_arguments(int argc, char const * const argv[])
     exceptions::throw_from_rcl_error(ret, "failed to parse arguments");
   }
 
-  std::vector<std::string> return_arguments;
-  try {
-    return_arguments = _remove_ros_arguments(argv, &parsed_args, alloc);
-  } catch (exceptions::RCLError & exc) {
+  int nonros_argc = 0;
+  const char ** nonros_argv = NULL;
+
+  ret = rcl_remove_ros_arguments(
+    argv,
+    &parsed_args,
+    alloc,
+    &nonros_argc,
+    &nonros_argv);
+
+  if (RCL_RET_OK != ret || nonros_argc < 0) {
+    // Not using throw_from_rcl_error, because we may need to append deallocation failures.
+    exceptions::RCLErrorBase base_exc(ret, rcl_get_error_state());
+    rcl_reset_error();
+    if (NULL != nonros_argv) {
+      alloc.deallocate(nonros_argv, alloc.state);
+    }
     if (RCL_RET_OK != rcl_arguments_fini(&parsed_args)) {
-      exc.formatted_message += std::string(
+      base_exc.formatted_message += std::string(
         ", failed also to cleanup parsed arguments, leaking memory: ") +
         rcl_get_error_string().str;
       rcl_reset_error();
     }
-    throw exc;
+    throw exceptions::RCLError(base_exc, "");
+  }
+
+  std::vector<std::string> return_arguments(static_cast<size_t>(nonros_argc));
+
+  for (size_t ii = 0; ii < static_cast<size_t>(nonros_argc); ++ii) {
+    return_arguments[ii] = std::string(nonros_argv[ii]);
+  }
+
+  if (NULL != nonros_argv) {
+    alloc.deallocate(nonros_argv, alloc.state);
   }
 
   ret = rcl_arguments_fini(&parsed_args);

rclcpp/test/CMakeLists.txt

@@ -4,12 +4,22 @@ find_package(test_msgs REQUIRED)
 
 include(cmake/rclcpp_add_build_failure_test.cmake)
 
-set(TEST_RESOURCES_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/resources")
+rosidl_generate_interfaces(${PROJECT_NAME}_test_msgs
+  msg/Header.msg
+  msg/MessageWithHeader.msg
+  DEPENDENCIES builtin_interfaces
+  LIBRARY_NAME ${PROJECT_NAME}
+  SKIP_INSTALL
+)
 
-add_subdirectory(benchmark)
 add_subdirectory(rclcpp)
 
 ament_add_gtest(test_rclcpp_gtest_macros utils/test_rclcpp_gtest_macros.cpp)
 if(TARGET test_rclcpp_gtest_macros)
   target_link_libraries(test_rclcpp_gtest_macros ${PROJECT_NAME})
 endif()
+
+# Install test resources
+install(
+  DIRECTORY resources
+  DESTINATION ${CMAKE_CURRENT_BINARY_DIR})

rclcpp/test/benchmark/CMakeLists.txt

@@ -1,44 +0,0 @@
-find_package(ament_cmake_google_benchmark REQUIRED)
-find_package(performance_test_fixture REQUIRED)
-
-# These benchmarks are only being created and run for the default RMW
-# implementation. We are looking to test the performance of the ROS 2 code, not
-# the underlying middleware.
-
-add_performance_test(benchmark_client benchmark_client.cpp)
-if(TARGET benchmark_client)
-  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})
-  ament_target_dependencies(benchmark_executor test_msgs)
-endif()
-
-add_performance_test(benchmark_init_shutdown benchmark_init_shutdown.cpp)
-if(TARGET benchmark_init_shutdown)
-  target_link_libraries(benchmark_init_shutdown ${PROJECT_NAME})
-endif()
-
-add_performance_test(benchmark_node benchmark_node.cpp)
-if(TARGET benchmark_node)
-  target_link_libraries(benchmark_node ${PROJECT_NAME})
-endif()
-
-add_performance_test(benchmark_node_parameters_interface benchmark_node_parameters_interface.cpp)
-if(TARGET benchmark_node_parameters_interface)
-  target_link_libraries(benchmark_node_parameters_interface ${PROJECT_NAME})
-endif()
-
-ament_add_google_benchmark(benchmark_parameter_client benchmark_parameter_client.cpp)
-if(TARGET benchmark_parameter_client)
-  target_link_libraries(benchmark_parameter_client ${PROJECT_NAME})
-endif()
-
-add_performance_test(benchmark_service benchmark_service.cpp)
-if(TARGET benchmark_service)
-  target_link_libraries(benchmark_service ${PROJECT_NAME})
-  ament_target_dependencies(benchmark_service test_msgs rcl_interfaces)
-endif()

rclcpp/test/benchmark/benchmark_client.cpp

@@ -1,153 +0,0 @@
-// Copyright 2020 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 <memory>
-#include <string>
-
-#include "performance_test_fixture/performance_test_fixture.hpp"
-#include "rclcpp/rclcpp.hpp"
-#include "test_msgs/srv/empty.hpp"
-
-using performance_test_fixture::PerformanceTest;
-
-constexpr char empty_service_name[] = "empty_service";
-
-class ClientPerformanceTest : public PerformanceTest
-{
-public:
-  explicit ClientPerformanceTest(rclcpp::NodeOptions = rclcpp::NodeOptions()) {}
-  void SetUp(benchmark::State & state)
-  {
-    rclcpp::init(0, nullptr);
-    node = std::make_unique<rclcpp::Node>("node", "ns");
-
-    auto empty_service_callback =
-      [](
-      const test_msgs::srv::Empty::Request::SharedPtr,
-      test_msgs::srv::Empty::Response::SharedPtr) {};
-    empty_service =
-      node->create_service<test_msgs::srv::Empty>(empty_service_name, empty_service_callback);
-
-    performance_test_fixture::PerformanceTest::SetUp(state);
-  }
-
-  void TearDown(benchmark::State & state)
-  {
-    performance_test_fixture::PerformanceTest::TearDown(state);
-    empty_service.reset();
-    node.reset();
-    rclcpp::shutdown();
-  }
-
-protected:
-  std::unique_ptr<rclcpp::Node> node;
-  std::shared_ptr<rclcpp::Service<test_msgs::srv::Empty>> empty_service;
-};
-
-BENCHMARK_F(ClientPerformanceTest, construct_client_no_service)(benchmark::State & state) {
-  // Prime cache
-  auto outer_client = node->create_client<test_msgs::srv::Empty>("not_an_existing_service");
-  outer_client.reset();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto client = node->create_client<test_msgs::srv::Empty>("not_an_existing_service");
-    benchmark::DoNotOptimize(client);
-    benchmark::ClobberMemory();
-
-    state.PauseTiming();
-    client.reset();
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(ClientPerformanceTest, construct_client_empty_srv)(benchmark::State & state) {
-  // Prime cache
-  auto outer_client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-  outer_client.reset();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-    benchmark::DoNotOptimize(client);
-    benchmark::ClobberMemory();
-
-    state.PauseTiming();
-    client.reset();
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(ClientPerformanceTest, destroy_client_empty_srv)(benchmark::State & state) {
-  // Prime cache
-  auto outer_client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-  outer_client.reset();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    state.PauseTiming();
-    auto client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-    state.ResumeTiming();
-    benchmark::DoNotOptimize(client);
-    benchmark::ClobberMemory();
-
-    client.reset();
-  }
-}
-
-BENCHMARK_F(ClientPerformanceTest, wait_for_service)(benchmark::State & state) {
-  int count = 0;
-  for (auto _ : state) {
-    state.PauseTiming();
-    const std::string service_name = std::string("service_") + std::to_string(count++);
-    // Create client before service so it has to 'discover' the service after construction
-    auto client = node->create_client<test_msgs::srv::Empty>(service_name);
-    auto callback =
-      [](
-      const test_msgs::srv::Empty::Request::SharedPtr,
-      test_msgs::srv::Empty::Response::SharedPtr) {};
-    auto service =
-      node->create_service<test_msgs::srv::Empty>(service_name, callback);
-    state.ResumeTiming();
-
-    client->wait_for_service(std::chrono::seconds(1));
-    benchmark::ClobberMemory();
-  }
-}
-
-BENCHMARK_F(ClientPerformanceTest, async_send_request_only)(benchmark::State & state) {
-  auto client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-  auto shared_request = std::make_shared<test_msgs::srv::Empty::Request>();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto future = client->async_send_request(shared_request);
-    benchmark::DoNotOptimize(future);
-    benchmark::ClobberMemory();
-  }
-}
-
-BENCHMARK_F(ClientPerformanceTest, async_send_request_and_response)(benchmark::State & state) {
-  auto client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-  auto shared_request = std::make_shared<test_msgs::srv::Empty::Request>();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto future = client->async_send_request(shared_request);
-    rclcpp::spin_until_future_complete(
-      node->get_node_base_interface(), future, std::chrono::seconds(1));
-    benchmark::DoNotOptimize(future);
-    benchmark::ClobberMemory();
-  }
-}

rclcpp/test/benchmark/benchmark_executor.cpp

@@ -1,390 +0,0 @@
-// Copyright 2020 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 <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "performance_test_fixture/performance_test_fixture.hpp"
-
-#include "rclcpp/rclcpp.hpp"
-#include "rclcpp/scope_exit.hpp"
-#include "test_msgs/msg/empty.hpp"
-
-using namespace std::chrono_literals;
-using performance_test_fixture::PerformanceTest;
-
-constexpr unsigned int kNumberOfNodes = 10;
-
-class PerformanceTestExecutor : public PerformanceTest
-{
-public:
-  void SetUp(benchmark::State & st)
-  {
-    rclcpp::init(0, nullptr);
-    callback_count = 0;
-    for (unsigned int i = 0u; i < kNumberOfNodes; i++) {
-      nodes.push_back(std::make_shared<rclcpp::Node>("my_node_" + std::to_string(i)));
-
-      publishers.push_back(
-        nodes[i]->create_publisher<test_msgs::msg::Empty>(
-          "/empty_msgs_" + std::to_string(i), rclcpp::QoS(10)));
-
-      auto callback = [this](test_msgs::msg::Empty::SharedPtr) {this->callback_count++;};
-      subscriptions.push_back(
-        nodes[i]->create_subscription<test_msgs::msg::Empty>(
-          "/empty_msgs_" + std::to_string(i), rclcpp::QoS(10), std::move(callback)));
-    }
-    PerformanceTest::SetUp(st);
-  }
-  void TearDown(benchmark::State & st)
-  {
-    PerformanceTest::TearDown(st);
-    subscriptions.clear();
-    publishers.clear();
-    nodes.clear();
-    rclcpp::shutdown();
-  }
-
-  test_msgs::msg::Empty empty_msgs;
-  std::vector<rclcpp::Node::SharedPtr> nodes;
-  std::vector<rclcpp::Publisher<test_msgs::msg::Empty>::SharedPtr> publishers;
-  std::vector<rclcpp::Subscription<test_msgs::msg::Empty>::SharedPtr> subscriptions;
-  int callback_count;
-};
-
-BENCHMARK_F(PerformanceTestExecutor, single_thread_executor_spin_some)(benchmark::State & st)
-{
-  rclcpp::executors::SingleThreadedExecutor executor;
-  for (unsigned int i = 0u; i < kNumberOfNodes; i++) {
-    executor.add_node(nodes[i]);
-    publishers[i]->publish(empty_msgs);
-    executor.spin_some(100ms);
-  }
-
-  callback_count = 0;
-  reset_heap_counters();
-
-  for (auto _ : st) {
-    st.PauseTiming();
-    for (unsigned int i = 0u; i < kNumberOfNodes; i++) {
-      publishers[i]->publish(empty_msgs);
-    }
-    st.ResumeTiming();
-
-    executor.spin_some(100ms);
-  }
-  if (callback_count == 0) {
-    st.SkipWithError("No message was received");
-  }
-}
-
-BENCHMARK_F(PerformanceTestExecutor, multi_thread_executor_spin_some)(benchmark::State & st)
-{
-  rclcpp::executors::MultiThreadedExecutor executor;
-  for (unsigned int i = 0u; i < kNumberOfNodes; i++) {
-    executor.add_node(nodes[i]);
-    publishers[i]->publish(empty_msgs);
-    executor.spin_some(100ms);
-  }
-
-  callback_count = 0;
-  reset_heap_counters();
-
-  for (auto _ : st) {
-    st.PauseTiming();
-    for (unsigned int i = 0u; i < kNumberOfNodes; i++) {
-      publishers[i]->publish(empty_msgs);
-    }
-    st.ResumeTiming();
-
-    executor.spin_some(100ms);
-  }
-  if (callback_count == 0) {
-    st.SkipWithError("No message was received");
-  }
-}
-
-class PerformanceTestExecutorSimple : public PerformanceTest
-{
-public:
-  void SetUp(benchmark::State & st)
-  {
-    rclcpp::init(0, nullptr);
-    node = std::make_shared<rclcpp::Node>("my_node");
-
-    PerformanceTest::SetUp(st);
-  }
-  void TearDown(benchmark::State & st)
-  {
-    PerformanceTest::TearDown(st);
-    node.reset();
-    rclcpp::shutdown();
-  }
-
-  rclcpp::Node::SharedPtr node;
-};
-
-
-BENCHMARK_F(PerformanceTestExecutorSimple, single_thread_executor_add_node)(benchmark::State & st)
-{
-  rclcpp::executors::SingleThreadedExecutor executor;
-  for (auto _ : st) {
-    executor.add_node(node);
-    st.PauseTiming();
-    executor.remove_node(node);
-    st.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(
-  PerformanceTestExecutorSimple, single_thread_executor_remove_node)(benchmark::State & st)
-{
-  rclcpp::executors::SingleThreadedExecutor executor;
-  for (auto _ : st) {
-    st.PauseTiming();
-    executor.add_node(node);
-    st.ResumeTiming();
-    executor.remove_node(node);
-  }
-}
-
-BENCHMARK_F(PerformanceTestExecutorSimple, multi_thread_executor_add_node)(benchmark::State & st)
-{
-  rclcpp::executors::MultiThreadedExecutor executor;
-  for (auto _ : st) {
-    executor.add_node(node);
-    st.PauseTiming();
-    executor.remove_node(node);
-    st.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(PerformanceTestExecutorSimple, multi_thread_executor_remove_node)(benchmark::State & st)
-{
-  rclcpp::executors::MultiThreadedExecutor executor;
-  for (auto _ : st) {
-    st.PauseTiming();
-    executor.add_node(node);
-    st.ResumeTiming();
-    executor.remove_node(node);
-  }
-}
-
-BENCHMARK_F(
-  PerformanceTestExecutorSimple,
-  static_single_thread_executor_add_node)(benchmark::State & st)
-{
-  rclcpp::executors::StaticSingleThreadedExecutor executor;
-  for (auto _ : st) {
-    executor.add_node(node);
-    st.PauseTiming();
-    executor.remove_node(node);
-    st.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(
-  PerformanceTestExecutorSimple,
-  static_single_thread_executor_remove_node)(benchmark::State & st)
-{
-  rclcpp::executors::StaticSingleThreadedExecutor executor;
-  for (auto _ : st) {
-    st.PauseTiming();
-    executor.add_node(node);
-    st.ResumeTiming();
-    executor.remove_node(node);
-  }
-}
-
-BENCHMARK_F(
-  PerformanceTestExecutorSimple,
-  static_single_thread_executor_spin_until_future_complete)(benchmark::State & st)
-{
-  rclcpp::executors::StaticSingleThreadedExecutor executor;
-  // test success of an immediately finishing future
-  std::promise<bool> promise;
-  std::future<bool> future = promise.get_future();
-  promise.set_value(true);
-  auto shared_future = future.share();
-
-  auto ret = executor.spin_until_future_complete(shared_future, 100ms);
-  if (ret != rclcpp::FutureReturnCode::SUCCESS) {
-    st.SkipWithError(rcutils_get_error_string().str);
-  }
-
-  reset_heap_counters();
-
-  for (auto _ : st) {
-    // static_single_thread_executor has a special design. We need to add/remove the node each
-    // time you call spin
-    st.PauseTiming();
-    executor.add_node(node);
-    st.ResumeTiming();
-
-    ret = executor.spin_until_future_complete(shared_future, 100ms);
-    if (ret != rclcpp::FutureReturnCode::SUCCESS) {
-      st.SkipWithError(rcutils_get_error_string().str);
-      break;
-    }
-    st.PauseTiming();
-    executor.remove_node(node);
-    st.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(
-  PerformanceTestExecutorSimple,
-  single_thread_executor_spin_node_until_future_complete)(benchmark::State & st)
-{
-  rclcpp::executors::SingleThreadedExecutor executor;
-  // test success of an immediately finishing future
-  std::promise<bool> promise;
-  std::future<bool> future = promise.get_future();
-  promise.set_value(true);
-  auto shared_future = future.share();
-
-  auto ret = rclcpp::executors::spin_node_until_future_complete(
-    executor, node, shared_future, 1s);
-  if (ret != rclcpp::FutureReturnCode::SUCCESS) {
-    st.SkipWithError(rcutils_get_error_string().str);
-  }
-
-  reset_heap_counters();
-
-  for (auto _ : st) {
-    ret = rclcpp::executors::spin_node_until_future_complete(
-      executor, node, shared_future, 1s);
-    if (ret != rclcpp::FutureReturnCode::SUCCESS) {
-      st.SkipWithError(rcutils_get_error_string().str);
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(
-  PerformanceTestExecutorSimple,
-  multi_thread_executor_spin_node_until_future_complete)(benchmark::State & st)
-{
-  rclcpp::executors::MultiThreadedExecutor executor;
-  // test success of an immediately finishing future
-  std::promise<bool> promise;
-  std::future<bool> future = promise.get_future();
-  promise.set_value(true);
-  auto shared_future = future.share();
-
-  auto ret = rclcpp::executors::spin_node_until_future_complete(
-    executor, node, shared_future, 1s);
-  if (ret != rclcpp::FutureReturnCode::SUCCESS) {
-    st.SkipWithError(rcutils_get_error_string().str);
-  }
-
-  reset_heap_counters();
-
-  for (auto _ : st) {
-    ret = rclcpp::executors::spin_node_until_future_complete(
-      executor, node, shared_future, 1s);
-    if (ret != rclcpp::FutureReturnCode::SUCCESS) {
-      st.SkipWithError(rcutils_get_error_string().str);
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(
-  PerformanceTestExecutorSimple,
-  static_single_thread_executor_spin_node_until_future_complete)(benchmark::State & st)
-{
-  rclcpp::executors::StaticSingleThreadedExecutor executor;
-  // test success of an immediately finishing future
-  std::promise<bool> promise;
-  std::future<bool> future = promise.get_future();
-  promise.set_value(true);
-  auto shared_future = future.share();
-
-  reset_heap_counters();
-
-  for (auto _ : st) {
-    auto ret = rclcpp::executors::spin_node_until_future_complete(
-      executor, node, shared_future, 1s);
-    if (ret != rclcpp::FutureReturnCode::SUCCESS) {
-      st.SkipWithError(rcutils_get_error_string().str);
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(PerformanceTestExecutorSimple, spin_until_future_complete)(benchmark::State & st)
-{
-  // test success of an immediately finishing future
-  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, shared_future, 1s);
-  if (ret != rclcpp::FutureReturnCode::SUCCESS) {
-    st.SkipWithError(rcutils_get_error_string().str);
-  }
-
-  reset_heap_counters();
-
-  for (auto _ : st) {
-    ret = rclcpp::spin_until_future_complete(node, shared_future, 1s);
-    if (ret != rclcpp::FutureReturnCode::SUCCESS) {
-      st.SkipWithError(rcutils_get_error_string().str);
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(
-  PerformanceTestExecutorSimple,
-  static_executor_entities_collector_execute)(benchmark::State & st)
-{
-  rclcpp::executors::StaticExecutorEntitiesCollector::SharedPtr entities_collector_ =
-    std::make_shared<rclcpp::executors::StaticExecutorEntitiesCollector>();
-  entities_collector_->add_node(node->get_node_base_interface());
-
-  rcl_wait_set_t wait_set = rcl_get_zero_initialized_wait_set();
-  rcl_allocator_t allocator = rcl_get_default_allocator();
-  auto shared_context = node->get_node_base_interface()->get_context();
-  rcl_context_t * context = shared_context->get_rcl_context().get();
-  rcl_ret_t ret = rcl_wait_set_init(&wait_set, 100, 100, 100, 100, 100, 100, context, allocator);
-  if (ret != RCL_RET_OK) {
-    st.SkipWithError(rcutils_get_error_string().str);
-  }
-  RCLCPP_SCOPE_EXIT(
-  {
-    rcl_ret_t ret = rcl_wait_set_fini(&wait_set);
-    if (ret != RCL_RET_OK) {
-      st.SkipWithError(rcutils_get_error_string().str);
-    }
-  });
-
-  auto memory_strategy = rclcpp::memory_strategies::create_default_strategy();
-  rclcpp::GuardCondition guard_condition(shared_context);
-  rcl_guard_condition_t rcl_guard_condition = guard_condition.get_rcl_guard_condition();
-
-  entities_collector_->init(&wait_set, memory_strategy, &rcl_guard_condition);
-  RCLCPP_SCOPE_EXIT(entities_collector_->fini());
-
-  reset_heap_counters();
-
-  for (auto _ : st) {
-    std::shared_ptr<void> data = entities_collector_->take_data();
-    entities_collector_->execute(data);
-  }
-}

rclcpp/test/benchmark/benchmark_init_shutdown.cpp

@@ -1,53 +0,0 @@
-// Copyright 2020 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 "performance_test_fixture/performance_test_fixture.hpp"
-
-#include "rclcpp/rclcpp.hpp"
-
-using performance_test_fixture::PerformanceTest;
-
-BENCHMARK_F(PerformanceTest, rclcpp_init)(benchmark::State & state)
-{
-  // Warmup and prime caches
-  rclcpp::init(0, nullptr);
-  rclcpp::shutdown();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    rclcpp::init(0, nullptr);
-
-    state.PauseTiming();
-    rclcpp::shutdown();
-    state.ResumeTiming();
-    benchmark::ClobberMemory();
-  }
-}
-
-BENCHMARK_F(PerformanceTest, rclcpp_shutdown)(benchmark::State & state)
-{
-  // Warmup and prime caches
-  rclcpp::init(0, nullptr);
-  rclcpp::shutdown();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    state.PauseTiming();
-    rclcpp::init(0, nullptr);
-    state.ResumeTiming();
-
-    rclcpp::shutdown();
-    benchmark::ClobberMemory();
-  }
-}

rclcpp/test/benchmark/benchmark_node.cpp

@@ -1,81 +0,0 @@
-// Copyright 2020 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 <memory>
-#include <string>
-
-#include "performance_test_fixture/performance_test_fixture.hpp"
-#include "rclcpp/rclcpp.hpp"
-
-using performance_test_fixture::PerformanceTest;
-
-class NodePerformanceTest : public PerformanceTest
-{
-public:
-  void SetUp(benchmark::State & state)
-  {
-    rclcpp::init(0, nullptr);
-    performance_test_fixture::PerformanceTest::SetUp(state);
-  }
-
-  void TearDown(benchmark::State & state)
-  {
-    performance_test_fixture::PerformanceTest::TearDown(state);
-    rclcpp::shutdown();
-  }
-};
-
-BENCHMARK_F(NodePerformanceTest, create_node)(benchmark::State & state)
-{
-  // Warmup and prime caches
-  auto outer_node = std::make_shared<rclcpp::Node>("node");
-  outer_node.reset();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    // Using pointer to separate construction and destruction in timing
-    auto node = std::make_shared<rclcpp::Node>("node");
-#ifndef __clang_analyzer__
-    benchmark::DoNotOptimize(node);
-#endif
-    benchmark::ClobberMemory();
-
-    // Ensure destruction of node is not counted toward timing
-    state.PauseTiming();
-    node.reset();
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(NodePerformanceTest, destroy_node)(benchmark::State & state)
-{
-  // Warmup and prime caches
-  auto outer_node = std::make_shared<rclcpp::Node>("node");
-  outer_node.reset();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    // Using pointer to separate construction and destruction in timing
-    state.PauseTiming();
-    auto node = std::make_shared<rclcpp::Node>("node");
-    state.ResumeTiming();
-
-#ifndef __clang_analyzer__
-    benchmark::DoNotOptimize(node);
-#endif
-    benchmark::ClobberMemory();
-
-    node.reset();
-  }
-}

rclcpp/test/benchmark/benchmark_node_parameters_interface.cpp

@@ -1,267 +0,0 @@
-// Copyright 2020 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 <memory>
-#include <string>
-#include <vector>
-
-#include "performance_test_fixture/performance_test_fixture.hpp"
-
-#include "rclcpp/rclcpp.hpp"
-
-class NodeParametersInterfaceTest : public performance_test_fixture::PerformanceTest
-{
-public:
-  NodeParametersInterfaceTest()
-  : node_name("my_node"),
-    param_prefix("my_prefix"),
-    param1_name(param_prefix + ".my_param_1"),
-    param2_name(param_prefix + ".my_param_2"),
-    param3_name(param_prefix + ".my_param_3")
-  {
-    dynamically_typed_descriptor.dynamic_typing = true;
-  }
-
-  void SetUp(benchmark::State & state)
-  {
-    rclcpp::init(0, nullptr);
-    node = std::make_shared<rclcpp::Node>(node_name);
-
-    node->declare_parameter(
-      param1_name, rclcpp::ParameterValue{}, dynamically_typed_descriptor);
-    node->declare_parameter(
-      param2_name, rclcpp::ParameterValue{}, dynamically_typed_descriptor);
-    node->declare_parameter(
-      param3_name, rclcpp::ParameterValue{}, dynamically_typed_descriptor);
-    node->undeclare_parameter(param3_name);
-
-    performance_test_fixture::PerformanceTest::SetUp(state);
-  }
-
-  void TearDown(benchmark::State & state)
-  {
-    performance_test_fixture::PerformanceTest::TearDown(state);
-
-    node.reset();
-    rclcpp::shutdown();
-  }
-
-  const std::string node_name;
-  const std::string param_prefix;
-  const std::string param1_name;
-  const std::string param2_name;
-  const std::string param3_name;
-  rcl_interfaces::msg::ParameterDescriptor dynamically_typed_descriptor;
-
-protected:
-  rclcpp::Node::SharedPtr node;
-};
-
-BENCHMARK_F(NodeParametersInterfaceTest, declare_undeclare)(benchmark::State & state)
-{
-  for (auto _ : state) {
-    node->declare_parameter(param3_name, rclcpp::ParameterValue{}, dynamically_typed_descriptor);
-    node->undeclare_parameter(param3_name);
-  }
-}
-
-BENCHMARK_F(NodeParametersInterfaceTest, has_parameter_hit)(benchmark::State & state)
-{
-  for (auto _ : state) {
-    if (!node->has_parameter(param1_name)) {
-      state.SkipWithError("Parameter was expected");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(NodeParametersInterfaceTest, has_parameter_miss)(benchmark::State & state)
-{
-  for (auto _ : state) {
-    if (node->has_parameter(param3_name)) {
-      state.SkipWithError("Parameter was not expected");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(NodeParametersInterfaceTest, set_parameters_bool)(benchmark::State & state)
-{
-  const std::vector<rclcpp::Parameter> param_values1
-  {
-    rclcpp::Parameter(param1_name, true),
-    rclcpp::Parameter(param2_name, false),
-  };
-  const std::vector<rclcpp::Parameter> param_values2
-  {
-    rclcpp::Parameter(param1_name, false),
-    rclcpp::Parameter(param2_name, true),
-  };
-
-  reset_heap_counters();
-
-  for (auto _ : state) {
-    node->set_parameters(param_values2);
-    node->set_parameters(param_values1);
-  }
-}
-
-BENCHMARK_F(NodeParametersInterfaceTest, set_parameters_atomically_bool)(benchmark::State & state)
-{
-  const std::vector<rclcpp::Parameter> param_values1
-  {
-    rclcpp::Parameter(param1_name, true),
-    rclcpp::Parameter(param2_name, false),
-  };
-  const std::vector<rclcpp::Parameter> param_values2
-  {
-    rclcpp::Parameter(param1_name, false),
-    rclcpp::Parameter(param2_name, true),
-  };
-
-  reset_heap_counters();
-
-  for (auto _ : state) {
-    node->set_parameters_atomically(param_values2);
-    node->set_parameters_atomically(param_values1);
-  }
-}
-
-BENCHMARK_F(NodeParametersInterfaceTest, set_parameters_callback_bool)(benchmark::State & state)
-{
-  const std::vector<rclcpp::Parameter> param_values1
-  {
-    rclcpp::Parameter(param1_name, true),
-    rclcpp::Parameter(param2_name, false),
-  };
-  const std::vector<rclcpp::Parameter> param_values2
-  {
-    rclcpp::Parameter(param1_name, false),
-    rclcpp::Parameter(param2_name, true),
-  };
-
-  rcl_interfaces::msg::SetParametersResult callback_result;
-  bool callback_received = false;
-  callback_result.successful = true;
-  auto callback =
-    [&callback_result, &callback_received](const std::vector<rclcpp::Parameter> &) {
-      callback_received = true;
-      return callback_result;
-    };
-  auto handle = node->add_on_set_parameters_callback(callback);
-
-  reset_heap_counters();
-
-  for (auto _ : state) {
-    node->set_parameters(param_values2);
-    node->set_parameters(param_values1);
-  }
-
-  if (!callback_received) {
-    state.SkipWithError("Callback is not functioning");
-  }
-
-  node->remove_on_set_parameters_callback(handle.get());
-}
-
-BENCHMARK_F(NodeParametersInterfaceTest, set_parameters_string)(benchmark::State & state)
-{
-  const std::vector<rclcpp::Parameter> param_values1
-  {
-    rclcpp::Parameter(param1_name, "param 1 value A"),
-    rclcpp::Parameter(param2_name, "param 2 value B"),
-  };
-  const std::vector<rclcpp::Parameter> param_values2
-  {
-    rclcpp::Parameter(param1_name, "param 1 value B"),
-    rclcpp::Parameter(param2_name, "param 2 value A"),
-  };
-
-  reset_heap_counters();
-
-  for (auto _ : state) {
-    node->set_parameters(param_values2);
-    node->set_parameters(param_values1);
-  }
-}
-
-BENCHMARK_F(NodeParametersInterfaceTest, set_parameters_array)(benchmark::State & state)
-{
-  const std::vector<rclcpp::Parameter> param_values1
-  {
-    rclcpp::Parameter(param1_name, std::vector<int> {0, 1, 2}),
-    rclcpp::Parameter(param2_name, std::vector<int> {3, 4, 5}),
-  };
-  const std::vector<rclcpp::Parameter> param_values2
-  {
-    rclcpp::Parameter(param1_name, std::vector<int> {4, 5, 6}),
-    rclcpp::Parameter(param2_name, std::vector<int> {7, 8, 9}),
-  };
-
-  reset_heap_counters();
-
-  for (auto _ : state) {
-    node->set_parameters(param_values2);
-    node->set_parameters(param_values1);
-  }
-}
-
-BENCHMARK_F(NodeParametersInterfaceTest, get_parameter)(benchmark::State & state)
-{
-  rclcpp::Parameter param1_value;
-
-  reset_heap_counters();
-
-  for (auto _ : state) {
-    node->get_parameter(param1_name, param1_value);
-  }
-}
-
-BENCHMARK_F(NodeParametersInterfaceTest, list_parameters_hit)(benchmark::State & state)
-{
-  rcl_interfaces::msg::ListParametersResult param_list;
-  const std::vector<std::string> prefixes
-  {
-    param_prefix,
-  };
-
-  reset_heap_counters();
-
-  for (auto _ : state) {
-    param_list = node->list_parameters(prefixes, 10);
-    if (param_list.names.size() != 2) {
-      state.SkipWithError("Expected node names");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(NodeParametersInterfaceTest, list_parameters_miss)(benchmark::State & state)
-{
-  rcl_interfaces::msg::ListParametersResult param_list;
-  const std::vector<std::string> prefixes
-  {
-    "your_param",
-  };
-
-  reset_heap_counters();
-
-  for (auto _ : state) {
-    param_list = node->list_parameters(prefixes, 10);
-    if (param_list.names.size() != 0) {
-      state.SkipWithError("Expected no node names");
-      break;
-    }
-  }
-}

rclcpp/test/benchmark/benchmark_parameter_client.cpp

@@ -1,327 +0,0 @@
-// Copyright 2020 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 <memory>
-#include <vector>
-#include <string>
-
-#include "benchmark/benchmark.h"
-
-#include "rclcpp/rclcpp.hpp"
-
-class RemoteNodeTest : public benchmark::Fixture
-{
-public:
-  RemoteNodeTest()
-  : remote_node_name("my_remote_node")
-  {
-  }
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Woverloaded-virtual"
-#endif
-  void SetUp(benchmark::State &)
-  {
-    remote_context = std::make_shared<rclcpp::Context>();
-    remote_context->init(0, nullptr, rclcpp::InitOptions().auto_initialize_logging(false));
-
-    rclcpp::ExecutorOptions exec_options;
-    exec_options.context = remote_context;
-
-    remote_executor = std::make_shared<rclcpp::executors::SingleThreadedExecutor>(exec_options);
-
-    remote_node = std::make_shared<rclcpp::Node>(
-      remote_node_name, rclcpp::NodeOptions().context(remote_context));
-    remote_executor->add_node(remote_node);
-
-    remote_thread = std::thread(&rclcpp::executors::SingleThreadedExecutor::spin, remote_executor);
-  }
-
-  void TearDown(benchmark::State &)
-  {
-    remote_executor->cancel();
-    remote_context->shutdown("Test is complete");
-    remote_thread.join();
-
-    remote_node.reset();
-    remote_executor.reset();
-    remote_context.reset();
-  }
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-  const std::string remote_node_name;
-
-protected:
-  rclcpp::Context::SharedPtr remote_context;
-  rclcpp::executors::SingleThreadedExecutor::SharedPtr remote_executor;
-  rclcpp::Node::SharedPtr remote_node;
-  std::thread remote_thread;
-};
-
-class ParameterClientTest : public RemoteNodeTest
-{
-public:
-  ParameterClientTest()
-  : node_name("my_node"),
-    param_prefix("my_prefix"),
-    param1_name(param_prefix + ".my_param_1"),
-    param2_name(param_prefix + ".my_param_2"),
-    param3_name(param_prefix + ".my_param_3")
-  {
-  }
-
-  void SetUp(benchmark::State & state)
-  {
-    RemoteNodeTest::SetUp(state);
-
-    rclcpp::init(0, nullptr);
-    node = std::make_shared<rclcpp::Node>(node_name);
-
-    rcl_interfaces::msg::ParameterDescriptor descriptor;
-    descriptor.dynamic_typing = true;
-
-    remote_node->declare_parameter(
-      param1_name, rclcpp::ParameterValue("param1_value"), descriptor);
-    remote_node->declare_parameter(
-      param2_name, rclcpp::ParameterValue(std::vector<int> {1, 2, 3}), descriptor);
-    remote_node->declare_parameter(param3_name, rclcpp::ParameterValue{}, descriptor);
-    remote_node->undeclare_parameter(param3_name);
-
-    params_client = std::make_shared<rclcpp::SyncParametersClient>(node, remote_node_name);
-
-    if (!params_client->wait_for_service()) {
-      state.SkipWithError("Client failed to become ready");
-    }
-  }
-
-  void TearDown(benchmark::State & state)
-  {
-    RemoteNodeTest::TearDown(state);
-
-    rclcpp::shutdown();
-    node.reset();
-    params_client.reset();
-  }
-
-  const std::string node_name;
-  const std::string param_prefix;
-  const std::string param1_name;
-  const std::string param2_name;
-  const std::string param3_name;
-
-protected:
-  rclcpp::Node::SharedPtr node;
-  rclcpp::SyncParametersClient::SharedPtr params_client;
-};
-
-static bool result_is_successful(rcl_interfaces::msg::SetParametersResult result)
-{
-  return result.successful;
-}
-
-BENCHMARK_F(ParameterClientTest, create_destroy_client)(benchmark::State & state)
-{
-  for (auto _ : state) {
-    params_client.reset();
-    params_client = std::make_shared<rclcpp::SyncParametersClient>(node, remote_node_name);
-    if (!params_client->wait_for_service()) {
-      state.SkipWithError("Client failed to become ready");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(ParameterClientTest, has_parameter_hit)(benchmark::State & state)
-{
-  for (auto _ : state) {
-    if (!params_client->has_parameter(param1_name)) {
-      state.SkipWithError("Parameter was expected");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(ParameterClientTest, has_parameter_miss)(benchmark::State & state)
-{
-  for (auto _ : state) {
-    if (params_client->has_parameter(param3_name)) {
-      state.SkipWithError("Parameter was not expected");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(ParameterClientTest, set_parameters_bool)(benchmark::State & state)
-{
-  const std::vector<rclcpp::Parameter> param_values1
-  {
-    rclcpp::Parameter(param1_name, true),
-    rclcpp::Parameter(param2_name, false),
-  };
-  const std::vector<rclcpp::Parameter> param_values2
-  {
-    rclcpp::Parameter(param1_name, false),
-    rclcpp::Parameter(param2_name, true),
-  };
-
-  for (auto _ : state) {
-    std::vector<rcl_interfaces::msg::SetParametersResult> results =
-      params_client->set_parameters(param_values2);
-    if (!std::all_of(results.begin(), results.end(), result_is_successful)) {
-      state.SkipWithError("Failed to set one or more parameters");
-      break;
-    }
-
-    results = params_client->set_parameters(param_values1);
-    if (!std::all_of(results.begin(), results.end(), result_is_successful)) {
-      state.SkipWithError("Failed to set one or more parameters");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(ParameterClientTest, set_parameters_atomically_bool)(benchmark::State & state)
-{
-  const std::vector<rclcpp::Parameter> param_values1
-  {
-    rclcpp::Parameter(param1_name, true),
-    rclcpp::Parameter(param2_name, false),
-  };
-  const std::vector<rclcpp::Parameter> param_values2
-  {
-    rclcpp::Parameter(param1_name, false),
-    rclcpp::Parameter(param2_name, true),
-  };
-
-  for (auto _ : state) {
-    rcl_interfaces::msg::SetParametersResult result =
-      params_client->set_parameters_atomically(param_values2);
-    if (!result.successful) {
-      state.SkipWithError(("Failed to set parameters: " + result.reason).c_str());
-      break;
-    }
-
-    result = params_client->set_parameters_atomically(param_values1);
-    if (!result.successful) {
-      state.SkipWithError(("Failed to set parameters: " + result.reason).c_str());
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(ParameterClientTest, set_parameters_string)(benchmark::State & state)
-{
-  const std::vector<rclcpp::Parameter> param_values1
-  {
-    rclcpp::Parameter(param1_name, "param 1 value A"),
-    rclcpp::Parameter(param2_name, "param 2 value B"),
-  };
-  const std::vector<rclcpp::Parameter> param_values2
-  {
-    rclcpp::Parameter(param1_name, "param 1 value B"),
-    rclcpp::Parameter(param2_name, "param 2 value A"),
-  };
-
-  for (auto _ : state) {
-    std::vector<rcl_interfaces::msg::SetParametersResult> results =
-      params_client->set_parameters(param_values2);
-    if (!std::all_of(results.begin(), results.end(), result_is_successful)) {
-      state.SkipWithError("Failed to set one or more parameters");
-      break;
-    }
-
-    results = params_client->set_parameters(param_values1);
-    if (!std::all_of(results.begin(), results.end(), result_is_successful)) {
-      state.SkipWithError("Failed to set one or more parameters");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(ParameterClientTest, set_parameters_array)(benchmark::State & state)
-{
-  const std::vector<rclcpp::Parameter> param_values1
-  {
-    rclcpp::Parameter(param1_name, std::vector<int> {0, 1, 2}),
-    rclcpp::Parameter(param2_name, std::vector<int> {3, 4, 5}),
-  };
-  const std::vector<rclcpp::Parameter> param_values2
-  {
-    rclcpp::Parameter(param1_name, std::vector<int> {4, 5, 6}),
-    rclcpp::Parameter(param2_name, std::vector<int> {7, 8, 9}),
-  };
-
-  for (auto _ : state) {
-    std::vector<rcl_interfaces::msg::SetParametersResult> results =
-      params_client->set_parameters(param_values2);
-    if (!std::all_of(results.begin(), results.end(), result_is_successful)) {
-      state.SkipWithError("Failed to set one or more parameters");
-      break;
-    }
-
-    results = params_client->set_parameters(param_values1);
-    if (!std::all_of(results.begin(), results.end(), result_is_successful)) {
-      state.SkipWithError("Failed to set one or more parameters");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(ParameterClientTest, get_parameters)(benchmark::State & state)
-{
-  for (auto _ : state) {
-    std::vector<rclcpp::Parameter> results = params_client->get_parameters({param1_name});
-    if (results.size() != 1 || results[0].get_name() != param1_name) {
-      state.SkipWithError("Got the wrong parameter(s)");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(ParameterClientTest, list_parameters_hit)(benchmark::State & state)
-{
-  const std::vector<std::string> prefixes
-  {
-    param_prefix,
-  };
-
-  for (auto _ : state) {
-    rcl_interfaces::msg::ListParametersResult param_list =
-      params_client->list_parameters(prefixes, 10);
-    if (param_list.names.size() != 2) {
-      state.SkipWithError("Expected parameters");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(ParameterClientTest, list_parameters_miss)(benchmark::State & state)
-{
-  const std::vector<std::string> prefixes
-  {
-    "your_prefix",
-  };
-
-  for (auto _ : state) {
-    rcl_interfaces::msg::ListParametersResult param_list =
-      params_client->list_parameters(prefixes, 10);
-    if (param_list.names.size() != 0) {
-      state.SkipWithError("Expected no parameters");
-      break;
-    }
-  }
-}

rclcpp/test/benchmark/benchmark_service.cpp

@@ -1,141 +0,0 @@
-// Copyright 2020 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 <memory>
-
-#include "performance_test_fixture/performance_test_fixture.hpp"
-#include "rclcpp/rclcpp.hpp"
-#include "test_msgs/srv/empty.hpp"
-
-using performance_test_fixture::PerformanceTest;
-
-constexpr char empty_service_name[] = "empty_service";
-
-class ServicePerformanceTest : public PerformanceTest
-{
-public:
-  ServicePerformanceTest()
-  : callback_count(0) {}
-
-  void SetUp(benchmark::State & state)
-  {
-    rclcpp::init(0, nullptr);
-    node = std::make_unique<rclcpp::Node>("node", "ns");
-    empty_client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-    callback_count = 0;
-
-    performance_test_fixture::PerformanceTest::SetUp(state);
-  }
-
-  void TearDown(benchmark::State & state)
-  {
-    performance_test_fixture::PerformanceTest::TearDown(state);
-
-    empty_client.reset();
-    node.reset();
-    rclcpp::shutdown();
-  }
-
-  void ServiceCallback(
-    const test_msgs::srv::Empty::Request::SharedPtr,
-    test_msgs::srv::Empty::Response::SharedPtr)
-  {
-    callback_count++;
-  }
-
-protected:
-  std::unique_ptr<rclcpp::Node> node;
-  std::shared_ptr<rclcpp::Client<test_msgs::srv::Empty>> empty_client;
-  int callback_count;
-};
-
-BENCHMARK_F(ServicePerformanceTest, construct_service_no_client)(benchmark::State & state) {
-  auto callback = std::bind(
-    &ServicePerformanceTest::ServiceCallback,
-    this, std::placeholders::_1, std::placeholders::_2);
-
-  auto outer_service = node->create_service<test_msgs::srv::Empty>("not_a_service", callback);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto service = node->create_service<test_msgs::srv::Empty>("not_a_service", callback);
-    benchmark::DoNotOptimize(service);
-    benchmark::ClobberMemory();
-
-    state.PauseTiming();
-    service.reset();
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(ServicePerformanceTest, construct_service_empty_srv)(benchmark::State & state) {
-  auto callback = std::bind(
-    &ServicePerformanceTest::ServiceCallback,
-    this, std::placeholders::_1, std::placeholders::_2);
-  auto outer_service = node->create_service<test_msgs::srv::Empty>(empty_service_name, callback);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto service = node->create_service<test_msgs::srv::Empty>(empty_service_name, callback);
-    benchmark::DoNotOptimize(service);
-    benchmark::ClobberMemory();
-
-    state.PauseTiming();
-    service.reset();
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(ServicePerformanceTest, destroy_service_empty_srv)(benchmark::State & state) {
-  auto callback = std::bind(
-    &ServicePerformanceTest::ServiceCallback,
-    this, std::placeholders::_1, std::placeholders::_2);
-  auto outer_service = node->create_service<test_msgs::srv::Empty>(empty_service_name, callback);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    state.PauseTiming();
-    auto service = node->create_service<test_msgs::srv::Empty>(empty_service_name, callback);
-    state.ResumeTiming();
-    benchmark::DoNotOptimize(service);
-    benchmark::ClobberMemory();
-
-    service.reset();
-  }
-}
-
-BENCHMARK_F(ServicePerformanceTest, async_send_response)(benchmark::State & state) {
-  auto callback = std::bind(
-    &ServicePerformanceTest::ServiceCallback,
-    this, std::placeholders::_1, std::placeholders::_2);
-  auto service = node->create_service<test_msgs::srv::Empty>(empty_service_name, callback);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    state.PauseTiming();
-    // Clear executor queue
-    rclcpp::spin_some(node->get_node_base_interface());
-
-    auto request = std::make_shared<test_msgs::srv::Empty::Request>();
-    auto future = empty_client->async_send_request(request);
-    state.ResumeTiming();
-    benchmark::DoNotOptimize(service);
-    benchmark::ClobberMemory();
-
-    rclcpp::spin_until_future_complete(node->get_node_base_interface(), future);
-  }
-  if (callback_count == 0) {
-    state.SkipWithError("Service callback was not called");
-  }
-}

rclcpp/test/rclcpp/CMakeLists.txt

@@ -1,16 +1,10 @@
+add_subdirectory(benchmark)
+
 find_package(ament_cmake_gtest REQUIRED)
 
 find_package(rmw_implementation_cmake REQUIRED)
 
-add_definitions(-DTEST_RESOURCES_DIRECTORY="${TEST_RESOURCES_DIRECTORY}")
-
-rosidl_generate_interfaces(${PROJECT_NAME}_test_msgs
-  ../msg/Header.msg
-  ../msg/MessageWithHeader.msg
-  DEPENDENCIES builtin_interfaces
-  LIBRARY_NAME ${PROJECT_NAME}
-  SKIP_INSTALL
-)
+add_definitions(-DTEST_RESOURCES_DIRECTORY="${CMAKE_CURRENT_BINARY_DIR}/../resources")
 
 ament_add_gtest(
   test_allocator_common
@@ -323,16 +317,6 @@ if(TARGET test_parameter)
   )
   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})
@@ -379,18 +363,6 @@ if(TARGET test_qos_event)
     mimick
   )
 endif()
-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}
-  )
-endif()
-ament_add_gmock(test_qos_parameters test_qos_parameters.cpp)
-if(TARGET test_qos_parameters)
-  target_link_libraries(test_qos_parameters
-    ${PROJECT_NAME}
-  )
-endif()
 ament_add_gtest(test_rate test_rate.cpp)
 if(TARGET test_rate)
   ament_target_dependencies(test_rate

rclcpp/test/rclcpp/allocator/test_allocator_common.cpp

@@ -23,9 +23,7 @@ TEST(TestAllocatorCommon, retyped_allocate) {
   void * untyped_allocator = &allocator;
   void * allocated_mem =
     rclcpp::allocator::retyped_allocate<std::allocator<char>>(1u, untyped_allocator);
-  // The more natural check here is ASSERT_NE(nullptr, ptr), but clang static
-  // analysis throws a false-positive memory leak warning.  Use ASSERT_TRUE instead.
-  ASSERT_TRUE(nullptr != allocated_mem);
+  ASSERT_NE(nullptr, allocated_mem);
 
   auto code = [&untyped_allocator, allocated_mem]() {
       rclcpp::allocator::retyped_deallocate<int, std::allocator<int>>(
@@ -34,15 +32,11 @@ TEST(TestAllocatorCommon, retyped_allocate) {
   EXPECT_NO_THROW(code());
 
   allocated_mem = allocator.allocate(1);
-  // The more natural check here is ASSERT_NE(nullptr, ptr), but clang static
-  // analysis throws a false-positive memory leak warning.  Use ASSERT_TRUE instead.
-  ASSERT_TRUE(nullptr != allocated_mem);
+  ASSERT_NE(nullptr, allocated_mem);
   void * reallocated_mem =
     rclcpp::allocator::retyped_reallocate<int, std::allocator<int>>(
     allocated_mem, 2u, untyped_allocator);
-  // The more natural check here is ASSERT_NE(nullptr, ptr), but clang static
-  // analysis throws a false-positive memory leak warning.  Use ASSERT_TRUE instead.
-  ASSERT_TRUE(nullptr != reallocated_mem);
+  ASSERT_NE(nullptr, reallocated_mem);
 
   auto code2 = [&untyped_allocator, reallocated_mem]() {
       rclcpp::allocator::retyped_deallocate<int, std::allocator<int>>(

rclcpp/test/rclcpp/allocator/test_allocator_deleter.cpp

@@ -38,9 +38,7 @@ TEST(TestAllocatorDeleter, construct_destruct) {
 TEST(TestAllocatorDeleter, delete) {
   std::allocator<int> allocator;
   int * some_mem = allocator.allocate(1u);
-  // The more natural check here is ASSERT_NE(nullptr, ptr), but clang static
-  // analysis throws a false-positive memory leak warning.  Use ASSERT_TRUE instead.
-  ASSERT_TRUE(nullptr != some_mem);
+  ASSERT_NE(nullptr, some_mem);
 
   rclcpp::allocator::AllocatorDeleter<std::allocator<int>> deleter(&allocator);
   EXPECT_NO_THROW(deleter(some_mem));

rclcpp/test/rclcpp/benchmark/CMakeLists.txt

@@ -0,0 +1,29 @@
+# Give cppcheck hints about macro definitions coming from outside this package
+get_target_property(
+  ament_cmake_cppcheck_ADDITIONAL_INCLUDE_DIRS
+  performance_test_fixture::performance_test_fixture
+  INTERFACE_INCLUDE_DIRECTORIES)
+
+function(add_rclcpp_benchmark NAME SOURCE)
+  cmake_parse_arguments(RCLCPP_BENCHMARK "" "LIBRARIES" "")
+  if(RCLCPP_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unrecognized arguments for 'add_rclcpp_benchmark' (${RCLCPP_UNPARSED_ARGUMENTS})")
+    return()
+  endif()
+  find_package(${rmw_implementation} REQUIRED)
+  message(STATUS "Adding ${NAME} for '${rmw_implementation}'")
+  set(rmw_implementation_env_var RMW_IMPLEMENTATION=${rmw_implementation})
+
+  set(full_benchmark_name ${NAME}${target_suffix})
+  add_performance_test(${full_benchmark_name} ${SOURCE})
+  if(TARGET ${full_benchmark_name})
+    target_link_libraries(${full_benchmark_name} ${PROJECT_NAME} ${LIBRARIES})
+  endif()
+endfunction()
+
+# Add new benchmarks inside this macro
+macro(rclcpp_benchmarks)
+  add_rclcpp_benchmark(benchmark_client benchmark_client.cpp)
+endmacro()
+
+call_for_each_rmw_implementation(rclcpp_benchmarks)

rclcpp/test/rclcpp/benchmark/benchmark_client.cpp

@@ -0,0 +1,13 @@
+// Copyright 2020 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.

rclcpp/test/rclcpp/executors/test_executors.cpp

@@ -115,9 +115,9 @@ public:
   }
 };
 
-// TYPED_TEST_SUITE is deprecated as of gtest 1.9, use TYPED_TEST_SUITE when gtest dependency
+// TYPED_TEST_CASE is deprecated as of gtest 1.9, use TYPED_TEST_SUITE when gtest dependency
 // is updated.
-TYPED_TEST_SUITE(TestExecutors, ExecutorTypes, ExecutorTypeNames);
+TYPED_TEST_CASE(TestExecutors, ExecutorTypes, ExecutorTypeNames);
 
 // StaticSingleThreadedExecutor is not included in these tests for now, due to:
 // https://github.com/ros2/rclcpp/issues/1219
@@ -125,7 +125,7 @@ using StandardExecutors =
   ::testing::Types<
   rclcpp::executors::SingleThreadedExecutor,
   rclcpp::executors::MultiThreadedExecutor>;
-TYPED_TEST_SUITE(TestExecutorsStable, StandardExecutors, ExecutorTypeNames);
+TYPED_TEST_CASE(TestExecutorsStable, StandardExecutors, ExecutorTypeNames);
 
 // Make sure that executors detach from nodes when destructing
 TYPED_TEST(TestExecutors, detachOnDestruction) {
@@ -436,16 +436,9 @@ public:
     return true;
   }
 
-  std::shared_ptr<void>
-  take_data() override
-  {
-    return nullptr;
-  }
-
   void
-  execute(std::shared_ptr<void> & data) override
+  execute() override
   {
-    (void) data;
     count_++;
     std::this_thread::sleep_for(1ms);
   }

rclcpp/test/rclcpp/executors/test_static_executor_entities_collector.cpp

@@ -235,16 +235,7 @@ public:
 
   bool is_ready(rcl_wait_set_t *) override {return true;}
 
-  std::shared_ptr<void>
-  take_data() override
-  {
-    return nullptr;
-  }
-  void
-  execute(std::shared_ptr<void> & data) override
-  {
-    (void) data;
-  }
+  void execute() override {}
 };
 
 TEST_F(TestStaticExecutorEntitiesCollector, add_remove_node_with_entities) {
@@ -372,9 +363,8 @@ TEST_F(TestStaticExecutorEntitiesCollector, prepare_wait_set_rcl_wait_set_clear_
 
   {
     auto mock = mocking_utils::patch_and_return("lib:rclcpp", rcl_wait_set_clear, RCL_RET_ERROR);
-    std::shared_ptr<void> data = entities_collector_->take_data();
     RCLCPP_EXPECT_THROW_EQ(
-      entities_collector_->execute(data),
+      entities_collector_->execute(),
       std::runtime_error("Couldn't clear wait set"));
   }
 
@@ -403,9 +393,8 @@ TEST_F(TestStaticExecutorEntitiesCollector, prepare_wait_set_rcl_wait_set_resize
 
   {
     auto mock = mocking_utils::patch_and_return("lib:rclcpp", rcl_wait_set_resize, RCL_RET_ERROR);
-    std::shared_ptr<void> data = entities_collector_->take_data();
     RCLCPP_EXPECT_THROW_EQ(
-      entities_collector_->execute(data),
+      entities_collector_->execute(),
       std::runtime_error("Couldn't resize the wait set: error not set"));
   }
 
@@ -627,8 +616,7 @@ TEST_F(
   RCLCPP_SCOPE_EXIT(entities_collector_->fini());
 
   cb_group->get_associated_with_executor_atomic().exchange(false);
-  std::shared_ptr<void> data = entities_collector_->take_data();
-  entities_collector_->execute(data);
+  entities_collector_->execute();
 
   EXPECT_TRUE(entities_collector_->remove_node(node->get_node_base_interface()));
 }

rclcpp/test/rclcpp/node_interfaces/test_node_graph.cpp

@@ -14,11 +14,9 @@
 
 #include <gtest/gtest.h>
 
-#include <functional>
 #include <memory>
 #include <string>
 #include <utility>
-#include <vector>
 
 #include "rcl/graph.h"
 #include "rcl/node_options.h"
@@ -68,43 +66,6 @@ protected:
 
   const rclcpp::node_interfaces::NodeGraph * node_graph() const {return node_graph_;}
 
-  size_t get_num_graph_things(std::function<size_t()> predicate)
-  {
-    constexpr std::chrono::milliseconds timeout(100);
-
-    size_t tries = 0;
-    size_t num_things = 0;
-    while (tries++ < 5) {
-      num_things = predicate();
-      if (num_things >= 1) {
-        break;
-      }
-
-      auto event = node()->get_graph_event();
-      EXPECT_NO_THROW(node()->wait_for_graph_change(event, timeout));
-    }
-
-    return num_things;
-  }
-
-  size_t get_num_topics()
-  {
-    return get_num_graph_things(
-      [this]() -> size_t {
-        auto topic_names_and_types = node_graph()->get_topic_names_and_types();
-        return topic_names_and_types.size();
-      });
-  }
-
-  size_t get_num_services()
-  {
-    return get_num_graph_things(
-      [this]() -> size_t {
-        auto service_names_and_types = node_graph()->get_service_names_and_types();
-        return service_names_and_types.size();
-      });
-  }
-
 private:
   std::shared_ptr<rclcpp::Node> node_;
   rclcpp::node_interfaces::NodeGraph * node_graph_;
@@ -112,9 +73,11 @@ private:
 
 TEST_F(TestNodeGraph, construct_from_node)
 {
-  EXPECT_LT(0u, get_num_topics());
+  auto topic_names_and_types = node_graph()->get_topic_names_and_types(false);
+  EXPECT_LT(0u, topic_names_and_types.size());
 
-  EXPECT_LT(0u, get_num_services());
+  auto service_names_and_types = node_graph()->get_service_names_and_types();
+  EXPECT_LT(0u, service_names_and_types.size());
 
   auto names = node_graph()->get_node_names();
   EXPECT_EQ(1u, names.size());
@@ -128,12 +91,13 @@ TEST_F(TestNodeGraph, construct_from_node)
 
   // get_graph_event is non-const
   EXPECT_NE(nullptr, node()->get_node_graph_interface()->get_graph_event());
-  EXPECT_LE(1u, node_graph()->count_graph_users());
+  EXPECT_EQ(1u, node_graph()->count_graph_users());
 }
 
 TEST_F(TestNodeGraph, get_topic_names_and_types)
 {
-  ASSERT_LT(0u, get_num_topics());
+  auto topic_names_and_types = node_graph()->get_topic_names_and_types();
+  EXPECT_LT(0u, topic_names_and_types.size());
 }
 
 TEST_F(TestNodeGraph, get_topic_names_and_types_rcl_error)
@@ -162,7 +126,8 @@ TEST_F(TestNodeGraph, get_topic_names_and_types_rcl_names_and_types_fini_error)
 
 TEST_F(TestNodeGraph, get_service_names_and_types)
 {
-  ASSERT_LT(0u, get_num_services());
+  auto service_names_and_types = node_graph()->get_service_names_and_types();
+  EXPECT_LT(0u, service_names_and_types.size());
 }
 
 TEST_F(TestNodeGraph, get_service_names_and_types_rcl_error)
@@ -344,13 +309,8 @@ TEST_F(TestNodeGraph, get_info_by_topic)
 
   EXPECT_EQ(0u, node_graph()->get_publishers_info_by_topic("topic", true).size());
 
-  std::vector<rclcpp::TopicEndpointInfo> publishers;
-  size_t num_publishers = get_num_graph_things(
-    [this, &publishers]() {
-      publishers = node_graph()->get_publishers_info_by_topic("topic", false);
-      return publishers.size();
-    });
-  ASSERT_EQ(1u, num_publishers);
+  auto publishers = node_graph()->get_publishers_info_by_topic("topic", false);
+  ASSERT_EQ(1u, publishers.size());
 
   auto publisher_endpoint_info = publishers[0];
   const auto const_publisher_endpoint_info = publisher_endpoint_info;

rclcpp/test/rclcpp/node_interfaces/test_node_parameters.cpp

@@ -125,7 +125,7 @@ TEST_F(TestNodeParameters, parameter_overrides)
   auto * node_parameters_interface =
     dynamic_cast<rclcpp::node_interfaces::NodeParameters *>(
     node2->get_node_parameters_interface().get());
-  ASSERT_NE(nullptr, node_parameters_interface);
+  ASSERT_NE(nullptr, node_parameters);
 
   const auto & parameter_overrides = node_parameters_interface->get_parameter_overrides();
   EXPECT_EQ(2u, parameter_overrides.size());

rclcpp/test/rclcpp/node_interfaces/test_node_services.cpp

@@ -16,7 +16,6 @@
 
 #include <memory>
 #include <string>
-#include <vector>
 
 #include "rcl/node_options.h"
 #include "rclcpp/node.hpp"
@@ -56,9 +55,7 @@ public:
   {
     rclcpp::init(0, nullptr);
 
-    rclcpp::NodeOptions options{};
-    options.arguments(std::vector<std::string>{"-r", "foo:=bar"});
-    node = std::make_shared<rclcpp::Node>("node", "ns", options);
+    node = std::make_shared<rclcpp::Node>("node", "ns");
 
     // This dynamic cast is not necessary for the unittest itself, but instead is used to ensure
     // the proper type is being tested and covered.
@@ -132,13 +129,3 @@ TEST_F(TestNodeService, add_client_rcl_trigger_guard_condition_error)
     node_services->add_client(client, callback_group),
     std::runtime_error("Failed to notify wait set on client creation: error not set"));
 }
-
-TEST_F(TestNodeService, resolve_service_name)
-{
-  EXPECT_EQ("/ns/bar", node_services->resolve_service_name("foo", false));
-  EXPECT_EQ("/ns/foo", node_services->resolve_service_name("foo", true));
-  EXPECT_EQ("/foo", node_services->resolve_service_name("/foo", true));
-  EXPECT_THROW(
-    node_services->resolve_service_name("this is not a valid name!~>", true),
-    rclcpp::exceptions::RCLError);
-}

rclcpp/test/rclcpp/node_interfaces/test_node_topics.cpp

@@ -17,7 +17,6 @@
 #include <memory>
 #include <string>
 #include <type_traits>
-#include <vector>
 
 #include "rcl/node_options.h"
 #include "rclcpp/node.hpp"
@@ -81,9 +80,7 @@ public:
   void SetUp()
   {
     rclcpp::init(0, nullptr);
-    rclcpp::NodeOptions options{};
-    options.arguments(std::vector<std::string>{"-r", "foo:=bar"});
-    node = std::make_shared<rclcpp::Node>("node", "ns", options);
+    node = std::make_shared<rclcpp::Node>("node", "ns");
 
     // This dynamic cast is not necessary for the unittest itself, but instead is used to ensure
     // the proper type is being tested and covered.
@@ -157,13 +154,3 @@ TEST_F(TestNodeTopics, add_subscription_rcl_trigger_guard_condition_error)
     node_topics->add_subscription(subscription, callback_group),
     std::runtime_error("failed to notify wait set on subscription creation: error not set"));
 }
-
-TEST_F(TestNodeTopics, resolve_topic_name)
-{
-  EXPECT_EQ("/ns/bar", node_topics->resolve_topic_name("foo", false));
-  EXPECT_EQ("/ns/foo", node_topics->resolve_topic_name("foo", true));
-  EXPECT_EQ("/foo", node_topics->resolve_topic_name("/foo", true));
-  EXPECT_THROW(
-    node_topics->resolve_topic_name("this is not a valid name!~>", true),
-    rclcpp::exceptions::RCLError);
-}