30.1.1

Signed-off-by: Alejandro Hernandez Cordero <ahcorde@gmail.com>

rclcpp/CHANGELOG.rst

@@ -2,35 +2,56 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-29.5.3 (2025-09-11)
+30.1.1 (2025-09-11)
 -------------------
-* Fix: improve exception context for parameter_value_from (`#2917 <https://github.com/ros2/rclcpp/issues/2917>`_) (`#2919 <https://github.com/ros2/rclcpp/issues/2919>`_)
-* Allow for implicitly convertable loggers as well (`#2922 <https://github.com/ros2/rclcpp/issues/2922>`_) (`#2936 <https://github.com/ros2/rclcpp/issues/2936>`_)
-* Fix `start_type_description_service` param handling (`#2897 <https://github.com/ros2/rclcpp/issues/2897>`_) (`#2908 <https://github.com/ros2/rclcpp/issues/2908>`_)
-* Add qos parameter for wait_for_message function (`#2903 <https://github.com/ros2/rclcpp/issues/2903>`_) (`#2905 <https://github.com/ros2/rclcpp/issues/2905>`_)
-* Expose `typesupport_helpers` API needed for the Rosbag2 (`#2858 <https://github.com/ros2/rclcpp/issues/2858>`_) (`#2901 <https://github.com/ros2/rclcpp/issues/2901>`_)
-* Fujitatomoya/test append parameter override (`#2896 <https://github.com/ros2/rclcpp/issues/2896>`_) (`#2899 <https://github.com/ros2/rclcpp/issues/2899>`_)
-* Add overload of `append_parameter_override` (`#2891 <https://github.com/ros2/rclcpp/issues/2891>`_) (`#2894 <https://github.com/ros2/rclcpp/issues/2894>`_)
-* Contributors: Tim Clephas, mergify[bot]
+* Removed warning (`#2949 <https://github.com/ros2/rclcpp/issues/2949>`_)
+* add note about problems with spin_until_future_complete (`#2849 <https://github.com/ros2/rclcpp/issues/2849>`_)
+* deprecate rclcpp::spin_some and rclcpp::spin_all (`#2848 <https://github.com/ros2/rclcpp/issues/2848>`_)
+* Improve the function extract_type_identifier (`#2923 <https://github.com/ros2/rclcpp/issues/2923>`_)
+* Allow for implicitly convertable loggers as well (`#2922 <https://github.com/ros2/rclcpp/issues/2922>`_)
+* Contributors: Alberto Soragna, Alejandro Hernández Cordero, Barry Xu, Tim Clephas
 
-29.5.2 (2025-07-07)
+30.1.0 (2025-07-29)
 -------------------
-* Shutdown deadlock fix jazzy (`#2887 <https://github.com/ros2/rclcpp/issues/2887>`_) (`#2888 <https://github.com/ros2/rclcpp/issues/2888>`_)
-* Fix test_publisher_with_system_default_qos (`#2881 <https://github.com/ros2/rclcpp/issues/2881>`_) (`#2884 <https://github.com/ros2/rclcpp/issues/2884>`_)
-* Contributors: Tomoya Fujita, Janosch Machowinski
+* Fix: improve exception context for parameter_value_from (`#2917 <https://github.com/ros2/rclcpp/issues/2917>`_)
+* Fix `start_type_description_service` param handling (`#2897 <https://github.com/ros2/rclcpp/issues/2897>`_)
+* Add qos parameter for wait_for_message function (`#2903 <https://github.com/ros2/rclcpp/issues/2903>`_)
+* Fujitatomoya/test append parameter override (`#2896 <https://github.com/ros2/rclcpp/issues/2896>`_)
+* Expose `typesupport_helpers` API needed for the Rosbag2 (`#2858 <https://github.com/ros2/rclcpp/issues/2858>`_)
+* Remove comment about now-removed StaticSingleThreadedExecutor (`#2893 <https://github.com/ros2/rclcpp/issues/2893>`_)
+* Add overload of `append_parameter_override` (`#2891 <https://github.com/ros2/rclcpp/issues/2891>`_)
+* fix: Don't deadlock if removing shutdown callbacks in a shutdown callback (`#2886 <https://github.com/ros2/rclcpp/issues/2886>`_)
+* Contributors: Christophe Bedard, Janosch Machowinski, Michael Orlov, Michiel Leegwater, Patrick Roncagliolo, Sriharsha Ghanta, Tomoya Fujita
 
-29.5.1 (2025-06-23)
+30.0.0 (2025-07-01)
+-------------------
+* Hand-code logging.hpp (`#2870 <https://github.com/ros2/rclcpp/issues/2870>`_)
+* Adressed TODO in node_graph (`#2877 <https://github.com/ros2/rclcpp/issues/2877>`_)
+* fix test_publisher_with_system_default_qos. (`#2881 <https://github.com/ros2/rclcpp/issues/2881>`_)
+* Contributors: Alejandro Hernández Cordero, Chris Lalancette, Tomoya Fujita
+
+29.6.1 (2025-06-23)
+-------------------
+* Fix for memory leaks in rclcpp::SerializedMessage (`#2861 <https://github.com/ros2/rclcpp/issues/2861>`_)
+* Removed warning test_qos (`#2859 <https://github.com/ros2/rclcpp/issues/2859>`_)
+* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_)
+* get_all_data_impl() does not handle null pointers properly, causing segmentation fault (`#2840 <https://github.com/ros2/rclcpp/issues/2840>`_)
+* QoSInitialization::from_rmw does not validate invalid history policy values, leading to silent failures (`#2841 <https://github.com/ros2/rclcpp/issues/2841>`_)
+* remove get_notify_guard_condition from NodeBaseInterface. (`#2839 <https://github.com/ros2/rclcpp/issues/2839>`_)
+* Removed deprecated StaticSingleThreadedExecutor (`#2835 <https://github.com/ros2/rclcpp/issues/2835>`_)
+* Removed deprecated rcpputils Path (`#2834 <https://github.com/ros2/rclcpp/issues/2834>`_)
+* Add range constraints for applicable array parameters (`#2828 <https://github.com/ros2/rclcpp/issues/2828>`_)
+* Update RingBufferImplementation to clear internal data. (`#2837 <https://github.com/ros2/rclcpp/issues/2837>`_)
+* Removed deprecated cancel_sleep_or_wait (`#2836 <https://github.com/ros2/rclcpp/issues/2836>`_)
+* Add missing 's' to 'NodeParametersInterface' in doc/comment (`#2831 <https://github.com/ros2/rclcpp/issues/2831>`_)
+* subordinate node consistent behavior and update docstring. (`#2822 <https://github.com/ros2/rclcpp/issues/2822>`_)
+* Contributors: Alejandro Hernández Cordero, Alex Youngs, Christophe Bedard, Michael Carlstrom, Michael Orlov, Tomoya Fujita
+
+29.6.0 (2025-04-25)
 -------------------
-* Removed warning test_qos (`#2859 <https://github.com/ros2/rclcpp/issues/2859>`_) (`#2873 <https://github.com/ros2/rclcpp/issues/2873>`_)
-* Fix for memory leaks in rclcpp::SerializedMessage (`#2861 <https://github.com/ros2/rclcpp/issues/2861>`_) (`#2863 <https://github.com/ros2/rclcpp/issues/2863>`_)
-* get_all_data_impl() does not handle null pointers properly, causing segmentation fault (backport `#2840 <https://github.com/ros2/rclcpp/issues/2840>`_) (`#2850 <https://github.com/ros2/rclcpp/issues/2850>`_)
-* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_) (`#2855 <https://github.com/ros2/rclcpp/issues/2855>`_)
-* QoSInitialization::from_rmw does not validate invalid history policy values, leading to silent failures (`#2841 <https://github.com/ros2/rclcpp/issues/2841>`_) (`#2846 <https://github.com/ros2/rclcpp/issues/2846>`_)
-* Add missing 's' to 'NodeParametersInterface' in doc/comment (`#2831 <https://github.com/ros2/rclcpp/issues/2831>`_) (`#2833 <https://github.com/ros2/rclcpp/issues/2833>`_)
-* subordinate node consistent behavior and update docstring. (`#2822 <https://github.com/ros2/rclcpp/issues/2822>`_) (`#2830 <https://github.com/ros2/rclcpp/issues/2830>`_)
 * throws std::invalid_argument if ParameterEvent is NULL. (`#2814 <https://github.com/ros2/rclcpp/issues/2814>`_)
 * Removed clang warnings (`#2823 <https://github.com/ros2/rclcpp/issues/2823>`_)
-* Contributors: Alejandro Hernández Cordero, Tomoya Fujita, mergify[bot]
+* Contributors: Alejandro Hernández Cordero, Tomoya Fujita
 
 29.5.0 (2025-04-18)
 -------------------

rclcpp/CMakeLists.txt

@@ -70,7 +70,6 @@ set(${PROJECT_NAME}_SRCS
   src/rclcpp/executors/executor_notify_waitable.cpp
   src/rclcpp/executors/multi_threaded_executor.cpp
   src/rclcpp/executors/single_threaded_executor.cpp
-  src/rclcpp/executors/static_single_threaded_executor.cpp
   src/rclcpp/expand_topic_or_service_name.cpp
   src/rclcpp/experimental/executors/events_executor/events_executor.cpp
   src/rclcpp/experimental/timers_manager.cpp
@@ -147,27 +146,6 @@ set(Python3_FIND_UNVERSIONED_NAMES FIRST)
 
 find_package(Python3 REQUIRED COMPONENTS Interpreter)
 
-# "watch" template for changes
-configure_file(
-  "resource/logging.hpp.em"
-  "logging.hpp.em.watch"
-  COPYONLY
-)
-# generate header with logging macros
-set(python_code_logging
-  "import em"
-  "em.invoke(['-o', 'include/rclcpp/logging.hpp', '${CMAKE_CURRENT_SOURCE_DIR}/resource/logging.hpp.em'])")
-string(REPLACE ";" "$<SEMICOLON>" python_code_logging "${python_code_logging}")
-add_custom_command(OUTPUT include/rclcpp/logging.hpp
-  COMMAND ${CMAKE_COMMAND} -E make_directory "include/rclcpp"
-  COMMAND Python3::Interpreter ARGS -c "${python_code_logging}"
-  DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/logging.hpp.em.watch"
-  COMMENT "Expanding logging.hpp.em"
-  VERBATIM
-)
-list(APPEND ${PROJECT_NAME}_SRCS
-  include/rclcpp/logging.hpp)
-
 file(GLOB interface_files "include/rclcpp/node_interfaces/node_*_interface.hpp")
 foreach(interface_file ${interface_files})
   get_filename_component(interface_name ${interface_file} NAME_WE)

rclcpp/Doxyfile

@@ -21,6 +21,22 @@ GENERATE_LATEX         = NO
 ENABLE_PREPROCESSING   = YES
 MACRO_EXPANSION        = YES
 EXPAND_ONLY_PREDEF     = YES
+EXCLUDE_SYMBOLS        += RCLCPP_STATIC_ASSERT_LOGGER
+EXCLUDE_SYMBOLS        += RCLCPP_LOG
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_ONCE
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_EXPRESSION
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_FUNCTION
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_SKIPFIRST
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_TIME_POINT_FUNC
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_THROTTLE
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_SKIPFIRST_THROTTLE
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_ONCE
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_EXPRESSION
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_FUNCTION
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_SKIPFIRST
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_THROTTLE
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
 PREDEFINED             += DOXYGEN_ONLY
 PREDEFINED             += RCLCPP_LOCAL=
 PREDEFINED             += RCLCPP_PUBLIC=

rclcpp/include/rclcpp/clock.hpp

@@ -200,21 +200,6 @@ public:
   bool
   ros_time_is_active();
 
-  /**
-   * Deprecated. This API is broken, as there is no way to get a deep
-   * copy of a clock. Therefore one can experience spurious wakeups triggered
-   * by some other instance of a clock.
-   *
-   * Cancels an ongoing or future sleep operation of one thread.
-   *
-   * This function can be used by one thread, to wakeup another thread that is
-   * blocked using any of the sleep_ or wait_ methods of this class.
-   */
-  [[deprecated("Use ClockConditionalVariable")]]
-  RCLCPP_PUBLIC
-  void
-  cancel_sleep_or_wait();
-
   /// Return the rcl_clock_t clock handle
   RCLCPP_PUBLIC
   rcl_clock_t *

rclcpp/include/rclcpp/context.hpp

@@ -381,10 +381,10 @@ private:
   std::recursive_mutex sub_contexts_mutex_;
 
   std::vector<std::shared_ptr<OnShutdownCallback>> on_shutdown_callbacks_;
-  mutable std::mutex on_shutdown_callbacks_mutex_;
+  mutable std::recursive_mutex on_shutdown_callbacks_mutex_;
 
   std::vector<std::shared_ptr<PreShutdownCallback>> pre_shutdown_callbacks_;
-  mutable std::mutex pre_shutdown_callbacks_mutex_;
+  mutable std::recursive_mutex pre_shutdown_callbacks_mutex_;
 
   /// Condition variable for timed sleep (see sleep_for).
   std::condition_variable interrupt_condition_variable_;

rclcpp/include/rclcpp/executor.hpp

@@ -371,6 +371,9 @@ public:
    *   If the time spent inside the blocking loop exceeds this timeout, return a TIMEOUT return
    *   code.
    * \return The return code, one of `SUCCESS`, `INTERRUPTED`, or `TIMEOUT`.
+   * \note This method will check the future and the timeout only when the executor is woken up.
+   *   If this future is unrelated to an executor's entity, this method will not correctly detect
+   *   when it's completed and therefore may wait forever and never time out.
    */
   template<typename FutureT, typename TimeRepT = int64_t, typename TimeT = std::milli>
   FutureReturnCode

rclcpp/include/rclcpp/executors.hpp

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

rclcpp/include/rclcpp/executors/static_single_threaded_executor.hpp

@@ -1,145 +0,0 @@
-// Copyright 2019 Nobleo Technology
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef RCLCPP__EXECUTORS__STATIC_SINGLE_THREADED_EXECUTOR_HPP_
-#define RCLCPP__EXECUTORS__STATIC_SINGLE_THREADED_EXECUTOR_HPP_
-
-#include <atomic>
-#include <chrono>
-#include <memory>
-
-#include "rclcpp/executor.hpp"
-#include "rclcpp/executors/executor_entities_collection.hpp"
-#include "rclcpp/executors/single_threaded_executor.hpp"
-
-namespace rclcpp
-{
-namespace executors
-{
-
-/// Static executor implementation
-/**
- * This executor is a static version of the original single threaded executor.
- * It contains some performance optimization to avoid unnecessary reconstructions of
- * the executable list for every iteration.
- * All nodes, callbackgroups, timers, subscriptions etc. are created before
- * spin() is called, and modified only when an entity is added/removed to/from a node.
- * This executor is deprecated because these performance improvements have now been
- * applied to all other executors.
- * This executor is also considered unstable due to known bugs.
- * See the unit-tests that are only applied to `StandardExecutors` for information
- * on the known limitations.
- *
- * To run this executor instead of SingleThreadedExecutor replace:
- * rclcpp::executors::SingleThreadedExecutor exec;
- * by
- * rclcpp::executors::StaticSingleThreadedExecutor exec;
- * in your source code and spin node(s) in the following way:
- * exec.add_node(node);
- * exec.spin();
- * exec.remove_node(node);
- */
-class [[deprecated("Use rclcpp::executors::SingleThreadedExecutor")]] StaticSingleThreadedExecutor
-  : public rclcpp::Executor
-{
-public:
-  RCLCPP_SMART_PTR_DEFINITIONS(StaticSingleThreadedExecutor)
-
-  /// Default constructor. See the default constructor for Executor.
-  RCLCPP_PUBLIC
-  explicit StaticSingleThreadedExecutor(
-    const rclcpp::ExecutorOptions & options = rclcpp::ExecutorOptions());
-
-  /// Default destructor.
-  RCLCPP_PUBLIC
-  virtual ~StaticSingleThreadedExecutor();
-
-  /// Static executor implementation of spin.
-  /**
-   * This function will block until work comes in, execute it, and keep blocking.
-   * It will only be interrupted by a CTRL-C (managed by the global signal handler).
-   * \throws std::runtime_error when spin() called while already spinning
-   */
-  RCLCPP_PUBLIC
-  void
-  spin() override;
-
-  /// Static executor implementation of spin some
-  /**
-   * This non-blocking function will execute entities that
-   * were ready when this API was called, until timeout or no
-   * more work available. Entities that got ready while
-   * executing work, won't be taken into account here.
-   *
-   * Example:
-   *   while(condition) {
-   *     spin_some();
-   *     sleep(); // User should have some sync work or
-   *              // sleep to avoid a 100% CPU usage
-   *   }
-   */
-  RCLCPP_PUBLIC
-  void
-  spin_some(std::chrono::nanoseconds max_duration = std::chrono::nanoseconds(0)) override;
-
-  /// Static executor implementation of spin all
-  /**
-   * This non-blocking function will execute entities until timeout (must be >= 0)
-   * or no more work available.
-   * If timeout is `0`, potentially it blocks forever until no more work is available.
-   * If new entities get ready while executing work available, they will be executed
-   * as long as the timeout hasn't expired.
-   *
-   * Example:
-   *   while(condition) {
-   *     spin_all();
-   *     sleep(); // User should have some sync work or
-   *              // sleep to avoid a 100% CPU usage
-   *   }
-   */
-  RCLCPP_PUBLIC
-  void
-  spin_all(std::chrono::nanoseconds max_duration) override;
-
-protected:
-  /**
-   * @brief Executes ready executables from wait set.
-   * @param collection entities to evaluate for ready executables.
-   * @param wait_result result to check for ready executables.
-   * @param spin_once if true executes only the first ready executable.
-   * @return true if any executable was ready.
-   */
-  bool
-  execute_ready_executables(
-    const rclcpp::executors::ExecutorEntitiesCollection & collection,
-    rclcpp::WaitResult<rclcpp::WaitSet> & wait_result,
-    bool spin_once);
-
-  void
-  spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive);
-
-  void
-  spin_once_impl(std::chrono::nanoseconds timeout) override;
-
-  std::optional<rclcpp::WaitResult<rclcpp::WaitSet>>
-  collect_and_wait(std::chrono::nanoseconds timeout);
-
-private:
-  RCLCPP_DISABLE_COPY(StaticSingleThreadedExecutor)
-};
-
-}  // namespace executors
-}  // namespace rclcpp
-
-#endif  // RCLCPP__EXECUTORS__STATIC_SINGLE_THREADED_EXECUTOR_HPP_

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

