irobot/master-events-executor features

rclcpp/CHANGELOG.rst

@@ -2,6 +2,20 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+15.1.0 (2022-03-01)
+-------------------
+* spin_all with a zero timeout. (`#1878 <https://github.com/ros2/rclcpp/issues/1878>`_)
+* Add RMW listener APIs (`#1579 <https://github.com/ros2/rclcpp/issues/1579>`_)
+* Remove fastrtps customization on tests (`#1887 <https://github.com/ros2/rclcpp/issues/1887>`_)
+* Install headers to include/${PROJECT_NAME} (`#1888 <https://github.com/ros2/rclcpp/issues/1888>`_)
+* Use ament_generate_version_header (`#1886 <https://github.com/ros2/rclcpp/issues/1886>`_)
+* use universal reference to support rvalue. (`#1883 <https://github.com/ros2/rclcpp/issues/1883>`_)
+* fix one subscription can wait_for_message twice (`#1870 <https://github.com/ros2/rclcpp/issues/1870>`_)
+* Add return value version of get_parameter_or (`#1813 <https://github.com/ros2/rclcpp/issues/1813>`_)
+* Cleanup time source object lifetimes (`#1867 <https://github.com/ros2/rclcpp/issues/1867>`_)
+* add is_spinning() method to executor base class
+* Contributors: Alberto Soragna, Chen Lihui, Chris Lalancette, Kenji Miyake, Miguel Company, Shane Loretz, Tomoya Fujita, iRobot ROS
+
 15.0.0 (2022-01-14)
 -------------------
 * Cleanup the TypeAdapt tests (`#1858 <https://github.com/ros2/rclcpp/issues/1858>`_)

rclcpp/CMakeLists.txt