@@ -178,6 +178,8 @@ public:
   void clear() override
   {
     TRACETOOLS_TRACEPOINT(rclcpp_ring_buffer_clear, static_cast<const void *>(this));
+    std::lock_guard<std::mutex> lock(mutex_);
+    clear_();
   }
 
 private:
@@ -227,6 +229,14 @@ private:
     return capacity_ - size_;
   }
 
+  inline void clear_()
+  {
+    ring_buffer_.clear();
+    size_ = 0;
+    read_index_ = 0;
+    write_index_ = capacity_ - 1;
+  }
+
   /// Traits for checking if a type is std::unique_ptr
   template<typename ...>
   struct is_std_unique_ptr final : std::false_type {};
@@ -296,7 +306,7 @@ private:
     return {};
   }
 
-  size_t capacity_;
+  const size_t capacity_;
 
   std::vector<BufferT> ring_buffer_;
 

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

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

rclcpp/include/rclcpp/logger.hpp

@@ -78,34 +78,6 @@ RCLCPP_PUBLIC
 Logger
 get_node_logger(const rcl_node_t * node);
 
-// TODO(ahcorde): Remove deprecated class on the next release (in Rolling after Kilted).
-#if !defined(_WIN32)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#else  // !defined(_WIN32)
-# pragma warning(push)
-# pragma warning(disable: 4996)
-#endif
-/// Get the current logging directory.
-/**
- * For more details of how the logging directory is determined,
- * see rcl_logging_get_logging_directory().
- *
- * \returns the logging directory being used.
- * \throws rclcpp::exceptions::RCLError if an unexpected error occurs.
- */
-[[deprecated("use rclcpp::get_log_directory instead of rclcpp::get_logging_directory")]]
-RCLCPP_PUBLIC
-rcpputils::fs::path
-get_logging_directory();
-
-// remove warning suppression
-#if !defined(_WIN32)
-# pragma GCC diagnostic pop
-#else  // !defined(_WIN32)
-# pragma warning(pop)
-#endif
-
 /// Get the current logging directory.
 /**
  * For more details of how the logging directory is determined,

rclcpp/include/rclcpp/logging.hpp

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

rclcpp/include/rclcpp/node_interfaces/node_base.hpp

@@ -121,11 +121,6 @@ public:
   std::atomic_bool &
   get_associated_with_executor_atomic() override;
 
-  [[deprecated("Use get_shared_notify_guard_condition or trigger_notify_guard_condition instead")]]
-  RCLCPP_PUBLIC
-  rclcpp::GuardCondition &
-  get_notify_guard_condition() override;
-
   RCLCPP_PUBLIC
   rclcpp::GuardCondition::SharedPtr
   get_shared_notify_guard_condition() override;

rclcpp/include/rclcpp/node_interfaces/node_base_interface.hpp

@@ -144,17 +144,6 @@ public:
   std::atomic_bool &
   get_associated_with_executor_atomic() = 0;
 
-  /// Return a guard condition that should be notified when the internal node state changes.
-  /**
-   * For example, this should be notified when a publisher is added or removed.
-   *
-   * \return the GuardCondition if it is valid, else throw runtime error
-   */
-  RCLCPP_PUBLIC
-  virtual
-  rclcpp::GuardCondition &
-  get_notify_guard_condition() = 0;
-
   /// Return a guard condition that should be notified when the internal node state changes.
   /**
    * For example, this should be notified when a publisher is added or removed.

rclcpp/include/rclcpp/rclcpp.hpp

@@ -68,8 +68,6 @@
  *
  * - Executors (responsible for execution of callbacks through a blocking spin):
  *   - rclcpp::spin()
- *   - rclcpp::spin_some()
- *   - rclcpp::spin_until_future_complete()
  *   - rclcpp::executors::SingleThreadedExecutor
  *   - rclcpp::executors::SingleThreadedExecutor::add_node()
  *   - rclcpp::executors::SingleThreadedExecutor::spin()

rclcpp/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format2.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="2">
   <name>rclcpp</name>
-  <version>29.5.3</version>
+  <version>30.1.1</version>
   <description>The ROS client library in C++.</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
@@ -17,6 +17,7 @@
   <buildtool_depend>ament_cmake_ros</buildtool_depend>
   <buildtool_depend>ament_cmake_gen_version_h</buildtool_depend>
   <buildtool_depend>python3</buildtool_depend>
+  <buildtool_depend>python3-empy</buildtool_depend>
 
   <build_depend>ament_index_cpp</build_depend>
   <build_depend>builtin_interfaces</build_depend>

rclcpp/resource/logging.hpp.em

@@ -1,164 +0,0 @@
-// generated from rclcpp/resource/logging.hpp.em
-
-// Copyright 2017 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef RCLCPP__LOGGING_HPP_
-#define RCLCPP__LOGGING_HPP_
-
-#include <sstream>
-#include <type_traits>
-
-#include "rclcpp/logger.hpp"
-#include "rcutils/logging_macros.h"
-#include "rclcpp/utilities.hpp"
-
-// These are used for compiling out logging macros lower than a minimum severity.
-#define RCLCPP_LOG_MIN_SEVERITY_DEBUG 0
-#define RCLCPP_LOG_MIN_SEVERITY_INFO 1
-#define RCLCPP_LOG_MIN_SEVERITY_WARN 2
-#define RCLCPP_LOG_MIN_SEVERITY_ERROR 3
-#define RCLCPP_LOG_MIN_SEVERITY_FATAL 4
-#define RCLCPP_LOG_MIN_SEVERITY_NONE 5
-
-#define RCLCPP_FIRST_ARG(N, ...) N
-#define RCLCPP_ALL_BUT_FIRST_ARGS(N, ...) __VA_ARGS__
-
-/**
- * \def RCLCPP_LOG_MIN_SEVERITY
- * Define RCLCPP_LOG_MIN_SEVERITY=RCLCPP_LOG_MIN_SEVERITY_[DEBUG|INFO|WARN|ERROR|FATAL]
- * in your build options to compile out anything below that severity.
- * Use RCLCPP_LOG_MIN_SEVERITY_NONE to compile out all macros.
- */
-#ifndef RCLCPP_LOG_MIN_SEVERITY
-#define RCLCPP_LOG_MIN_SEVERITY RCLCPP_LOG_MIN_SEVERITY_DEBUG
-#endif
-
-@{
-from collections import OrderedDict
-from copy import deepcopy
-from rcutils.logging import feature_combinations
-from rcutils.logging import get_suffix_from_features
-from rcutils.logging import severities
-from rcutils.logging import throttle_args
-from rcutils.logging import throttle_params
-
-throttle_args['condition_before'] = 'RCUTILS_LOG_CONDITION_THROTTLE_BEFORE(clock, duration)'
-del throttle_params['get_time_point_value']
-throttle_params['clock'] = 'rclcpp::Clock that will be used to get the time point.'
-throttle_params.move_to_end('clock', last=False)
-
-rclcpp_feature_combinations = OrderedDict()
-for combinations, feature in feature_combinations.items():
-    # skip feature combinations using 'named'
-    if 'named' in combinations:
-        continue
-    rclcpp_feature_combinations[combinations] = feature
-# add a stream variant for each available feature combination
-stream_arg = 'stream_arg'
-for combinations, feature in list(rclcpp_feature_combinations.items()):
-    combinations = ('stream', ) + combinations
-    feature = deepcopy(feature)
-    feature.params[stream_arg] = 'The argument << into a stringstream'
-    rclcpp_feature_combinations[combinations] = feature
-
-def get_rclcpp_suffix_from_features(features):
-    suffix = get_suffix_from_features(features)
-    if 'stream' in features:
-        suffix = '_STREAM' + suffix
-    return suffix
-}@
-@[for severity in severities]@
-/** @@name Logging macros for severity @(severity).
- */
-///@@{
-#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_@(severity))
-// empty logging macros for severity @(severity) when being disabled at compile time
-@[ for feature_combination in rclcpp_feature_combinations.keys()]@
-@{suffix = get_rclcpp_suffix_from_features(feature_combination)}@
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_@(severity)@(suffix)(...)
-@[ end for]@
-
-#else
-@[ for feature_combination in rclcpp_feature_combinations.keys()]@
-@{suffix = get_rclcpp_suffix_from_features(feature_combination)}@
-// The RCLCPP_@(severity)@(suffix) macro is surrounded by do { .. } while (0)
-// to implement the standard C macro idiom to make the macro safe in all
-// contexts; see http://c-faq.com/cpp/multistmt.html for more information.
-/**
- * \def RCLCPP_@(severity)@(suffix)
- * Log a message with severity @(severity)@
-@[ if rclcpp_feature_combinations[feature_combination].doc_lines]@
- with the following conditions:
-@[ else]@
-.
-@[ end if]@
-@[ for doc_line in rclcpp_feature_combinations[feature_combination].doc_lines]@
- * @(doc_line)
-@[ end for]@
- * \param logger The `rclcpp::Logger` to use
-@[ for param_name, doc_line in rclcpp_feature_combinations[feature_combination].params.items()]@
- * \param @(param_name) @(doc_line)
-@[ end for]@
-@[ if 'stream' not in feature_combination]@
- * \param ... The format string, followed by the variable arguments for the format string.
-@[ end if]@
- */
-@{params = rclcpp_feature_combinations[feature_combination].params.keys()}@
-#define RCLCPP_@(severity)@(suffix)(logger@(''.join([', ' + p for p in params]))@
-@[ if 'stream' not in feature_combination]@
-, ...@
-@[ end if]@
-) \
-  do { \
-    static_assert( \
-      ::std::is_convertible_v<decltype(logger), ::rclcpp::Logger>, \
-      "First argument to logging macros must be an rclcpp::Logger"); \
-@[ if 'throttle' in feature_combination]@ \
-    auto get_time_point = [&c=clock](rcutils_time_point_value_t * time_point) -> rcutils_ret_t { \
-      try { \
-        *time_point = c.now().nanoseconds(); \
-      } catch (...) { \
-        RCUTILS_SAFE_FWRITE_TO_STDERR( \
-        "[rclcpp|logging.hpp] RCLCPP_@(severity)@(suffix) could not get current time stamp\n"); \
-        return RCUTILS_RET_ERROR; \
-      } \
-        return RCUTILS_RET_OK; \
-    }; \
-@[ end if] \
-@[ if 'stream' in feature_combination]@
-    std::stringstream rclcpp_stream_ss_; \
-    rclcpp_stream_ss_ << @(stream_arg); \
-@[ end if]@
-    RCUTILS_LOG_@(severity)@(get_suffix_from_features(feature_combination))_NAMED( \
-@{params = ['get_time_point' if p == 'clock' and 'throttle' in feature_combination else p for p in params]}@
-@[ if params]@
-@(''.join(['      ' + p + ', \\\n' for p in params if p != stream_arg]))@
-@[ end if]@
-      (logger).get_name(), \
-@[ if 'stream' not in feature_combination]@
-      __VA_ARGS__); \
-@[ else]@
-      "%s", rclcpp_stream_ss_.str().c_str()); \
-@[ end if]@
-  } while (0)
-
-@[ end for]@
-#endif
-///@@}
-
-@[end for]@
-
-#endif  // RCLCPP__LOGGING_HPP_

rclcpp/src/rclcpp/clock.cpp

@@ -83,16 +83,6 @@ Clock::now() const
   return now;
 }
 
-void
-Clock::cancel_sleep_or_wait()
-{
-  {
-    std::unique_lock lock(impl_->wait_mutex_);
-    impl_->stop_sleeping_ = true;
-  }
-  impl_->cv_.notify_one();
-}
-
 bool
 Clock::sleep_until(
   Time until,

rclcpp/src/rclcpp/context.cpp

@@ -14,7 +14,6 @@
 
 #include "rclcpp/context.hpp"
 
-#include <map>
 #include <memory>
 #include <mutex>
 #include <sstream>
@@ -143,52 +142,11 @@ rclcpp_logging_output_handler(
 }
 }  // extern "C"
 
-/**
- * Global storage for pre and post shutdown recursive mutexes.
- * Note, this is a ABI compatibility hack.
- */
-class MutexLookup
-{
-  std::mutex m;
-
-  struct MutexHolder
-  {
-    std::recursive_mutex on_shutdown_callbacks_mutex_;
-    std::recursive_mutex pre_shutdown_callbacks_mutex_;
-  };
-
-  std::map<const Context *, std::unique_ptr<MutexHolder>> mutexMap;
-
-public:
-  MutexHolder & getMutexes(const Context *forContext)
-  {
-    auto it = mutexMap.find(forContext);
-    if(it == mutexMap.end()) {
-      it = mutexMap.emplace(forContext, std::make_unique<MutexHolder>()).first;
-    }
-
-    return *(it->second);
-  }
-
-  /**
-   * Only supposed to be called on deletion of context
-   */
-  void removeMutexes(const Context *forContext)
-  {
-    mutexMap.erase(forContext);
-  }
-};
-
-MutexLookup mutexStorage;
-
 Context::Context()
 : rcl_context_(nullptr),
   shutdown_reason_(""),
   logging_mutex_(nullptr)
-{
-  // allocate mutexes
-  mutexStorage.getMutexes(this);
-}
+{}
 
 Context::~Context()
 {
@@ -207,9 +165,6 @@ Context::~Context()
   } catch (...) {
     RCLCPP_ERROR(rclcpp::get_logger("rclcpp"), "unhandled exception in ~Context()");
   }
-
-  // delete mutexes
-  mutexStorage.removeMutexes(this);
 }
 
 RCLCPP_LOCAL
@@ -355,8 +310,7 @@ Context::shutdown(const std::string & reason)
 
   // call each pre-shutdown callback
   {
-    std::lock_guard<std::recursive_mutex> lock{mutexStorage.getMutexes(
-        this).pre_shutdown_callbacks_mutex_};
+    std::lock_guard<std::recursive_mutex> lock{pre_shutdown_callbacks_mutex_};
     // callbacks may delete other callbacks during the execution,
     // therefore we need to save a copy and check before execution
     // if the next callback is still present
@@ -378,8 +332,7 @@ Context::shutdown(const std::string & reason)
   shutdown_reason_ = reason;
   // call each shutdown callback
   {
-    std::lock_guard<std::recursive_mutex> lock(mutexStorage.getMutexes(
-      this).on_shutdown_callbacks_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(on_shutdown_callbacks_mutex_);
     // callbacks may delete other callbacks during the execution,
     // therefore we need to save a copy and check before execution
     // if the next callback is still present
@@ -459,12 +412,10 @@ Context::add_shutdown_callback(
     shutdown_type == ShutdownType::pre_shutdown || shutdown_type == ShutdownType::on_shutdown);
 
   if constexpr (shutdown_type == ShutdownType::pre_shutdown) {
-    std::lock_guard<std::recursive_mutex> lock(mutexStorage.getMutexes(
-      this).pre_shutdown_callbacks_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(pre_shutdown_callbacks_mutex_);
     pre_shutdown_callbacks_.emplace_back(callback_shared_ptr);
   } else {
-    std::lock_guard<std::recursive_mutex> lock(mutexStorage.getMutexes(
-      this).on_shutdown_callbacks_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(on_shutdown_callbacks_mutex_);
     on_shutdown_callbacks_.emplace_back(callback_shared_ptr);
   }
 
@@ -495,7 +446,6 @@ Context::remove_shutdown_callback(
         return false;
       }
       callback_vector.erase(iter);
-
       return true;
     };
 
@@ -503,11 +453,9 @@ Context::remove_shutdown_callback(
     shutdown_type == ShutdownType::pre_shutdown || shutdown_type == ShutdownType::on_shutdown);
 
   if constexpr (shutdown_type == ShutdownType::pre_shutdown) {
-    return remove_callback(mutexStorage.getMutexes(this).pre_shutdown_callbacks_mutex_,
-      pre_shutdown_callbacks_);
+    return remove_callback(pre_shutdown_callbacks_mutex_, pre_shutdown_callbacks_);
   } else {
-    return remove_callback(mutexStorage.getMutexes(this).on_shutdown_callbacks_mutex_,
-      on_shutdown_callbacks_);
+    return remove_callback(on_shutdown_callbacks_mutex_, on_shutdown_callbacks_);
   }
 }
 
@@ -540,11 +488,9 @@ Context::get_shutdown_callback() const
     shutdown_type == ShutdownType::pre_shutdown || shutdown_type == ShutdownType::on_shutdown);
 
   if constexpr (shutdown_type == ShutdownType::pre_shutdown) {
-    return get_callback_vector(mutexStorage.getMutexes(this).pre_shutdown_callbacks_mutex_,
-      pre_shutdown_callbacks_);
+    return get_callback_vector(pre_shutdown_callbacks_mutex_, pre_shutdown_callbacks_);
   } else {
-    return get_callback_vector(mutexStorage.getMutexes(this).on_shutdown_callbacks_mutex_,
-      on_shutdown_callbacks_);
+    return get_callback_vector(on_shutdown_callbacks_mutex_, on_shutdown_callbacks_);
   }
 }
 

rclcpp/src/rclcpp/executor.cpp

@@ -18,6 +18,7 @@
 #include <iterator>
 #include <memory>
 #include <map>
+#include <stdexcept>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -52,6 +53,7 @@ class rclcpp::ExecutorImplementation {};
 
 Executor::Executor(const std::shared_ptr<rclcpp::Context> & context)
 : spinning(false),
+  context_(context),
   entities_need_rebuild_(true),
   collector_(nullptr),
   wait_set_({}, {}, {}, {}, {}, {}, context)
@@ -186,6 +188,11 @@ Executor::add_callback_group(
 void
 Executor::add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify)
 {
+  if (node_ptr->get_context() != context_) {
+    throw std::runtime_error(
+      "add_node() called with a node with a different context from this executor");
+  }
+
   this->collector_.add_node(node_ptr);
 
   try {

rclcpp/src/rclcpp/executors.cpp

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "rclcpp/executors.hpp"
+#include "rcpputils/compile_warnings.hpp"
 
 void
 rclcpp::spin_all(
@@ -25,12 +26,6 @@ rclcpp::spin_all(
   exec.spin_node_all(node_ptr, max_duration);
 }
 
-void
-rclcpp::spin_all(rclcpp::Node::SharedPtr node_ptr, std::chrono::nanoseconds max_duration)
-{
-  rclcpp::spin_all(node_ptr->get_node_base_interface(), max_duration);
-}
-
 void
 rclcpp::spin_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
 {
@@ -40,12 +35,6 @@ rclcpp::spin_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr
   exec.spin_node_some(node_ptr);
 }
 
-void
-rclcpp::spin_some(rclcpp::Node::SharedPtr node_ptr)
-{
-  rclcpp::spin_some(node_ptr->get_node_base_interface());
-}
-
 void
 rclcpp::spin(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
 {
@@ -62,3 +51,19 @@ rclcpp::spin(rclcpp::Node::SharedPtr node_ptr)
 {
   rclcpp::spin(node_ptr->get_node_base_interface());
 }
+
+void
+rclcpp::spin_all(rclcpp::Node::SharedPtr node_ptr, std::chrono::nanoseconds max_duration)
+{
+  RCPPUTILS_DEPRECATION_WARNING_OFF_START
+  rclcpp::spin_all(node_ptr->get_node_base_interface(), max_duration);
+  RCPPUTILS_DEPRECATION_WARNING_OFF_STOP
+}
+
+void
+rclcpp::spin_some(rclcpp::Node::SharedPtr node_ptr)
+{
+  RCPPUTILS_DEPRECATION_WARNING_OFF_START
+  rclcpp::spin_some(node_ptr->get_node_base_interface());
+  RCPPUTILS_DEPRECATION_WARNING_OFF_STOP
+}

rclcpp/src/rclcpp/executors/static_single_threaded_executor.cpp

@@ -1,223 +0,0 @@
-// Copyright 2019 Nobleo Technology
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "rclcpp/executors/executor_entities_collection.hpp"
-#include "rcpputils/scope_exit.hpp"
-
-#include "rclcpp/executors/static_single_threaded_executor.hpp"
-#include "rclcpp/any_executable.hpp"
-
-using rclcpp::executors::StaticSingleThreadedExecutor;
-
-StaticSingleThreadedExecutor::StaticSingleThreadedExecutor(const rclcpp::ExecutorOptions & options)
-: rclcpp::Executor(options)
-{
-}
-
-StaticSingleThreadedExecutor::~StaticSingleThreadedExecutor() {}
-
-void
-StaticSingleThreadedExecutor::spin()
-{
-  if (spinning.exchange(true)) {
-    throw std::runtime_error("spin() called while already spinning");
-  }
-  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false); );
-
-  // This is essentially the contents of the rclcpp::Executor::wait_for_work method,
-  // except we need to keep the wait result to reproduce the StaticSingleThreadedExecutor
-  // behavior.
-  while (rclcpp::ok(this->context_) && spinning.load()) {
-    this->spin_once_impl(std::chrono::nanoseconds(-1));
-  }
-}
-
-void
-StaticSingleThreadedExecutor::spin_some(std::chrono::nanoseconds max_duration)
-{
-  // In this context a 0 input max_duration means no duration limit
-  if (std::chrono::nanoseconds(0) == max_duration) {
-    max_duration = std::chrono::nanoseconds::max();
-  }
-  return this->spin_some_impl(max_duration, false);
-}
-
-void
-StaticSingleThreadedExecutor::spin_all(std::chrono::nanoseconds max_duration)
-{
-  if (max_duration < std::chrono::nanoseconds(0)) {
-    throw std::invalid_argument("max_duration must be greater than or equal to 0");
-  }
-  return this->spin_some_impl(max_duration, true);
-}
-
-void
-StaticSingleThreadedExecutor::spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive)
-{
-  auto start = std::chrono::steady_clock::now();
-  auto max_duration_not_elapsed = [max_duration, start]() {
-      const auto spin_forever = std::chrono::nanoseconds(0) == max_duration;
-      const auto cur_duration = std::chrono::steady_clock::now() - start;
-      return spin_forever || (cur_duration < max_duration);
-    };
-
-  if (spinning.exchange(true)) {
-    throw std::runtime_error("spin_some() called while already spinning");
-  }
-  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false););
-
-  while (rclcpp::ok(context_) && spinning.load() && max_duration_not_elapsed()) {
-    // Get executables that are ready now
-    std::lock_guard<std::mutex> guard(mutex_);
-
-    auto wait_result = this->collect_and_wait(std::chrono::nanoseconds(0));
-    if (wait_result.has_value()) {
-      // Execute ready executables
-      bool work_available = this->execute_ready_executables(
-        current_collection_,
-        wait_result.value(),
-        false);
-      if (!work_available || !exhaustive) {
-        break;
-      }
-    }
-  }
-}
-
-void
-StaticSingleThreadedExecutor::spin_once_impl(std::chrono::nanoseconds timeout)
-{
-  if (rclcpp::ok(context_) && spinning.load()) {
-    std::lock_guard<std::mutex> guard(mutex_);
-    auto wait_result = this->collect_and_wait(timeout);
-    if (wait_result.has_value()) {
-      this->execute_ready_executables(current_collection_, wait_result.value(), true);
-    }
-  }
-}
-
-std::optional<rclcpp::WaitResult<rclcpp::WaitSet>>
-StaticSingleThreadedExecutor::collect_and_wait(std::chrono::nanoseconds timeout)
-{
-  // we need to make sure that callback groups don't get out of scope
-  // during the wait. As in jazzy, they are not covered by the DynamicStorage,
-  // we explicitly hold them here as a bugfix
-  std::vector<rclcpp::CallbackGroup::SharedPtr> cbgs;
-
-  if (this->entities_need_rebuild_.exchange(false) || current_collection_.empty()) {
-    this->collect_entities();
-  }
-
-  auto callback_groups = this->collector_.get_all_callback_groups();
-  cbgs.resize(callback_groups.size());
-  for(const auto & w_ptr : callback_groups) {
-    auto shr_ptr = w_ptr.lock();
-    if(shr_ptr) {
-      cbgs.push_back(std::move(shr_ptr));
-    }
-  }
-
-  auto wait_result = wait_set_.wait(std::chrono::nanoseconds(timeout));
-
-  // drop references to the callback groups, before trying to execute anything
-  cbgs.clear();
-
-  if (wait_result.kind() == WaitResultKind::Empty) {
-    RCUTILS_LOG_WARN_NAMED(
-      "rclcpp",
-      "empty wait set received in wait(). This should never happen.");
-    return {};
-  } else {
-    if (wait_result.kind() == WaitResultKind::Ready && current_notify_waitable_) {
-      auto & rcl_wait_set = wait_result.get_wait_set().get_rcl_wait_set();
-      if (current_notify_waitable_->is_ready(rcl_wait_set)) {
-        current_notify_waitable_->execute(current_notify_waitable_->take_data());
-      }
-    }
-  }
-  return wait_result;
-}
-
-// This preserves the "scheduling semantics" of the StaticSingleThreadedExecutor
-// from the original implementation.
-bool StaticSingleThreadedExecutor::execute_ready_executables(
-  const rclcpp::executors::ExecutorEntitiesCollection & collection,
-  rclcpp::WaitResult<rclcpp::WaitSet> & wait_result,
-  bool spin_once)
-{
-  bool any_ready_executable = false;
-  if (wait_result.kind() != rclcpp::WaitResultKind::Ready) {
-    return any_ready_executable;
-  }
-
-  while (auto subscription = wait_result.next_ready_subscription()) {
-    auto entity_iter = collection.subscriptions.find(subscription->get_subscription_handle().get());
-    if (entity_iter != collection.subscriptions.end()) {
-      execute_subscription(subscription);
-      any_ready_executable = true;
-      if (spin_once) {return any_ready_executable;}
-    }
-  }
-
-  size_t current_timer_index = 0;
-  while (true) {
-    auto [timer, timer_index] = wait_result.peek_next_ready_timer(current_timer_index);
-    if (nullptr == timer) {
-      break;
-    }
-    current_timer_index = timer_index;
-    auto entity_iter = collection.timers.find(timer->get_timer_handle().get());
-    if (entity_iter != collection.timers.end()) {
-      wait_result.clear_timer_with_index(current_timer_index);
-      auto data = timer->call();
-      if (!data) {
-        // someone canceled the timer between is_ready and call
-        continue;
-      }
-
-      execute_timer(std::move(timer), data);
-      any_ready_executable = true;
-      if (spin_once) {return any_ready_executable;}
-    }
-  }
-
-  while (auto client = wait_result.next_ready_client()) {
-    auto entity_iter = collection.clients.find(client->get_client_handle().get());
-    if (entity_iter != collection.clients.end()) {
-      execute_client(client);
-      any_ready_executable = true;
-      if (spin_once) {return any_ready_executable;}
-    }
-  }
-
-  while (auto service = wait_result.next_ready_service()) {
-    auto entity_iter = collection.services.find(service->get_service_handle().get());
-    if (entity_iter != collection.services.end()) {
-      execute_service(service);
-      any_ready_executable = true;
-      if (spin_once) {return any_ready_executable;}
-    }
-  }
-
-  while (auto waitable = wait_result.next_ready_waitable()) {
-    auto entity_iter = collection.waitables.find(waitable.get());
-    if (entity_iter != collection.waitables.end()) {
-      const auto data = waitable->take_data();
-      waitable->execute(data);
-      any_ready_executable = true;
-      if (spin_once) {return any_ready_executable;}
-    }
-  }
-  return any_ready_executable;
-}

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

@@ -25,9 +25,9 @@ using namespace std::chrono_literals;
 using rclcpp::experimental::executors::EventsExecutor;
 
 EventsExecutor::EventsExecutor(
+  const rclcpp::ExecutorOptions & options,
   rclcpp::experimental::executors::EventsQueue::UniquePtr events_queue,
-  bool execute_timers_separate_thread,
-  const rclcpp::ExecutorOptions & options)
+  bool execute_timers_separate_thread)
 : rclcpp::Executor(options)
 {
   // Get ownership of the queue used to store events.

rclcpp/src/rclcpp/logger.cpp

@@ -55,34 +55,6 @@ get_node_logger(const rcl_node_t * node)
   return rclcpp::get_logger(logger_name);
 }
 