@@ -191,7 +191,7 @@ endif()
 target_include_directories(${PROJECT_NAME} PUBLIC
   "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
   "$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>"
-  "$<INSTALL_INTERFACE:include>")
+  "$<INSTALL_INTERFACE:include/${PROJECT_NAME}>")
 target_link_libraries(${PROJECT_NAME} ${CMAKE_THREAD_LIBS_INIT})
 # specific order: dependents before dependencies
 ament_target_dependencies(${PROJECT_NAME}
@@ -221,11 +221,14 @@ install(
   RUNTIME DESTINATION bin
 )
 
-# specific order: dependents before dependencies
-ament_export_include_directories(include)
+# Export old-style CMake variables
+ament_export_include_directories("include/${PROJECT_NAME}")
 ament_export_libraries(${PROJECT_NAME})
+
+# Export modern CMake targets
 ament_export_targets(${PROJECT_NAME})
 
+# specific order: dependents before dependencies
 ament_export_dependencies(ament_index_cpp)
 ament_export_dependencies(libstatistics_collector)
 ament_export_dependencies(rcl)
@@ -251,12 +254,12 @@ ament_package()
 
 install(
   DIRECTORY include/ ${CMAKE_CURRENT_BINARY_DIR}/include/
-  DESTINATION include
+  DESTINATION include/${PROJECT_NAME}
 )
 
 if(TEST cppcheck)
   # must set the property after ament_package()
   set_tests_properties(cppcheck PROPERTIES TIMEOUT 500)
 endif()
 
-ament_cmake_gen_version_h()
+ament_generate_version_header(${PROJECT_NAME})

rclcpp/include/rclcpp/callback_group.hpp

@@ -138,6 +138,14 @@ class CallbackGroup
   const CallbackGroupType &
   type() const;
 
+  RCLCPP_PUBLIC
+  void collect_all_ptrs(
+    std::function<void(const rclcpp::SubscriptionBase::SharedPtr &)> sub_func,
+    std::function<void(const rclcpp::ServiceBase::SharedPtr &)> service_func,
+    std::function<void(const rclcpp::ClientBase::SharedPtr &)> client_func,
+    std::function<void(const rclcpp::TimerBase::SharedPtr &)> timer_func,
+    std::function<void(const rclcpp::Waitable::SharedPtr &)> waitable_func) const;
+
   /// Return a reference to the 'associated with executor' atomic boolean.
   /**
    * When a callback group is added to an executor this boolean is checked

rclcpp/include/rclcpp/client.hpp

@@ -273,7 +273,7 @@ class ClientBase
         }
       };
 
-    std::lock_guard<std::recursive_mutex> lock(listener_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);
 
     // Set it temporarily to the new callback, while we replace the old one.
     // This two-step setting, prevents a gap where the old std::function has
@@ -295,7 +295,7 @@ class ClientBase
   void
   clear_on_new_response_callback()
   {
-    std::lock_guard<std::recursive_mutex> lock(listener_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);
     if (on_new_response_callback_) {
       set_on_new_response_callback(nullptr, nullptr);
       on_new_response_callback_ = nullptr;
@@ -330,7 +330,7 @@ class ClientBase
 
   std::atomic<bool> in_use_by_wait_set_{false};
 
-  std::recursive_mutex listener_mutex_;
+  std::recursive_mutex callback_mutex_;
   std::function<void(size_t)> on_new_response_callback_{nullptr};
 };
 

rclcpp/include/rclcpp/create_publisher.hpp

@@ -92,7 +92,7 @@ template<
   typename NodeT>
 std::shared_ptr<PublisherT>
 create_publisher(
-  NodeT & node,
+  NodeT && node,
   const std::string & topic_name,
   const rclcpp::QoS & qos,
   const rclcpp::PublisherOptionsWithAllocator<AllocatorT> & options = (

rclcpp/include/rclcpp/detail/cpp_callback_trampoline.hpp

@@ -38,7 +38,7 @@ namespace detail
  * captures, and various kinds of std::bind instances.
  *
  * The interior of this function is likely to be executed within a C runtime,
- * so no exceptins should be thrown at this point, and doing so results in
+ * so no exceptions should be thrown at this point, and doing so results in
  * undefined behavior.
  *
  * \tparam UserDataT Deduced type based on what is passed for user data,

rclcpp/include/rclcpp/executor.hpp

@@ -305,7 +305,9 @@ class Executor
    * If the time that waitables take to be executed is longer than the period on which new waitables
    * become ready, this method will execute work repeatedly until `max_duration` has elapsed.
    *
-   * \param[in] max_duration The maximum amount of time to spend executing work. Must be positive.
+   * \param[in] max_duration The maximum amount of time to spend executing work, must be >= 0.
+   *   `0` is potentially block forever until no more work is available.
+   * \throw throw std::invalid_argument if max_duration is less than 0.
    * Note that spin_all() may take longer than this time as it only returns once max_duration has
    * been exceeded.
    */

rclcpp/include/rclcpp/executors/static_single_threaded_executor.hpp

@@ -99,9 +99,10 @@ class StaticSingleThreadedExecutor : public rclcpp::Executor
 
   /// Static executor implementation of spin all
   /**
-   * This non-blocking function will execute entities until
-   * timeout or no more work available. If new entities get ready
-   * while executing work available, they will be executed
+   * 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:

rclcpp/include/rclcpp/experimental/subscription_intra_process_base.hpp

@@ -103,7 +103,7 @@ class SubscriptionIntraProcessBase : public rclcpp::Waitable
    * The application should provide a generic callback function that will be then
    * forwarded by the waitable to all of its entities.
    * Before forwarding, a different value for the identifier argument will be
-   * bond to the function.
+   * bound to the function.
    * This implies that the provided callback can use the identifier to behave
    * differently depending on which entity triggered the waitable to become ready.
    *
@@ -149,11 +149,11 @@ class SubscriptionIntraProcessBase : public rclcpp::Waitable
         }
       };
 
-    std::lock_guard<std::recursive_mutex> lock(listener_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);
     on_new_message_callback_ = new_callback;
 
     if (unread_count_ > 0) {
-      if (qos_profile_.history() == HistoryPolicy::KeepLast || qos_profile_.depth() == 0) {
+      if (qos_profile_.history() == HistoryPolicy::KeepAll) {
         on_new_message_callback_(unread_count_);
       } else {
         // Use qos profile depth as upper bound for unread_count_
@@ -167,19 +167,30 @@ class SubscriptionIntraProcessBase : public rclcpp::Waitable
   void
   clear_on_ready_callback() override
   {
-    std::lock_guard<std::recursive_mutex> lock(listener_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);
     on_new_message_callback_ = nullptr;
   }
 
 protected:
-  std::recursive_mutex listener_mutex_;
+  std::recursive_mutex callback_mutex_;
   std::function<void(size_t)> on_new_message_callback_ {nullptr};
   size_t unread_count_{0};
   rclcpp::GuardCondition gc_;
 
   virtual void
   trigger_guard_condition() = 0;
 
+  void
+  invoke_on_new_message()
+  {
+    std::lock_guard<std::recursive_mutex> lock(this->callback_mutex_);
+    if (this->on_new_message_callback_) {
+      this->on_new_message_callback_(1);
+    } else {
+      this->unread_count_++;
+    }
+  }
+
 private:
   std::string topic_name_;
   QoS qos_profile_;

rclcpp/include/rclcpp/experimental/subscription_intra_process_buffer.hpp

@@ -125,7 +125,7 @@ class SubscriptionIntraProcessBuffer : public SubscriptionROSMsgIntraProcessBuff
       buffer_->add_shared(convert_ros_message_to_subscribed_type_unique_ptr(*message));
       trigger_guard_condition();
     }
-    invoke_on_new_message_listener();
+    this->invoke_on_new_message();
   }
 
   void
@@ -138,23 +138,23 @@ class SubscriptionIntraProcessBuffer : public SubscriptionROSMsgIntraProcessBuff
       buffer_->add_unique(convert_ros_message_to_subscribed_type_unique_ptr(*message));
       trigger_guard_condition();
     }
-    invoke_on_new_message_listener();
+    this->invoke_on_new_message();
   }
 
   void
   provide_intra_process_data(ConstDataSharedPtr message)
   {
     buffer_->add_shared(std::move(message));
     trigger_guard_condition();
-    invoke_on_new_message_listener();
+    this->invoke_on_new_message();
   }
 
   void
   provide_intra_process_data(SubscribedTypeUniquePtr message)
   {
     buffer_->add_unique(std::move(message));
     trigger_guard_condition();
-    invoke_on_new_message_listener();
+    this->invoke_on_new_message();
   }
 
   bool

rclcpp/include/rclcpp/memory_strategy.hpp

@@ -100,52 +100,52 @@ class RCLCPP_PUBLIC MemoryStrategy
 
   static rclcpp::SubscriptionBase::SharedPtr
   get_subscription_by_handle(
-    std::shared_ptr<const rcl_subscription_t> subscriber_handle,
+    const std::shared_ptr<const rcl_subscription_t> & subscriber_handle,
     const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes);
 
   static rclcpp::ServiceBase::SharedPtr
   get_service_by_handle(
-    std::shared_ptr<const rcl_service_t> service_handle,
+    const std::shared_ptr<const rcl_service_t> & service_handle,
     const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes);
 
   static rclcpp::ClientBase::SharedPtr
   get_client_by_handle(
-    std::shared_ptr<const rcl_client_t> client_handle,
+    const std::shared_ptr<const rcl_client_t> & client_handle,
     const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes);
 
   static rclcpp::TimerBase::SharedPtr
   get_timer_by_handle(
-    std::shared_ptr<const rcl_timer_t> timer_handle,
+    const std::shared_ptr<const rcl_timer_t> & timer_handle,
     const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes);
 
   static rclcpp::node_interfaces::NodeBaseInterface::SharedPtr
   get_node_by_group(
-    rclcpp::CallbackGroup::SharedPtr group,
+    const rclcpp::CallbackGroup::SharedPtr & group,
     const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes);
 
   static rclcpp::CallbackGroup::SharedPtr
   get_group_by_subscription(
-    rclcpp::SubscriptionBase::SharedPtr subscription,
+    const rclcpp::SubscriptionBase::SharedPtr & subscription,
     const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes);
 
   static rclcpp::CallbackGroup::SharedPtr
   get_group_by_service(
-    rclcpp::ServiceBase::SharedPtr service,
+    const rclcpp::ServiceBase::SharedPtr & service,
     const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes);
 
   static rclcpp::CallbackGroup::SharedPtr
   get_group_by_client(
-    rclcpp::ClientBase::SharedPtr client,
+    const rclcpp::ClientBase::SharedPtr & client,
     const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes);
 
   static rclcpp::CallbackGroup::SharedPtr
   get_group_by_timer(
-    rclcpp::TimerBase::SharedPtr timer,
+    const rclcpp::TimerBase::SharedPtr & timer,
     const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes);
 
   static rclcpp::CallbackGroup::SharedPtr
   get_group_by_waitable(
-    rclcpp::Waitable::SharedPtr waitable,
+    const rclcpp::Waitable::SharedPtr & waitable,
     const WeakCallbackGroupsToNodesMap & weak_groups_to_nodes);
 };
 

rclcpp/include/rclcpp/qos_event.hpp

@@ -179,7 +179,7 @@ class QOSEventHandlerBase : public Waitable
         }
       };
 
-    std::lock_guard<std::recursive_mutex> lock(listener_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);
 
     // Set it temporarily to the new callback, while we replace the old one.
     // This two-step setting, prevents a gap where the old std::function has
@@ -201,7 +201,7 @@ class QOSEventHandlerBase : public Waitable
   void
   clear_on_ready_callback() override
   {
-    std::lock_guard<std::recursive_mutex> lock(listener_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);
     if (on_new_event_callback_) {
       set_on_new_event_callback(nullptr, nullptr);
       on_new_event_callback_ = nullptr;
@@ -215,7 +215,7 @@ class QOSEventHandlerBase : public Waitable
 
   rcl_event_t event_handle_;
   size_t wait_set_event_index_;
-  std::recursive_mutex listener_mutex_;
+  std::recursive_mutex callback_mutex_;
   std::function<void(size_t)> on_new_event_callback_{nullptr};
 };
 

rclcpp/include/rclcpp/service.hpp

@@ -183,7 +183,7 @@ class ServiceBase
         }
       };
 
-    std::lock_guard<std::recursive_mutex> lock(listener_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);
 
     // Set it temporarily to the new callback, while we replace the old one.
     // This two-step setting, prevents a gap where the old std::function has
@@ -205,7 +205,7 @@ class ServiceBase
   void
   clear_on_new_request_callback()
   {
-    std::lock_guard<std::recursive_mutex> lock(listener_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(callback_mutex_);
     if (on_new_request_callback_) {
       set_on_new_request_callback(nullptr, nullptr);
       on_new_request_callback_ = nullptr;
@@ -236,7 +236,7 @@ class ServiceBase
 
   std::atomic<bool> in_use_by_wait_set_{false};
 
-  std::recursive_mutex listener_mutex_;
+  std::recursive_mutex callback_mutex_;
   std::function<void(size_t)> on_new_request_callback_{nullptr};
 };