-// TODO(ahcorde): Remove deprecated class on the next release (in Rolling after Kilted).
-#if !defined(_WIN32)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#else  // !defined(_WIN32)
-# pragma warning(push)
-# pragma warning(disable: 4996)
-#endif
-rcpputils::fs::path
-get_logging_directory()
-{
-  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;
-}
-// remove warning suppression
-#if !defined(_WIN32)
-# pragma GCC diagnostic pop
-#else  // !defined(_WIN32)
-# pragma warning(pop)
-#endif
-
 std::filesystem::path
 get_log_directory()
 {

rclcpp/src/rclcpp/node_interfaces/node_base.cpp

@@ -275,16 +275,6 @@ NodeBase::get_associated_with_executor_atomic()
   return associated_with_executor_;
 }
 
-rclcpp::GuardCondition &
-NodeBase::get_notify_guard_condition()
-{
-  std::lock_guard<std::recursive_mutex> notify_condition_lock(notify_guard_condition_mutex_);
-  if (!notify_guard_condition_is_valid_) {
-    throw std::runtime_error("failed to get notify guard condition because it is invalid");
-  }
-  return *notify_guard_condition_;
-}
-
 rclcpp::GuardCondition::SharedPtr
 NodeBase::get_shared_notify_guard_condition()
 {

rclcpp/src/rclcpp/node_interfaces/node_graph.cpp

@@ -419,7 +419,7 @@ NodeGraph::get_node_names_and_namespaces() const
         rcl_get_error_string().str;
       rcl_reset_error();
     }
-    // TODO(karsten1987): Append rcutils_error_message once it's in master
+    RCUTILS_LOG_ERROR_NAMED("rclcpp", "%s", error_msg.c_str());
     throw std::runtime_error(error_msg);
   }
 
@@ -434,20 +434,15 @@ NodeGraph::get_node_names_and_namespaces() const
   std::string error;
   rcl_ret_t ret_names = rcutils_string_array_fini(&node_names_c);
   if (ret_names != RCUTILS_RET_OK) {
-    // *INDENT-OFF*
-    // TODO(karsten1987): Append rcutils_error_message once it's in master
-    error = "could not destroy node names";
-    // *INDENT-ON*
+    error = std::string("could not destroy node names: ") + rcl_get_error_string().str;
   }
   rcl_ret_t ret_ns = rcutils_string_array_fini(&node_namespaces_c);
   if (ret_ns != RCUTILS_RET_OK) {
-    // *INDENT-OFF*
-    // TODO(karsten1987): Append rcutils_error_message once it's in master
-    error += ", could not destroy node namespaces";
-    // *INDENT-ON*
+    error += std::string(", could not destroy node namespaces: ") + rcl_get_error_string().str;
   }
 
   if (ret_names != RCUTILS_RET_OK || ret_ns != RCUTILS_RET_OK) {
+    RCUTILS_LOG_ERROR_NAMED("rclcpp", "%s", error.c_str());
     throw std::runtime_error(error);
   }
 

rclcpp/src/rclcpp/node_interfaces/node_parameters.cpp

@@ -192,6 +192,65 @@ format_range_reason(const std::string & name, const char * range_type)
   return ss.str();
 }
 
+RCLCPP_LOCAL
+rcl_interfaces::msg::SetParametersResult
+__check_integer_range(
+  const rcl_interfaces::msg::ParameterDescriptor & descriptor,
+  const int64_t value)
+{
+  rcl_interfaces::msg::SetParametersResult result;
+  result.successful = true;
+  auto integer_range = descriptor.integer_range.at(0);
+  if (value == integer_range.from_value || value == integer_range.to_value) {
+    return result;
+  }
+  if ((value < integer_range.from_value) || (value > integer_range.to_value)) {
+    result.successful = false;
+    result.reason = format_range_reason(descriptor.name, "integer");
+    return result;
+  }
+  if (integer_range.step == 0) {
+    return result;
+  }
+  if (((value - integer_range.from_value) % integer_range.step) == 0) {
+    return result;
+  }
+  result.successful = false;
+  result.reason = format_range_reason(descriptor.name, "integer");
+  return result;
+}
+
+RCLCPP_LOCAL
+rcl_interfaces::msg::SetParametersResult
+__check_double_range(
+  const rcl_interfaces::msg::ParameterDescriptor & descriptor,
+  const double value)
+{
+  rcl_interfaces::msg::SetParametersResult result;
+  result.successful = true;
+  auto fp_range = descriptor.floating_point_range.at(0);
+  if (__are_doubles_equal(value, fp_range.from_value) || __are_doubles_equal(value,
+    fp_range.to_value))
+  {
+    return result;
+  }
+  if ((value < fp_range.from_value) || (value > fp_range.to_value)) {
+    result.successful = false;
+    result.reason = format_range_reason(descriptor.name, "floating point");
+    return result;
+  }
+  if (fp_range.step == 0.0) {
+    return result;
+  }
+  double rounded_div = std::round((value - fp_range.from_value) / fp_range.step);
+  if (__are_doubles_equal(value, fp_range.from_value + rounded_div * fp_range.step)) {
+    return result;
+  }
+  result.successful = false;
+  result.reason = format_range_reason(descriptor.name, "floating point");
+  return result;
+}
+
 RCLCPP_LOCAL
 rcl_interfaces::msg::SetParametersResult
 __check_parameter_value_in_range(
@@ -201,49 +260,39 @@ __check_parameter_value_in_range(
   rcl_interfaces::msg::SetParametersResult result;
   result.successful = true;
   if (!descriptor.integer_range.empty() && value.get_type() == rclcpp::PARAMETER_INTEGER) {
-    int64_t v = value.get<int64_t>();
-    auto integer_range = descriptor.integer_range.at(0);
-    if (v == integer_range.from_value || v == integer_range.to_value) {
-      return result;
+    result = __check_integer_range(descriptor, value.get<int64_t>());
+    return result;
+  }
+
+  if (!descriptor.integer_range.empty() && value.get_type() == rclcpp::PARAMETER_INTEGER_ARRAY) {
+    std::vector<int64_t> val_array = value.get<std::vector<int64_t>>();
+    for (const int64_t & val : val_array) {
+      result = __check_integer_range(descriptor, val);
+      if (!result.successful) {
+        return result;
+      }
     }
-    if ((v < integer_range.from_value) || (v > integer_range.to_value)) {
-      result.successful = false;
-      result.reason = format_range_reason(descriptor.name, "integer");
-      return result;
-    }
-    if (integer_range.step == 0) {
-      return result;
-    }
-    if (((v - integer_range.from_value) % integer_range.step) == 0) {
-      return result;
-    }
-    result.successful = false;
-    result.reason = format_range_reason(descriptor.name, "integer");
     return result;
   }
 
   if (!descriptor.floating_point_range.empty() && value.get_type() == rclcpp::PARAMETER_DOUBLE) {
-    double v = value.get<double>();
-    auto fp_range = descriptor.floating_point_range.at(0);
-    if (__are_doubles_equal(v, fp_range.from_value) || __are_doubles_equal(v, fp_range.to_value)) {
-      return result;
-    }
-    if ((v < fp_range.from_value) || (v > fp_range.to_value)) {
-      result.successful = false;
-      result.reason = format_range_reason(descriptor.name, "floating point");
-      return result;
-    }
-    if (fp_range.step == 0.0) {
-      return result;
-    }
-    double rounded_div = std::round((v - fp_range.from_value) / fp_range.step);
-    if (__are_doubles_equal(v, fp_range.from_value + rounded_div * fp_range.step)) {
-      return result;
-    }
-    result.successful = false;
-    result.reason = format_range_reason(descriptor.name, "floating point");
+    result = __check_double_range(descriptor, value.get<double>());
     return result;
   }
+
+  if (!descriptor.floating_point_range.empty() &&
+    value.get_type() == rclcpp::PARAMETER_DOUBLE_ARRAY)
+  {
+    std::vector<double> val_array = value.get<std::vector<double>>();
+    for (const double & val : val_array) {
+      result = __check_double_range(descriptor, val);
+      if (!result.successful) {
+        return result;
+      }
+    }
+    return result;
+  }
+
   return result;
 }
 

rclcpp/src/rclcpp/typesupport_helpers.cpp

@@ -15,6 +15,7 @@
 
 #include "rclcpp/typesupport_helpers.hpp"
 
+#include <algorithm>
 #include <functional>
 #include <memory>
 #include <sstream>
@@ -73,6 +74,21 @@ const void * get_typesupport_handle_impl(
   }
 }
 
+// Trim leading and trailing whitespace from the string.
+std::string string_trim(std::string_view str_v)
+{
+  auto begin = std::find_if_not(str_v.begin(), str_v.end(), [](unsigned char ch) {
+        return std::isspace(ch);
+  });
+  auto end = std::find_if_not(str_v.rbegin(), str_v.rend(), [](unsigned char ch) {
+        return std::isspace(ch);
+  }).base();
+  if (begin >= end) {
+    return {};
+  }
+  return std::string(begin, end);
+}
+
 }  // anonymous namespace
 
 std::tuple<std::string, std::string, std::string>
@@ -82,6 +98,7 @@ extract_type_identifier(const std::string & full_type)
   auto sep_position_back = full_type.find_last_of(type_separator);
   auto sep_position_front = full_type.find_first_of(type_separator);
   if (sep_position_back == std::string::npos ||
+    sep_position_front == 0 ||
     sep_position_back == 0 ||
     sep_position_back == full_type.length() - 1)
   {
@@ -97,7 +114,8 @@ extract_type_identifier(const std::string & full_type)
   }
   std::string type_name = full_type.substr(sep_position_back + 1);
 
-  return std::make_tuple(package_name, middle_module, type_name);
+  return std::make_tuple(
+    string_trim(package_name), string_trim(middle_module), string_trim(type_name));
 }
 
 std::string get_typesupport_library_path(

rclcpp/test/benchmark/benchmark_service.cpp

@@ -125,11 +125,13 @@ BENCHMARK_F(ServicePerformanceTest, async_send_response)(benchmark::State & stat
   auto service = node->create_service<test_msgs::srv::Empty>(empty_service_name, callback);
 
   reset_heap_counters();
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node->get_node_base_interface());
   for (auto _ : state) {
     (void)_;
     state.PauseTiming();
     // Clear executor queue
-    rclcpp::spin_some(node->get_node_base_interface());
+    executor.spin_some();
 
     auto request = std::make_shared<test_msgs::srv::Empty::Request>();
     auto future = empty_client->async_send_request(request);
@@ -137,7 +139,7 @@ BENCHMARK_F(ServicePerformanceTest, async_send_response)(benchmark::State & stat
     benchmark::DoNotOptimize(service);
     benchmark::ClobberMemory();
 
-    rclcpp::spin_until_future_complete(node->get_node_base_interface(), future);
+    executor.spin_until_future_complete(future);
   }
   if (callback_count == 0) {
     state.SkipWithError("Service callback was not called");

rclcpp/test/rclcpp/CMakeLists.txt

@@ -57,11 +57,6 @@ ament_add_test_label(test_client mimick)
 if(TARGET test_client)
   target_link_libraries(test_client ${PROJECT_NAME} mimick ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
 endif()
-ament_add_gtest(test_clock test_clock.cpp)
-ament_add_test_label(test_clock mimick)
-if(TARGET test_clock)
-  target_link_libraries(test_clock ${PROJECT_NAME} mimick ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
-endif()
 ament_add_gtest(test_clock_conditional test_clock_conditional.cpp)
 ament_add_test_label(test_clock_conditional mimick)
 if(TARGET test_clock_conditional)
@@ -534,13 +529,6 @@ if(TARGET test_executors_warmup)
   target_link_libraries(test_executors_warmup ${PROJECT_NAME} ${test_msgs_TARGETS})
 endif()
 
-ament_add_gtest(test_static_single_threaded_executor executors/test_static_single_threaded_executor.cpp
-  APPEND_LIBRARY_DIRS "${append_library_dirs}")
-ament_add_test_label(test_static_single_threaded_executor mimick)
-if(TARGET test_static_single_threaded_executor)
-  target_link_libraries(test_static_single_threaded_executor ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
-endif()
-
 ament_add_gtest(test_multi_threaded_executor executors/test_multi_threaded_executor.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_multi_threaded_executor)

rclcpp/test/rclcpp/executors/executor_types.hpp

@@ -22,40 +22,13 @@
 
 #include "rclcpp/experimental/executors/events_executor/events_executor.hpp"
 #include "rclcpp/executors/single_threaded_executor.hpp"
-#include "rclcpp/executors/static_single_threaded_executor.hpp"
 #include "rclcpp/executors/multi_threaded_executor.hpp"
 
-// suppress deprecated StaticSingleThreadedExecutor warning
-// we define an alias that explicitly indicates that this class is deprecated, while avoiding
-// polluting a lot of files the gcc pragmas
-#if !defined(_WIN32)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#else  // !defined(_WIN32)
-# pragma warning(push)
-# pragma warning(disable: 4996)
-#endif
-using DeprecatedStaticSingleThreadedExecutor = rclcpp::executors::StaticSingleThreadedExecutor;
-// remove warning suppression
-#if !defined(_WIN32)
-# pragma GCC diagnostic pop
-#else  // !defined(_WIN32)
-# pragma warning(pop)
-#endif
-
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
 using ExecutorTypes =
   ::testing::Types<
   rclcpp::executors::SingleThreadedExecutor,
   rclcpp::executors::MultiThreadedExecutor,
-  DeprecatedStaticSingleThreadedExecutor,
   rclcpp::experimental::executors::EventsExecutor>;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
 
 class ExecutorTypeNames
 {
@@ -70,16 +43,6 @@ public:
     if (std::is_same<T, rclcpp::executors::MultiThreadedExecutor>()) {
       return "MultiThreadedExecutor";
     }
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-    if (std::is_same<T, DeprecatedStaticSingleThreadedExecutor>()) {
-      return "StaticSingleThreadedExecutor";
-    }
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
 
     if (std::is_same<T, rclcpp::experimental::executors::EventsExecutor>()) {
       return "EventsExecutor";
@@ -89,8 +52,6 @@ public:
   }
 };
 
-// StaticSingleThreadedExecutor is not included in these tests for now, due to:
-// https://github.com/ros2/rclcpp/issues/1219
 using StandardExecutors =
   ::testing::Types<
   rclcpp::executors::SingleThreadedExecutor,

rclcpp/test/rclcpp/executors/test_executors.cpp

@@ -804,8 +804,10 @@ TEST(TestExecutors, testSpinUntilFutureCompleteNodePtr)
 }
 
 // Check spin functions with non default context
-TEST(TestExecutors, testSpinWithNonDefaultContext)
+TYPED_TEST(TestExecutors, testSpinWithNonDefaultContext)
 {
+  using ExecutorType = TypeParam;
+
   auto non_default_context = std::make_shared<rclcpp::Context>();
   non_default_context->init(0, nullptr);
 
@@ -813,9 +815,14 @@ TEST(TestExecutors, testSpinWithNonDefaultContext)
     auto node =
       std::make_unique<rclcpp::Node>("node", rclcpp::NodeOptions().context(non_default_context));
 
-    EXPECT_NO_THROW(rclcpp::spin_some(node->get_node_base_interface()));
+    rclcpp::ExecutorOptions options;
+    options.context = non_default_context;
+    ExecutorType executor(options);
+    EXPECT_NO_THROW(executor.add_node(node->get_node_base_interface()));
 
-    EXPECT_NO_THROW(rclcpp::spin_all(node->get_node_base_interface(), 1s));
+    EXPECT_NO_THROW(executor.spin_some());
+
+    EXPECT_NO_THROW(executor.spin_all(1s));
 
     auto check_spin_until_future_complete = [&]() {
         std::promise<bool> promise;
@@ -823,8 +830,7 @@ TEST(TestExecutors, testSpinWithNonDefaultContext)
         promise.set_value(true);
 
         auto shared_future = future.share();
-        auto ret = rclcpp::spin_until_future_complete(
-          node->get_node_base_interface(), shared_future, 1s);
+        auto ret = executor.spin_until_future_complete(shared_future, 1s);
         EXPECT_EQ(rclcpp::FutureReturnCode::SUCCESS, ret);
       };
     EXPECT_NO_THROW(check_spin_until_future_complete());

rclcpp/test/rclcpp/executors/test_executors_timer_cancel_behavior.cpp

@@ -285,20 +285,11 @@ public:
   T executor;
 };
 
-#if !defined(_WIN32)
-# ifdef __clang__
-#  pragma clang diagnostic push
-#  pragma clang diagnostic ignored "-Wdeprecated-declarations"
-# endif
-#endif
 using MainExecutorTypes =
   ::testing::Types<
   rclcpp::executors::SingleThreadedExecutor,
-  rclcpp::executors::MultiThreadedExecutor,
-  DeprecatedStaticSingleThreadedExecutor>;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
+  rclcpp::executors::MultiThreadedExecutor>;
+
 // TODO(@fujitatomoya): this test excludes EventExecutor because it does not
 // support simulation time used for this test to relax the racy condition.
 // See more details for https://github.com/ros2/rclcpp/issues/2457.

rclcpp/test/rclcpp/executors/test_static_single_threaded_executor.cpp

@@ -1,192 +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 <gtest/gtest.h>
-
-#include <chrono>
-#include <future>
-#include <memory>
-#include <stdexcept>
-
-#include "rclcpp/exceptions.hpp"
-#include "rclcpp/executors.hpp"
-#include "rclcpp/node.hpp"
-#include "rclcpp/rclcpp.hpp"
-
-#include "test_msgs/srv/empty.hpp"
-
-#include "./executor_types.hpp"
-#include "../../mocking_utils/patch.hpp"
-#include "../../utils/rclcpp_gtest_macros.hpp"
-
-using namespace std::chrono_literals;
-
-class TestStaticSingleThreadedExecutor : public ::testing::Test
-{
-public:
-  void SetUp()
-  {
-    rclcpp::init(0, nullptr);
-  }
-
-  void TearDown()
-  {
-    rclcpp::shutdown();
-  }
-};
-
-TEST_F(TestStaticSingleThreadedExecutor, add_callback_group_trigger_guard_failed) {
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-  DeprecatedStaticSingleThreadedExecutor executor;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-  auto node = std::make_shared<rclcpp::Node>("node", "ns");
-  rclcpp::CallbackGroup::SharedPtr cb_group = node->create_callback_group(
-    rclcpp::CallbackGroupType::MutuallyExclusive);
-
-  {
-    auto mock = mocking_utils::patch_and_return(
-      "lib:rclcpp", rcl_trigger_guard_condition, RCL_RET_ERROR);
-    RCLCPP_EXPECT_THROW_EQ(
-      executor.add_callback_group(cb_group, node->get_node_base_interface(), true),
-      std::runtime_error("Failed to handle entities update on callback group add: error not set"));
-  }
-}
-
-TEST_F(TestStaticSingleThreadedExecutor, add_node_trigger_guard_failed) {
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-  DeprecatedStaticSingleThreadedExecutor executor;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-  auto node = std::make_shared<rclcpp::Node>("node", "ns");
-
-  {
-    auto mock = mocking_utils::patch_and_return(
-      "lib:rclcpp", rcl_trigger_guard_condition, RCL_RET_ERROR);
-    RCLCPP_EXPECT_THROW_EQ(
-      executor.add_node(node),
-      std::runtime_error("Failed to handle entities update on node add: error not set"));
-  }
-}
-
-TEST_F(TestStaticSingleThreadedExecutor, remove_callback_group_trigger_guard_failed) {
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-  DeprecatedStaticSingleThreadedExecutor executor;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-  auto node = std::make_shared<rclcpp::Node>("node", "ns");
-  rclcpp::CallbackGroup::SharedPtr cb_group = node->create_callback_group(
-    rclcpp::CallbackGroupType::MutuallyExclusive);
-
-  executor.add_callback_group(cb_group, node->get_node_base_interface(), true);
-
-  {
-    auto mock = mocking_utils::patch_and_return(
-      "lib:rclcpp", rcl_trigger_guard_condition, RCL_RET_ERROR);
-    RCLCPP_EXPECT_THROW_EQ(
-      executor.remove_callback_group(cb_group, true),
-      std::runtime_error(
-        "Failed to handle entities update on callback group remove: error not set"));
-  }
-}
-
-TEST_F(TestStaticSingleThreadedExecutor, remove_node_failed) {
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-  DeprecatedStaticSingleThreadedExecutor executor;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-  auto node = std::make_shared<rclcpp::Node>("node", "ns");
-
-  {
-    auto mock = mocking_utils::patch_and_return(
-      "lib:rclcpp", rcl_trigger_guard_condition, RCL_RET_ERROR);
-    RCLCPP_EXPECT_THROW_EQ(
-      executor.remove_node(node, true),
-      std::runtime_error("Node '/ns/node' needs to be associated with an executor."));
-  }
-}
-
-TEST_F(TestStaticSingleThreadedExecutor, remove_node_trigger_guard_failed) {
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-  DeprecatedStaticSingleThreadedExecutor executor;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-  auto node = std::make_shared<rclcpp::Node>("node", "ns");
-
-  executor.add_node(node);
-
-  {
-    auto mock = mocking_utils::patch_and_return(
-      "lib:rclcpp", rcl_trigger_guard_condition, RCL_RET_ERROR);
-    RCLCPP_EXPECT_THROW_EQ(
-      executor.remove_node(node, true),
-      std::runtime_error("Failed to handle entities update on node remove: error not set"));
-  }
-}
-
-TEST_F(TestStaticSingleThreadedExecutor, execute_service) {
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-  DeprecatedStaticSingleThreadedExecutor executor;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-  auto node = std::make_shared<rclcpp::Node>("node", "ns");
-  executor.add_node(node);
-
-  auto service =
-    node->create_service<test_msgs::srv::Empty>(
-    "service",
-    [](
-      const test_msgs::srv::Empty::Request::SharedPtr,
-      test_msgs::srv::Empty::Response::SharedPtr) {});
-  auto client = node->create_client<test_msgs::srv::Empty>("service");
-
-  std::promise<void> promise;
-  std::future<void> future = promise.get_future();
-  EXPECT_EQ(
-    rclcpp::FutureReturnCode::TIMEOUT,
-    executor.spin_until_future_complete(future, std::chrono::milliseconds(1)));
-
-  executor.remove_node(node);
-  executor.spin_until_future_complete(future, std::chrono::milliseconds(1));
-}

rclcpp/test/rclcpp/node_interfaces/test_node_graph.cpp

@@ -510,7 +510,9 @@ TEST_F(TestNodeGraph, get_node_names_and_namespaces_fini_errors)
     "lib:rclcpp", rcutils_string_array_fini, RCL_RET_ERROR);
   RCLCPP_EXPECT_THROW_EQ(
     node_graph()->get_node_names_and_namespaces(),
-    std::runtime_error("could not destroy node names, could not destroy node namespaces"));
+    std::runtime_error(
+    "could not destroy node names: error not set, "
+    "could not destroy node namespaces: error not set"));
 }
 
 TEST_F(TestNodeGraph, get_node_names_with_enclaves_fini_errors)

rclcpp/test/rclcpp/test_client_common.cpp

@@ -112,10 +112,12 @@ protected:
     auto req_id = client->async_send_request(request, std::move(callback));
 
     auto start = std::chrono::steady_clock::now();
+    rclcpp::executors::SingleThreadedExecutor executor;
+    executor.add_node(node);
     while (!received_response &&
       (std::chrono::steady_clock::now() - start) < timeout)
     {
-      rclcpp::spin_some(node);
+      executor.spin_some();
     }
 
     if (!received_response) {
@@ -356,10 +358,12 @@ TYPED_TEST(TestAllClientTypesWithServer, on_new_response_callback)
 
   this->template async_send_request<ClientType, test_msgs::srv::Empty::Request>(client, request);
   auto start = std::chrono::steady_clock::now();
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(server_node);
   while (server_requests_count == 0 &&
     (std::chrono::steady_clock::now() - start) < std::chrono::seconds(10))
   {
-    rclcpp::spin_some(server_node);
+    executor.spin_some();
   }
 
   ASSERT_EQ(server_requests_count, 1u);
@@ -380,7 +384,7 @@ TYPED_TEST(TestAllClientTypesWithServer, on_new_response_callback)
   while (server_requests_count == 1 &&
     (std::chrono::steady_clock::now() - start) < std::chrono::seconds(10))
   {
-    rclcpp::spin_some(server_node);
+    executor.spin_some();
   }
 
   ASSERT_EQ(server_requests_count, 2u);
@@ -402,7 +406,7 @@ TYPED_TEST(TestAllClientTypesWithServer, on_new_response_callback)
   while (server_requests_count < 5 &&
     (std::chrono::steady_clock::now() - start) < std::chrono::seconds(10))
   {
-    rclcpp::spin_some(server_node);
+    executor.spin_some();
   }
 
   ASSERT_EQ(server_requests_count, 5u);
@@ -492,10 +496,12 @@ void client_async_send_request_callback_with_request(
   auto req_id = client->async_send_request(request, std::move(callback));
 
   auto start = std::chrono::steady_clock::now();
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   while (!received_response &&
     (std::chrono::steady_clock::now() - start) < std::chrono::seconds(1))
   {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_TRUE(received_response);
   EXPECT_FALSE(client->remove_pending_request(req_id));
@@ -553,25 +559,29 @@ void client_qos_depth(rclcpp::Node::SharedPtr node)
   }
 
   auto start = std::chrono::steady_clock::now();
+  rclcpp::executors::SingleThreadedExecutor server_executor;
+  server_executor.add_node(server_node);
   while ((server_cb_count_ < client_requests) &&
     (std::chrono::steady_clock::now() - start) < 2s)
   {
-    rclcpp::spin_some(server_node);
+    server_executor.spin_some();
     std::this_thread::sleep_for(2ms);
   }
 
   EXPECT_GT(server_cb_count_, client_qos_profile.depth());
 
   start = std::chrono::steady_clock::now();
+  rclcpp::executors::SingleThreadedExecutor client_executor;
+  client_executor.add_node(node);
   while ((client_cb_count_ < client_qos_profile.depth()) &&
     (std::chrono::steady_clock::now() - start) < 1s)
   {
-    rclcpp::spin_some(node);
+    client_executor.spin_some();
   }
 
   // Spin an extra time to check if client QoS depth has been ignored,
   // so more client callbacks might be called than expected.
-  rclcpp::spin_some(node);
+  client_executor.spin_some();
 
   EXPECT_EQ(client_cb_count_, client_qos_profile.depth());
 }

rclcpp/test/rclcpp/test_clock.cpp

@@ -1,238 +0,0 @@
-// Copyright 2024 Cellumation GmbH
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <gtest/gtest.h>
-
-#include <chrono>
-#include <rcpputils/compile_warnings.hpp>
-
-#include "rcl/error_handling.h"
-#include "rcl/time.h"
-#include "rclcpp/clock.hpp"
-#include "rclcpp/rclcpp.hpp"
-#include "rclcpp/time_source.hpp"
-
-#include "../utils/rclcpp_gtest_macros.hpp"
-
-using namespace std::chrono_literals;
-
-class TestClockWakeup : public ::testing::TestWithParam<rcl_clock_type_e>
-{
-public:
-  void test_wakeup_before_sleep(const rclcpp::Clock::SharedPtr & clock)
-  {
-    std::atomic_bool thread_finished = false;
-
-    std::thread wait_thread = std::thread(
-      [&clock, &thread_finished]()
-      {
-        // make sure the thread starts sleeping late
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        clock->sleep_until(clock->now() + std::chrono::seconds(3));
-        thread_finished = true;
-      });
-    RCPPUTILS_DEPRECATION_WARNING_OFF_START
-    // notify the clock, that the sleep shall be interrupted
-    clock->cancel_sleep_or_wait();
-    RCPPUTILS_DEPRECATION_WARNING_OFF_STOP
-
-    auto start_time = std::chrono::steady_clock::now();
-    auto cur_time = start_time;
-    while (!thread_finished && start_time + std::chrono::seconds(1) > cur_time) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-      cur_time = std::chrono::steady_clock::now();
-    }
-
-    wait_thread.join();
-
-    EXPECT_TRUE(thread_finished);
-    EXPECT_LT(cur_time, start_time + std::chrono::seconds(1));
-  }
-
-  void test_wakeup_after_sleep(const rclcpp::Clock::SharedPtr & clock)
-  {
-    std::atomic_bool thread_finished = false;
-
-    std::thread wait_thread = std::thread(
-      [&clock, &thread_finished]()
-      {
-        clock->sleep_until(clock->now() + std::chrono::seconds(3));
-        thread_finished = true;
-      });
-
-    // make sure the thread is already sleeping before we send the cancel
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-
-    RCPPUTILS_DEPRECATION_WARNING_OFF_START
-    // notify the clock, that the sleep shall be interrupted
-    clock->cancel_sleep_or_wait();
-    RCPPUTILS_DEPRECATION_WARNING_OFF_STOP
-
-    auto start_time = std::chrono::steady_clock::now();
-    auto cur_time = start_time;
-    while (!thread_finished && start_time + std::chrono::seconds(1) > cur_time) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-      cur_time = std::chrono::steady_clock::now();
-    }
-
-    wait_thread.join();
-
-    EXPECT_TRUE(thread_finished);
-    EXPECT_LT(cur_time, start_time + std::chrono::seconds(1));
-  }
-
-protected:
-  static void SetUpTestCase()
-  {
-    rclcpp::init(0, nullptr);
-  }
-
-  static void TearDownTestCase()
-  {
-    rclcpp::shutdown();
-  }
-
-  void SetUp()
-  {
-    node = std::make_shared<rclcpp::Node>("my_node");
-  }
-
-  void TearDown()
-  {
-    node.reset();
-  }
-
-  rclcpp::Node::SharedPtr node;
-};
-
-INSTANTIATE_TEST_SUITE_P(
-  Clocks,
-  TestClockWakeup,
-  ::testing::Values(
-    RCL_SYSTEM_TIME, RCL_ROS_TIME, RCL_STEADY_TIME
-));
-
-TEST_P(TestClockWakeup, wakeup_sleep) {
-  auto clock = std::make_shared<rclcpp::Clock>(GetParam());
-  test_wakeup_after_sleep(clock);
-  test_wakeup_before_sleep(clock);
-}
-
-TEST_F(TestClockWakeup, wakeup_sleep_ros_time_active) {
-  node->set_parameter({"use_sim_time", true});
-  auto clock = std::make_shared<rclcpp::Clock>(RCL_ROS_TIME);
-  rclcpp::TimeSource time_source(node);
-  time_source.attachClock(clock);
-
-  EXPECT_TRUE(clock->ros_time_is_active());
-
-  test_wakeup_after_sleep(clock);
-  test_wakeup_before_sleep(clock);
-}
-
-TEST_F(TestClockWakeup, no_wakeup_on_sim_time) {
-  node->set_parameter({"use_sim_time", true});
-  auto clock = std::make_shared<rclcpp::Clock>(RCL_ROS_TIME);
-  rclcpp::TimeSource time_source(node);
-  time_source.attachClock(clock);
-
-  EXPECT_TRUE(clock->ros_time_is_active());
-
-  std::atomic_bool thread_finished = false;
-
-  std::thread wait_thread = std::thread(
-    [&clock, &thread_finished]()
-    {
-      // make sure the thread starts sleeping late
-      clock->sleep_until(clock->now() + std::chrono::milliseconds(10));
-      thread_finished = true;
-    });
-
-  // make sure, that the sim time clock does not wakeup, as no clock is provided
-  std::this_thread::sleep_for(std::chrono::milliseconds(500));
-  EXPECT_FALSE(thread_finished);
-
-  RCPPUTILS_DEPRECATION_WARNING_OFF_START
-  // notify the clock, that the sleep shall be interrupted
-  clock->cancel_sleep_or_wait();
-  RCPPUTILS_DEPRECATION_WARNING_OFF_STOP
-
-  auto start_time = std::chrono::steady_clock::now();
-  auto cur_time = start_time;
-  while (!thread_finished && start_time + std::chrono::seconds(1) > cur_time) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    cur_time = std::chrono::steady_clock::now();
-  }
-
-  wait_thread.join();
-
-  EXPECT_TRUE(thread_finished);
-  EXPECT_LT(cur_time, start_time + std::chrono::seconds(1));
-}
-
-TEST_F(TestClockWakeup, multiple_threads_wait_on_one_clock) {
-  auto clock = std::make_shared<rclcpp::Clock>(RCL_ROS_TIME);
-
-  std::vector<std::atomic_bool> thread_finished(10);
-  for (std::atomic_bool & finished : thread_finished) {
-    finished = false;
-  }
-
-  std::vector<std::thread> threads;
-
-  for (size_t nr = 0; nr < thread_finished.size(); nr++) {
-    threads.push_back(
-      std::thread(
-        [&clock, &thread_finished, nr]()
-        {
-          // make sure the thread starts sleeping late
-          clock->sleep_until(clock->now() + std::chrono::seconds(10));
-          thread_finished[nr] = true;
-        }));
-  }
-
-  // wait a bit so all threads can execute the sleep_until
-  std::this_thread::sleep_for(std::chrono::milliseconds(500));
-
-  for (const std::atomic_bool & finished : thread_finished) {
-    EXPECT_FALSE(finished);
-  }
-
-  rclcpp::shutdown();
-
-  auto start_time = std::chrono::steady_clock::now();
-  auto cur_time = start_time;
-  bool threads_finished = false;
-  while (!threads_finished && start_time + std::chrono::seconds(1) > cur_time) {
-    threads_finished = true;
-    for (const std::atomic_bool & finished : thread_finished) {
-      if (!finished) {
-        threads_finished = false;
-      }
-    }
-
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    cur_time = std::chrono::steady_clock::now();
-  }
-
-  for (const std::atomic_bool & finished : thread_finished) {
-    EXPECT_TRUE(finished);
-  }
-
-  for (auto & thread : threads) {
-    thread.join();
-  }
-
-  EXPECT_LT(cur_time, start_time + std::chrono::seconds(1));
-}

rclcpp/test/rclcpp/test_create_timer.cpp

@@ -42,7 +42,9 @@ TEST(TestCreateTimer, timer_executes)
       timer->cancel();
     });
 
-  rclcpp::spin_some(node);
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
+  executor.spin_some();
 
   ASSERT_TRUE(got_callback);
   rclcpp::shutdown();

rclcpp/test/rclcpp/test_generic_pubsub.cpp

@@ -78,8 +78,10 @@ public:
         counter++;
       });
 
+    rclcpp::executors::SingleThreadedExecutor executor;
+    executor.add_node(node_);
     while (counter < expected_recv_msg_count) {
-      rclcpp::spin_some(node_);
+      executor.spin_some();
     }
     return messages;
   }
@@ -107,11 +109,13 @@ public:
   {
     using clock = std::chrono::system_clock;
     auto start = clock::now();
+    rclcpp::executors::SingleThreadedExecutor executor;
+    executor.add_node(node_);
     while (!condition()) {
       if ((clock::now() - start) > timeout) {
         return false;
       }
-      rclcpp::spin_some(node_);
+      executor.spin_some();
     }
     return true;
   }

rclcpp/test/rclcpp/test_generic_service.cpp

@@ -372,16 +372,18 @@ TEST_F(TestGenericService, generic_service_qos_depth) {
   }
 
   auto start = std::chrono::steady_clock::now();
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(server_node);
   while ((server_cb_count_ < server_qos_profile.depth()) &&
     (std::chrono::steady_clock::now() - start) < 1s)
   {
-    rclcpp::spin_some(server_node);
+    executor.spin_some();
     std::this_thread::sleep_for(1ms);
   }
 
   // Spin an extra time to check if server QoS depth has been ignored,
   // so more server responses might be processed than expected.
-  rclcpp::spin_some(server_node);
+  executor.spin_some();
 
   EXPECT_EQ(server_cb_count_, server_qos_profile.depth());
 }

rclcpp/test/rclcpp/test_intra_process_buffer.cpp

@@ -21,7 +21,7 @@
 #include "rclcpp/rclcpp.hpp"
 
 /*
-   Construtctor
+   Constructor
  */
 TEST(TestIntraProcessBuffer, constructor) {
   using MessageT = char;

rclcpp/test/rclcpp/test_node.cpp

@@ -1365,6 +1365,203 @@ TEST_F(TestNode, set_parameter_undeclared_parameters_not_allowed) {
       node->declare_parameter(name, 42, descriptor),
       rclcpp::exceptions::InvalidParameterValueException);
   }
+  {
+    // setting an array parameter with integer range descriptor
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 10;
+    integer_range.to_value = 18;
+    integer_range.step = 2;
+    node->declare_parameter(name, std::vector<int64_t>{10, 12, 14, 16, 18}, descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<int64_t>>(), std::vector<int64_t>({10, 12, 14, 16, 18}));
+
+    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({12, 14, 10}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({12, 14, 10}));
+    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({10, 10, 10}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({10, 10, 10}));
+    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({18}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({15}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({20}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({8}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({12, 8, 18}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+  }
+  {
+    // setting an array parameter with integer range descriptor, from_value > to_value
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 20;
+    integer_range.to_value = 18;
+    integer_range.step = 1;
+    node->declare_parameter(name, std::vector<int64_t>({18, 20}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<int64_t>>(), std::vector<int64_t>({18, 20}));
+
+    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({20, 18}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({20, 18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({18, 19, 20}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({20, 18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({10}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({20, 18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({25}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({20, 18}));
+  }
+  {
+    // setting an array parameter with integer range descriptor, from_value = to_value
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 18;
+    integer_range.to_value = 18;
+    integer_range.step = 1;
+    node->declare_parameter(name, std::vector<int64_t>({18}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<int64_t>>(), std::vector<int64_t>({18}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({17}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({19}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18}));
+  }
+  {
+    // setting an array parameter with integer range descriptor,
+    // step > distance(from_value, to_value)
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 18;
+    integer_range.to_value = 25;
+    integer_range.step = 10;
+    node->declare_parameter(name, std::vector<int64_t>({18, 25}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<int64_t>>(), std::vector<int64_t>({18, 25}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({17}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18, 25}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({19}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18, 25}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({28}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18, 25}));
+  }
+  {
+    // setting an array parameter with integer range descriptor, distance not multiple of the step.
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 18;
+    integer_range.to_value = 28;
+    integer_range.step = 7;
+    node->declare_parameter(name, std::vector<int64_t>({18, 25, 28}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<int64_t>>(), std::vector<int64_t>({18, 25, 28}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({17}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18, 25, 28}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({19}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18, 25, 28}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({32}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({18, 25, 28}));
+  }
+  {
+    // setting an array parameter with integer range descriptor, step=0
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 10;
+    integer_range.to_value = 18;
+    integer_range.step = 0;
+    node->declare_parameter(name, std::vector<int64_t>({10, 11, 12, 13, 14, 15, 16, 17, 18}),
+      descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({10, 11, 12, 13, 14, 15, 16, 17, 18}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({9}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({10, 11, 12, 13, 14, 15, 16, 17, 18}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<int64_t>({19}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<int64_t>>(),
+      std::vector<int64_t>({10, 11, 12, 13, 14, 15, 16, 17, 18}));
+  }
+  {
+    // setting an array parameter with integer range descriptor and wrong default value will throw
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.integer_range.resize(1);
+    auto & integer_range = descriptor.integer_range.at(0);
+    integer_range.from_value = 10;
+    integer_range.to_value = 18;
+    integer_range.step = 2;
+    ASSERT_THROW(
+      node->declare_parameter(name, std::vector<int64_t>({10, 11, 12, 13, 14, 15, 16, 17, 18}),
+      descriptor),
+      rclcpp::exceptions::InvalidParameterValueException);
+  }
   {
     // setting a parameter with floating point range descriptor
     auto name = "parameter"_unq;
@@ -1535,6 +1732,201 @@ TEST_F(TestNode, set_parameter_undeclared_parameters_not_allowed) {
     EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 9.999)).successful);
     EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
   }
+  {
+    // setting an array parameter with floating point range descriptor
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 10.0;
+    floating_point_range.to_value = 11.0;
+    floating_point_range.step = 0.2;
+    node->declare_parameter(name, std::vector<double>({10.0, 10.4, 11.0, 10.8, 10.2, 10.6}),
+      descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.4, 11.0, 10.8, 10.2, 10.6}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({10.3}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.4, 11.0, 10.8, 10.2, 10.6}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({12.0}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.4, 11.0, 10.8, 10.2, 10.6}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({9.4}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.4, 11.0, 10.8, 10.2, 10.6}));
+  }
+  {
+    // setting an array parameter with floating point range descriptor, negative step
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 10.0;
+    floating_point_range.to_value = 11.0;
+    floating_point_range.step = -0.2;
+    node->declare_parameter(name, std::vector<double>({10.0, 10.2, 10.4, 10.6, 10.8, 11.0}),
+      descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.2, 10.4, 10.6, 10.8, 11.0}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({10.3}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.2, 10.4, 10.6, 10.8, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({12.0}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.2, 10.4, 10.6, 10.8, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({9.4}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.2, 10.4, 10.6, 10.8, 11.0}));
+  }
+  {
+    // setting an array parameter with floating point range descriptor, from_value > to_value
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 11.0;
+    floating_point_range.to_value = 10.0;
+    floating_point_range.step = 0.2;
+    node->declare_parameter(name, std::vector<double>({10.0, 11.0}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(), std::vector<double>({10.0, 11.0}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({10.2}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({12.0}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({9.4}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 11.0}));
+  }
+  {
+    // setting an array parameter with floating point range descriptor, from_value = to_value
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 10.0;
+    floating_point_range.to_value = 10.0;
+    floating_point_range.step = 0.2;
+    node->declare_parameter(name, std::vector<double>({10.0}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(), std::vector<double>({10.0}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({11.2}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({12.0}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({9.4}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0}));
+  }
+  {
+    // setting an array parameter with floating point range descriptor, step > distance
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 10.0;
+    floating_point_range.to_value = 11.0;
+    floating_point_range.step = 2.2;
+    node->declare_parameter(name, std::vector<double>({10.0, 11.0}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(), std::vector<double>({10.0, 11.0}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({12.2}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({7.8}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 11.0}));
+  }
+  {
+    // setting an array parameter with floating point range descriptor,
+    // distance not multiple of the step.
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 10.0;
+    floating_point_range.to_value = 11.0;
+    floating_point_range.step = 0.7;
+    node->declare_parameter(name, std::vector<double>({10.0, 10.7, 11.0}), descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(), std::vector<double>({10.0, 10.7, 11.0}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({12.2}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.7, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({11.4}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.7, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({9.3}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.7, 11.0}));
+  }
+  {
+    // setting an array parameter with floating point range descriptor, step=0
+    auto name = "parameter"_unq;
+    rcl_interfaces::msg::ParameterDescriptor descriptor;
+    descriptor.floating_point_range.resize(1);
+    auto & floating_point_range = descriptor.floating_point_range.at(0);
+    floating_point_range.from_value = 10.0;
+    floating_point_range.to_value = 11.0;
+    floating_point_range.step = 0.0;
+    node->declare_parameter(name, std::vector<double>({10.0, 10.0001, 10.5479051, 11.0}),
+      descriptor);
+    EXPECT_TRUE(node->has_parameter(name));
+    auto value = node->get_parameter(name);
+    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);
+    EXPECT_EQ(value.get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.0001, 10.5479051, 11.0}));
+
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({11.001}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.0001, 10.5479051, 11.0}));
+    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name,
+      std::vector<double>({9.999}))).successful);
+    EXPECT_EQ(node->get_parameter(name).get_value<std::vector<double>>(),
+      std::vector<double>({10.0, 10.0001, 10.5479051, 11.0}));
+  }
   {
     // setting a parameter with a different type is still possible
     // when having a descriptor specifying a type (type is a status, not a constraint).

rclcpp/test/rclcpp/test_ring_buffer_implementation.cpp

@@ -22,7 +22,7 @@
 #include "rclcpp/experimental/buffers/ring_buffer_implementation.hpp"
 
 /*
- * Construtctor
+ * Constructor
  */
 TEST(TestRingBufferImplementation, constructor) {
   // Cannot create a buffer of size zero.
@@ -140,6 +140,31 @@ TEST(TestRingBufferImplementation, basic_usage_unique_ptr) {
   EXPECT_EQ(false, rb.is_full());
 }
 
+TEST(TestRingBufferImplementation, test_buffer_clear) {
+  rclcpp::experimental::buffers::RingBufferImplementation<char> rb(2);
+  rb.enqueue('a');
+  rb.enqueue('b');
+
+  EXPECT_EQ(true, rb.has_data());
+  EXPECT_EQ(true, rb.is_full());
+  const auto all_data_vec = rb.get_all_data();
+  EXPECT_EQ(2u, all_data_vec.capacity());
+  EXPECT_EQ(2u, all_data_vec.size());
+  rb.clear();
+  EXPECT_EQ(false, rb.has_data());
+  EXPECT_EQ(false, rb.is_full());
+  const auto all_data_vec_empty = rb.get_all_data();
+  EXPECT_EQ(0u, all_data_vec_empty.capacity());
+  EXPECT_EQ(0u, all_data_vec_empty.size());
+  rb.enqueue('c');
+  rb.enqueue('d');
+  const auto c = rb.dequeue();
+  const auto d = rb.dequeue();
+
+  EXPECT_EQ('c', c);
+  EXPECT_EQ('d', d);
+}
+
 TEST(TestRingBufferImplementation, handle_nullptr_deletion) {
   rclcpp::experimental::buffers::RingBufferImplementation<std::unique_ptr<int>> rb(3);
   rb.enqueue(std::make_unique<int>(42));

rclcpp/test/rclcpp/test_service.cpp

@@ -386,17 +386,20 @@ TEST_F(TestService, server_qos_depth) {
     std::this_thread::sleep_for(10ms);
   }
 
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(server_node);
+
   auto start = std::chrono::steady_clock::now();
   while ((server_cb_count_ < server_qos_profile.depth()) &&
     (std::chrono::steady_clock::now() - start) < 1s)
   {
-    rclcpp::spin_some(server_node);
+    executor.spin_some();
     std::this_thread::sleep_for(1ms);
   }
 
   // Spin an extra time to check if server QoS depth has been ignored,
   // so more server responses might be processed than expected.
-  rclcpp::spin_some(server_node);
+  executor.spin_some();
 
   EXPECT_EQ(server_cb_count_, server_qos_profile.depth());
 }

rclcpp/test/rclcpp/test_service_introspection.cpp

@@ -87,6 +87,9 @@ protected:
 
 TEST_F(TestServiceIntrospection, service_introspection_nominal)
 {
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
+
   auto request = std::make_shared<BasicTypes::Request>();
   request->set__bool_value(true);
   request->set__int64_value(42);
@@ -106,7 +109,7 @@ TEST_F(TestServiceIntrospection, service_introspection_nominal)
   auto future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
 
   BasicTypes::Response::SharedPtr response = future.get();
   ASSERT_EQ(response->bool_value, false);
@@ -115,7 +118,7 @@ TEST_F(TestServiceIntrospection, service_introspection_nominal)
   // wrap up work to get all the service_event messages
   auto start = std::chrono::steady_clock::now();
   while (events.size() < 4 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   std::map<uint8_t, std::shared_ptr<const BasicTypes::Event>> event_map;
@@ -174,6 +177,9 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
   service->configure_introspection(
     node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_OFF);
 
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
+
   ASSERT_EQ(sub->get_publisher_count(), 0);
 
   auto request = std::make_shared<BasicTypes::Request>();
@@ -182,10 +188,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
   auto future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   auto start = std::chrono::steady_clock::now();
   while ((std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 0U);
 
@@ -206,10 +212,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
   future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   start = std::chrono::steady_clock::now();
   while (events.size() < 2 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 2U);
 
@@ -230,10 +236,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
   future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   start = std::chrono::steady_clock::now();
   while (events.size() < 2 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 2U);
 
@@ -254,10 +260,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
   future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   start = std::chrono::steady_clock::now();
   while (events.size() < 4 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 4U);
 }
@@ -269,6 +275,9 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
   service->configure_introspection(
     node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
 
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
+
   // Wait for the introspection to attach to our subscription
   size_t tries = 1000;
   while (this->sub->get_publisher_count() < 2 && tries-- > 0) {
@@ -282,10 +291,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
   auto future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   auto start = std::chrono::steady_clock::now();
   while (events.size() < 4 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 4U);
   for (const auto & event : events) {
@@ -310,10 +319,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
   future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   start = std::chrono::steady_clock::now();
   while (events.size() < 4 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 4U);
   for (const auto & event : events) {
@@ -350,10 +359,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
   future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   start = std::chrono::steady_clock::now();
   while (events.size() < 4 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 4U);
   for (const auto & event : events) {
@@ -390,10 +399,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
   future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   start = std::chrono::steady_clock::now();
   while (events.size() < 4 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 4U);
   for (const auto & event : events) {

rclcpp/test/rclcpp/test_subscription_content_filter.cpp

@@ -69,11 +69,13 @@ public:
   {
     using clock = std::chrono::system_clock;
     auto start = clock::now();
+    rclcpp::executors::SingleThreadedExecutor executor;
+    executor.add_node(node);
     while (!condition()) {
       if ((clock::now() - start) > timeout) {
         return false;
       }
-      rclcpp::spin_some(node);
+      executor.spin_some();
     }
     return true;
   }

rclcpp/test/rclcpp/test_typesupport_helpers.cpp

@@ -158,3 +158,15 @@ TEST(TypesupportHelpersTest, test_throw_exception_with_invalid_type) {
     rclcpp::get_action_typesupport_handle(invalid_type, "rosidl_typesupport_cpp", *library),
     std::runtime_error);
 }
+
+TEST(TypesupportHelpersTest, throws_exception_if_filetype_has_multiple_slashes_at_start) {
+  EXPECT_ANY_THROW(rclcpp::extract_type_identifier("//name_with_slashes_at_start"));
+}
+
+TEST(TypesupportHelpersTestV3, ProcessesValidTypeWithWhitespace) {
+  std::string package, middle, name;
+  std::tie(package, middle, name) = rclcpp::extract_type_identifier("   package/  name  ");
+  EXPECT_EQ(package, "package");
+  EXPECT_TRUE(middle.empty());
+  EXPECT_EQ(name, "name");
+}

rclcpp_action/CHANGELOG.rst

@@ -3,19 +3,27 @@ Changelog for package rclcpp_action
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 
-29.5.3 (2025-09-11)
+30.1.1 (2025-09-11)
 -------------------
-* fix cmake deprecation (`#2914 <https://github.com/ros2/rclcpp/issues/2914>`_) (`#2915 <https://github.com/ros2/rclcpp/issues/2915>`_)
-* Contributors: mergify[bot]
+* deprecate rclcpp::spin_some and rclcpp::spin_all (`#2848 <https://github.com/ros2/rclcpp/issues/2848>`_)
+* Contributors: Alberto Soragna
 
-29.5.2 (2025-07-07)
+30.1.0 (2025-07-29)
+-------------------
+* fix cmake deprecation (`#2914 <https://github.com/ros2/rclcpp/issues/2914>`_)
+* Contributors: mosfet80
+
+30.0.0 (2025-07-01)
 -------------------
 
-29.5.1 (2025-06-23)
+29.6.1 (2025-06-23)
+-------------------
+* Replace std::default_random_engine with std::mt19937 (rolling) (`#2843 <https://github.com/ros2/rclcpp/issues/2843>`_)
+* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_)
+* Contributors: Alejandro Hernández Cordero, keeponoiro
+
+29.6.0 (2025-04-25)
 -------------------
-* Replace std::default_random_engine with std::mt19937 (rolling) (`#2843 <https://github.com/ros2/rclcpp/issues/2843>`_) (`#2866 <https://github.com/ros2/rclcpp/issues/2866>`_)
-* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_) (`#2855 <https://github.com/ros2/rclcpp/issues/2855>`_)
-* Contributors: mergify[bot]
 
 29.5.0 (2025-04-18)
 -------------------

rclcpp_action/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_action</name>
-  <version>29.5.3</version>
+  <version>30.1.1</version>
   <description>Adds action APIs for C++.</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>

rclcpp_action/test/test_server.cpp

@@ -518,9 +518,11 @@ TEST_F(TestServer, publish_status_accepted)
 
   // 10 seconds
   const size_t max_tries = 10 * 1000 / 100;
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   for (size_t retry = 0; retry < max_tries && received_msgs.size() != 1u; ++retry) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   ASSERT_LT(0u, received_msgs.size());
@@ -582,9 +584,11 @@ TEST_F(TestServer, publish_status_canceling)
 
   // 10 seconds
   const size_t max_tries = 10 * 1000 / 100;
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   for (size_t retry = 0; retry < max_tries && received_msgs.size() < 2u; ++retry) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   ASSERT_LT(0u, received_msgs.size());
@@ -640,10 +644,12 @@ TEST_F(TestServer, publish_status_canceled)
   received_handle->canceled(std::make_shared<Fibonacci::Result>());
 
   // 10 seconds
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   const size_t max_tries = 10 * 1000 / 100;
   for (size_t retry = 0; retry < max_tries && received_msgs.size() < 3u; ++retry) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   ASSERT_LT(0u, received_msgs.size());
@@ -697,10 +703,12 @@ TEST_F(TestServer, publish_status_succeeded)
   received_handle->succeed(std::make_shared<Fibonacci::Result>());
 
   // 10 seconds
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   const size_t max_tries = 10 * 1000 / 100;
   for (size_t retry = 0; retry < max_tries && received_msgs.size() < 2u; ++retry) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   ASSERT_LT(0u, received_msgs.size());
@@ -754,10 +762,12 @@ TEST_F(TestServer, publish_status_aborted)
   received_handle->abort(std::make_shared<Fibonacci::Result>());
 
   // 10 seconds
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   const size_t max_tries = 10 * 1000 / 100;
   for (size_t retry = 0; retry < max_tries && received_msgs.size() < 2u; ++retry) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   ASSERT_LT(0u, received_msgs.size());
@@ -814,10 +824,12 @@ TEST_F(TestServer, publish_feedback)
   received_handle->publish_feedback(sent_message);
 
   // 10 seconds
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   const size_t max_tries = 10 * 1000 / 100;
   for (size_t retry = 0; retry < max_tries && received_msgs.size() < 1u; ++retry) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   ASSERT_EQ(1u, received_msgs.size());
@@ -878,10 +890,13 @@ TEST_F(TestServer, get_result)
   result->sequence = {5, 8, 13, 21};
   received_handle->succeed(result);
 
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
+
   // Wait for the result request to be received
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future));
+    executor.spin_until_future_complete(future));
 
   auto response = future.get();
   EXPECT_EQ(action_msgs::msg::GoalStatus::STATUS_SUCCEEDED, response->status);
@@ -891,13 +906,13 @@ TEST_F(TestServer, get_result)
   rclcpp::sleep_for(2 * result_timeout);
 
   // Allow for expiration to take place
-  rclcpp::spin_some(node);
+  executor.spin_some();
 
   // Send and wait for another result request
   future = result_client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future));
+    executor.spin_until_future_complete(future));
 
   response = future.get();
   EXPECT_EQ(action_msgs::msg::GoalStatus::STATUS_UNKNOWN, response->status);
@@ -946,9 +961,12 @@ TEST_F(TestServer, get_result_deferred)
   request->goal_id.uuid = uuid;
   auto future = result_client->async_send_request(request);
 
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
+
   // Process request first
   rclcpp::sleep_for(std::chrono::milliseconds(10));  // Give a chance for the request to be served
-  rclcpp::spin_some(node);
+  executor.spin_some();
 
   // Send a result
   auto result = std::make_shared<Fibonacci::Result>();
@@ -958,7 +976,7 @@ TEST_F(TestServer, get_result_deferred)
   // Wait for the result request to be received
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future));
+    executor.spin_until_future_complete(future));
 
   auto response = future.get();
   EXPECT_EQ(action_msgs::msg::GoalStatus::STATUS_SUCCEEDED, response->status);
@@ -1042,10 +1060,13 @@ public:
     result->sequence = {5, 8, 13, 21};
     goal_handle_->succeed(result);
 
+    rclcpp::executors::SingleThreadedExecutor executor;
+    executor.add_node(node_);
+
     // Wait for the result request to be received
     ASSERT_EQ(
       rclcpp::FutureReturnCode::SUCCESS,
-      rclcpp::spin_until_future_complete(node_, future));
+      executor.spin_until_future_complete(future));
 
     auto response = future.get();
     EXPECT_EQ(action_msgs::msg::GoalStatus::STATUS_SUCCEEDED, response->status);
@@ -1055,13 +1076,13 @@ public:
     rclcpp::sleep_for(std::chrono::milliseconds(100));
 
     // Allow for expiration to take place
-    rclcpp::spin_some(node_);
+    executor.spin_some();
 
     // Send and wait for another result request
     future = result_client->async_send_request(request);
     ASSERT_EQ(
       rclcpp::FutureReturnCode::SUCCESS,
-      rclcpp::spin_until_future_complete(node_, future));
+      executor.spin_until_future_complete(future));
   }
 
 protected:

rclcpp_components/CHANGELOG.rst

@@ -2,18 +2,30 @@
 Changelog for package rclcpp_components
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-29.5.3 (2025-09-11)
+30.1.1 (2025-09-11)
 -------------------
-* fix cmake deprecation (`#2914 <https://github.com/ros2/rclcpp/issues/2914>`_) (`#2915 <https://github.com/ros2/rclcpp/issues/2915>`_)
-* Contributors: mergify[bot]
+* Cleanup the dependencies in rclcpp_components. (`#2918 <https://github.com/ros2/rclcpp/issues/2918>`_)
+* Contributors: Chris Lalancette
 
-29.5.2 (2025-07-07)
+30.1.0 (2025-07-29)
 -------------------
+* fix cmake deprecation (`#2914 <https://github.com/ros2/rclcpp/issues/2914>`_)
+* Contributors: mosfet80
 
-29.5.1 (2025-06-23)
+30.0.0 (2025-07-01)
+-------------------
+* NEW PR: Add component_container for EventsExecutor (`#2885 <https://github.com/ros2/rclcpp/issues/2885>`_)
+* make sure that plugin arg includes the double colon. (`#2878 <https://github.com/ros2/rclcpp/issues/2878>`_)
+* Contributors: Mihir Rao, Tomoya Fujita
+
+29.6.1 (2025-06-23)
+-------------------
+* set thread names by node in component container isolated (`#2871 <https://github.com/ros2/rclcpp/issues/2871>`_)
+* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_)
+* Contributors: Adam Aposhian, Alejandro Hernández Cordero
+
+29.6.0 (2025-04-25)
 -------------------
-* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_) (`#2855 <https://github.com/ros2/rclcpp/issues/2855>`_)
-* Contributors: mergify[bot]
 
 29.5.0 (2025-04-18)
 -------------------

rclcpp_components/CMakeLists.txt

@@ -19,7 +19,9 @@ find_package(ament_index_cpp REQUIRED)
 find_package(class_loader REQUIRED)
 find_package(composition_interfaces REQUIRED)
 find_package(rclcpp REQUIRED)
+find_package(rcl_interfaces REQUIRED)
 find_package(rcpputils REQUIRED)
+find_package(rmw REQUIRED)
 
 # Add an interface library that can be depended upon by libraries who register components
 add_library(component INTERFACE)
@@ -39,13 +41,15 @@ target_include_directories(component_manager PUBLIC
   "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
   "$<INSTALL_INTERFACE:include/${PROJECT_NAME}>")
 target_link_libraries(component_manager PUBLIC
+  class_loader::class_loader
   ${composition_interfaces_TARGETS}
   rclcpp::rclcpp
+  rmw::rmw
 )
 target_link_libraries(component_manager PRIVATE
   ament_index_cpp::ament_index_cpp
-  class_loader::class_loader
   rcpputils::rcpputils
+  ${rcl_interfaces_TARGETS}
 )
 target_compile_definitions(component_manager
   PRIVATE "RCLCPP_COMPONENTS_BUILDING_LIBRARY")
@@ -54,7 +58,13 @@ add_executable(
   component_container
   src/component_container.cpp
 )
-target_link_libraries(component_container component_manager rclcpp::rclcpp)
+target_link_libraries(component_container PRIVATE component_manager rclcpp::rclcpp)
+
+add_executable(
+  component_container_event
+  src/component_container_event.cpp
+)
+target_link_libraries(component_container_event PRIVATE component_manager rclcpp::rclcpp)
 
 set(node_main_template_install_dir "share/${PROJECT_NAME}")
 install(FILES
@@ -65,19 +75,13 @@ add_executable(
   component_container_mt
   src/component_container_mt.cpp
 )
-target_link_libraries(component_container_mt component_manager rclcpp::rclcpp)
+target_link_libraries(component_container_mt PRIVATE component_manager rclcpp::rclcpp)
 
 add_executable(
   component_container_isolated
   src/component_container_isolated.cpp
 )
-target_link_libraries(component_container_isolated component_manager rclcpp::rclcpp)
-
-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  target_link_libraries(component_container "stdc++fs")
-  target_link_libraries(component_container_mt "stdc++fs")
-  target_link_libraries(component_container_isolated "stdc++fs")
-endif()
+target_link_libraries(component_container_isolated PRIVATE component_manager rclcpp::rclcpp)
 
 if(BUILD_TESTING)
   find_package(ament_lint_auto REQUIRED)
@@ -145,7 +149,7 @@ install(
 
 # Install executables
 install(
-  TARGETS component_container component_container_mt component_container_isolated
+  TARGETS component_container component_container_mt component_container_isolated component_container_event
   RUNTIME DESTINATION lib/${PROJECT_NAME}
 )
 
@@ -168,9 +172,5 @@ ament_export_libraries(component_manager)
 # Export modern CMake targets
 ament_export_targets(export_${PROJECT_NAME})
 
-# specific order: dependents before dependencies
-ament_export_dependencies(ament_index_cpp)
-ament_export_dependencies(class_loader)
-ament_export_dependencies(composition_interfaces)
-ament_export_dependencies(rclcpp)
+ament_export_dependencies(class_loader composition_interfaces rclcpp rcpputils rmw)
 ament_package(CONFIG_EXTRAS rclcpp_components-extras.cmake.in)

rclcpp_components/cmake/rclcpp_components_register_node.cmake

@@ -57,6 +57,9 @@ macro(rclcpp_components_register_node target)
     message(STATUS "Setting executor non-default value ${executor}")
   endif()
 
+  if("${ARGS_PLUGIN}" MATCHES "^[^:]+:[^:]+$")
+    message(FATAL_ERROR "PLUGIN argument '${ARGS_PLUGIN}' appears to be incorrect. (e.g., 'package_name::ClassName').")
+  endif()
   set(component ${ARGS_PLUGIN})
   set(node ${ARGS_EXECUTABLE})
   _rclcpp_components_register_package_hook()

rclcpp_components/include/rclcpp_components/component_manager.hpp

@@ -43,10 +43,13 @@
 
 #include <map>
 #include <memory>
+#include <stdexcept>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "class_loader/class_loader.hpp"
+
 #include "composition_interfaces/srv/load_node.hpp"
 #include "composition_interfaces/srv/unload_node.hpp"
 #include "composition_interfaces/srv/list_nodes.hpp"
@@ -56,12 +59,10 @@
 #include "rclcpp/rclcpp.hpp"
 
 #include "rclcpp_components/node_factory.hpp"
+#include "rclcpp_components/node_instance_wrapper.hpp"
 #include "rclcpp_components/visibility_control.hpp"
 
-namespace class_loader
-{
-class ClassLoader;
-}  // namespace class_loader
+#include "rmw/types.h"
 
 namespace rclcpp_components
 {

rclcpp_components/include/rclcpp_components/component_manager_isolated.hpp

@@ -16,15 +16,22 @@
 #ifndef RCLCPP_COMPONENTS__COMPONENT_MANAGER_ISOLATED_HPP__
 #define RCLCPP_COMPONENTS__COMPONENT_MANAGER_ISOLATED_HPP__
 
+#include <atomic>
+#include <chrono>
 #include <map>
 #include <memory>
 #include <string>
+#include <thread>
+#include <unordered_map>
 #include <utility>
 #include <vector>
-#include <unordered_map>
+#include <system_error>
 
+#include "rclcpp/executor.hpp"
+#include "rclcpp/executors/single_threaded_executor.hpp"
+#include "rclcpp/utilities.hpp"
 #include "rclcpp_components/component_manager.hpp"
-
+#include "rcpputils/thread_name.hpp"
 
 namespace rclcpp_components
 {
@@ -77,8 +84,16 @@ protected:
     DedicatedExecutorWrapper & wrapper = result.first->second;
     wrapper.executor = exec;
     auto & thread_initialized = wrapper.thread_initialized;
+    auto name = node_wrappers_[node_id].get_node_base_interface()->get_name();
+    // Copy name so that it doesn't deallocate before the thread is started
     wrapper.thread = std::thread(
-      [exec, &thread_initialized]() {
+      [exec, &thread_initialized, name]() {
+        try {
+          rcpputils::set_thread_name(name);
+        } catch (const std::system_error & e) {
+          RCLCPP_WARN(rclcpp::get_logger("rclcpp"), "Failed to set thread name: %s (%s)", e.what(),
+            e.code().message().c_str());
+        }
         thread_initialized = true;
         exec->spin();
       });

rclcpp_components/include/rclcpp_components/node_factory_template.hpp

@@ -18,7 +18,10 @@
 #include <functional>
 #include <memory>
 
+#include "rclcpp/node_options.hpp"
+
 #include "rclcpp_components/node_factory.hpp"
+#include "rclcpp_components/node_instance_wrapper.hpp"
 
 namespace rclcpp_components
 {

rclcpp_components/include/rclcpp_components/register_node_macro.hpp

@@ -16,6 +16,7 @@
 #define RCLCPP_COMPONENTS__REGISTER_NODE_MACRO_HPP__
 
 #include "class_loader/class_loader.hpp"
+#include "rclcpp_components/node_factory.hpp"
 #include "rclcpp_components/node_factory_template.hpp"
 
 /// Register a component that can be dynamically loaded at runtime.

rclcpp_components/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_components</name>
-  <version>29.5.3</version>
+  <version>30.1.1</version>
   <description>Package containing tools for dynamically loadable components</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
@@ -16,23 +16,32 @@
 
   <buildtool_depend>ament_cmake_ros</buildtool_depend>
 
+  <build_export_depend>class_loader</build_export_depend>
+  <build_export_depend>composition_interfaces</build_export_depend>
+  <build_export_depend>rclcpp</build_export_depend>
+  <build_export_depend>rcpputils</build_export_depend>
+  <build_export_depend>rmw</build_export_depend>
+
   <build_depend>ament_index_cpp</build_depend>
   <build_depend>class_loader</build_depend>
   <build_depend>composition_interfaces</build_depend>
   <build_depend>rclcpp</build_depend>
+  <build_depend>rcl_interfaces</build_depend>
   <build_depend>rcpputils</build_depend>
+  <build_depend>rmw</build_depend>
 
   <exec_depend>ament_index_cpp</exec_depend>
   <exec_depend>class_loader</exec_depend>
   <exec_depend>composition_interfaces</exec_depend>
   <exec_depend>rclcpp</exec_depend>
+  <exec_depend>rcl_interfaces</exec_depend>
+  <exec_depend>rcpputils</exec_depend>
+  <exec_depend>rmw</exec_depend>
 
   <test_depend>ament_cmake_google_benchmark</test_depend>
   <test_depend>ament_cmake_gtest</test_depend>
   <test_depend>ament_lint_auto</test_depend>
   <test_depend>ament_lint_common</test_depend>
-  <test_depend>launch_testing</test_depend>
-  <test_depend>std_msgs</test_depend>
 
   <export>
     <build_type>ament_cmake</build_type>

rclcpp_components/src/component_container.cpp

@@ -14,7 +14,8 @@
 
 #include <memory>
 
-#include "rclcpp/rclcpp.hpp"
+#include "rclcpp/executors/single_threaded_executor.hpp"
+#include "rclcpp/utilities.hpp"
 
 #include "rclcpp_components/component_manager.hpp"
 
@@ -26,4 +27,6 @@ int main(int argc, char * argv[])
   auto node = std::make_shared<rclcpp_components::ComponentManager>(exec);
   exec->add_node(node);
   exec->spin();
+
+  return 0;
 }

rclcpp_components/src/component_container_event.cpp

@@ -0,0 +1,32 @@
+// Copyright 2025 Open Source Robotics Foundation, Inc.Add commentMore actions
+//
+// 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.Add commentMore actions
+
+#include <memory>
+
+#include "rclcpp/utilities.hpp"
+#include "rclcpp/experimental/executors/events_executor/events_executor.hpp"
+
+#include "rclcpp_components/component_manager.hpp"
+
+int main(int argc, char * argv[])
+{
+  /// Component container with an events executor.
+  rclcpp::init(argc, argv);
+  auto exec = std::make_shared<rclcpp::experimental::executors::EventsExecutor>();
+  auto node = std::make_shared<rclcpp_components::ComponentManager>(exec);
+  exec->add_node(node);
+  exec->spin();
+
+  return 0;
+}

rclcpp_components/src/component_container_isolated.cpp

@@ -16,8 +16,10 @@
 #include <vector>
 #include <string>
 
-#include "rclcpp/rclcpp.hpp"
+#include "rclcpp/executors/single_threaded_executor.hpp"
+#include "rclcpp/executors/multi_threaded_executor.hpp"
 #include "rclcpp/utilities.hpp"
+
 #include "rclcpp_components/component_manager_isolated.hpp"
 
 int main(int argc, char * argv[])
@@ -46,4 +48,6 @@ int main(int argc, char * argv[])
   }
   exec->add_node(node);
   exec->spin();
+
+  return 0;
 }

rclcpp_components/src/component_container_mt.cpp

@@ -14,7 +14,8 @@
 
 #include <memory>
 
-#include "rclcpp/rclcpp.hpp"
+#include "rclcpp/executors/multi_threaded_executor.hpp"
+#include "rclcpp/utilities.hpp"
 
 #include "rclcpp_components/component_manager.hpp"
 
@@ -35,4 +36,6 @@ int main(int argc, char * argv[])
   }
   exec->add_node(node);
   exec->spin();
+
+  return 0;
 }

rclcpp_components/src/component_manager.cpp

@@ -17,15 +17,29 @@
 #include <filesystem>
 #include <functional>
 #include <memory>
+#include <stdexcept>
+#include <sstream>
 #include <string>
+#include <thread>
 #include <utility>
 #include <vector>
 
 #include "ament_index_cpp/get_resource.hpp"
+
 #include "class_loader/class_loader.hpp"
-#include "rcpputils/filesystem_helper.hpp"
+
+#include "rclcpp/node_options.hpp"
+#include "rclcpp/qos.hpp"
+
+#include "rclcpp_components/node_factory.hpp"
+
+#include "rcl_interfaces/msg/parameter_descriptor.hpp"
+#include "rcl_interfaces/msg/integer_range.hpp"
+
 #include "rcpputils/split.hpp"
 
+#include "rmw/types.h"
+
 using namespace std::placeholders;
 
 namespace rclcpp_components

rclcpp_lifecycle/CHANGELOG.rst

@@ -3,19 +3,29 @@ Changelog for package rclcpp_lifecycle
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 
-29.5.3 (2025-09-11)
+30.1.1 (2025-09-11)
 -------------------
-* Clearer warning message, the old one lacked information and was perhaps misleading (`#2927 <https://github.com/ros2/rclcpp/issues/2927>`_) (`#2931 <https://github.com/ros2/rclcpp/issues/2931>`_)
-* fix cmake deprecation (`#2914 <https://github.com/ros2/rclcpp/issues/2914>`_) (`#2915 <https://github.com/ros2/rclcpp/issues/2915>`_)
-* Contributors: mergify[bot]
+* deprecate rclcpp::spin_some and rclcpp::spin_all (`#2848 <https://github.com/ros2/rclcpp/issues/2848>`_)
+* Clearer warning message, the old one lacked information and was perhaps misleading (`#2927 <https://github.com/ros2/rclcpp/issues/2927>`_)
+* Contributors: Alberto Soragna, Peter Mitrano (AR)
 
-29.5.2 (2025-07-07)
+30.1.0 (2025-07-29)
+-------------------
+* fix cmake deprecation (`#2914 <https://github.com/ros2/rclcpp/issues/2914>`_)
+  cmake version < then 3.10 is deprecated
+* Contributors: mosfet80
+
+30.0.0 (2025-07-01)
 -------------------
 
-29.5.1 (2025-06-23)
+29.6.1 (2025-06-23)
+-------------------
+* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_)
+* introduce rcl_lifecycle_get_transition_label_by_id(). (`#2827 <https://github.com/ros2/rclcpp/issues/2827>`_)
+* Contributors: Alejandro Hernández Cordero, Tomoya Fujita
+
+29.6.0 (2025-04-25)
 -------------------
-* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_) (`#2855 <https://github.com/ros2/rclcpp/issues/2855>`_)
-* Contributors: mergify[bot]
 
 29.5.0 (2025-04-18)
 -------------------

rclcpp_lifecycle/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_lifecycle</name>
-  <version>29.5.3</version>
+  <version>30.1.1</version>
   <description>Package containing a prototype for lifecycle implementation</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>

rclcpp_lifecycle/src/lifecycle_node_interface_impl.cpp

@@ -414,10 +414,14 @@ LifecycleNode::LifecycleNodeInterfaceImpl::change_state(
       rcl_lifecycle_trigger_transition_by_id(
         &state_machine_, transition_id, publish_update) != RCL_RET_OK)
     {
+      const char * transition_label = rcl_lifecycle_get_transition_label_by_id(
+        &state_machine_.transition_map, transition_id);
       RCLCPP_ERROR(
         node_logging_interface_->get_logger(),
-        "Unable to start transition %u from current state %s: %s",
-        transition_id, state_machine_.current_state->label, rcl_get_error_string().str);
+        "Unable to start transition %u (%s) from current state %s: %s",
+        transition_id,
+        transition_label ? transition_label : "unknown transition",
+        state_machine_.current_state->label, rcl_get_error_string().str);
       rcutils_reset_error();
       return RCL_RET_ERROR;
     }

rclcpp_lifecycle/test/test_lifecycle_service_client.cpp

@@ -226,36 +226,28 @@ private:
     rclcpp::init(0, nullptr);
     lifecycle_node_ = std::make_shared<EmptyLifecycleNode>();
     lifecycle_client_ = std::make_shared<LifecycleServiceClient>("client");
-    spinner_ = std::thread(&TestLifecycleServiceClient::spin, this);
+
+    executor_ = std::make_shared<rclcpp::executors::SingleThreadedExecutor>();
+    spinner_ = std::thread([this]() {
+          executor_->add_node(lifecycle_node_->get_node_base_interface());
+          executor_->add_node(lifecycle_client_);
+          executor_->spin();
+    });
   }
 
   void TearDown() override
   {
-    {
-      std::lock_guard<std::mutex> guard(shutdown_mutex_);
-      rclcpp::shutdown();
+    while(!executor_->is_spinning()) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
+    executor_->cancel();
     spinner_.join();
-  }
-
-  void spin()
-  {
-    while (true) {
-      {
-        std::lock_guard<std::mutex> guard(shutdown_mutex_);
-        if (!rclcpp::ok()) {
-          break;
-        }
-        rclcpp::spin_some(lifecycle_node_->get_node_base_interface());
-        rclcpp::spin_some(lifecycle_client_);
-      }
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    }
+    rclcpp::shutdown();
   }
 
   std::shared_ptr<EmptyLifecycleNode> lifecycle_node_;
   std::shared_ptr<LifecycleServiceClient> lifecycle_client_;
-  std::mutex shutdown_mutex_;
+  std::shared_ptr<rclcpp::executors::SingleThreadedExecutor> executor_;
   std::thread spinner_;
 };
 
@@ -455,34 +447,39 @@ TEST_F(TestLifecycleServiceClientRCLErrors, call_services_rcl_errors) {
   auto mock = mocking_utils::patch_and_return(
     "lib:rclcpp_lifecycle", rcl_lifecycle_state_machine_is_initialized, RCL_RET_ERROR);
 
+  rclcpp::executors::SingleThreadedExecutor lifecycle_node_executor;
+  lifecycle_node_executor.add_node(lifecycle_node->get_node_base_interface());
+  rclcpp::executors::SingleThreadedExecutor client_executor;
+  client_executor.add_node(lifecycle_client);
+
   // on_change_state
   lifecycle_client->change_state(
     lifecycle_msgs::msg::Transition::TRANSITION_CONFIGURE);
-  rclcpp::spin_some(lifecycle_client);
+  client_executor.spin_some();
   EXPECT_THROW(
-    rclcpp::spin_some(lifecycle_node->get_node_base_interface()), std::runtime_error);
+    lifecycle_node_executor.spin_some(), std::runtime_error);
 
   // on_get_state
   lifecycle_client->get_state();
-  rclcpp::spin_some(lifecycle_client);
+  client_executor.spin_some();
   EXPECT_THROW(
-    rclcpp::spin_some(lifecycle_node->get_node_base_interface()), std::runtime_error);
+    lifecycle_node_executor.spin_some(), std::runtime_error);
 
   // on_get_avilable_states
   lifecycle_client->get_available_states();
-  rclcpp::spin_some(lifecycle_client);
+  client_executor.spin_some();
   EXPECT_THROW(
-    rclcpp::spin_some(lifecycle_node->get_node_base_interface()), std::runtime_error);
+    lifecycle_node_executor.spin_some(), std::runtime_error);
 
   // on_get_available_transitions
   lifecycle_client->get_available_transitions();
-  rclcpp::spin_some(lifecycle_client);
+  client_executor.spin_some();
   EXPECT_THROW(
-    rclcpp::spin_some(lifecycle_node->get_node_base_interface()), std::runtime_error);
+    lifecycle_node_executor.spin_some(), std::runtime_error);
 
   // on_get_transition_graph
   lifecycle_client->get_transition_graph();
-  rclcpp::spin_some(lifecycle_client);
+  client_executor.spin_some();
   EXPECT_THROW(
-    rclcpp::spin_some(lifecycle_node->get_node_base_interface()), std::runtime_error);
+    lifecycle_node_executor.spin_some(), std::runtime_error);
 }