first try of node like something

Signed-off-by: Karsten Knese <karsten@openrobotics.org>

rclcpp/CHANGELOG.rst

@@ -2,32 +2,6 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-0.7.5 (2019-05-30)
-------------------
-* Avoid 'Intra process message no longer being stored when trying to handle it' warning (`#749 <https://github.com/ros2/rclcpp/issues/749>`_)
-* Contributors: ivanpauno
-
-0.7.4 (2019-05-29)
-------------------
-* Rename parameter options (`#745 <https://github.com/ros2/rclcpp/issues/745>`_)
-* Bionic use of strerror_r (`#742 <https://github.com/ros2/rclcpp/issues/742>`_)
-* Enforce parameter ranges (`#735 <https://github.com/ros2/rclcpp/issues/735>`_)
-* removed not used parameter client (`#740 <https://github.com/ros2/rclcpp/issues/740>`_)
-* ensure removal of guard conditions of expired nodes from memory strategy (`#741 <https://github.com/ros2/rclcpp/issues/741>`_)
-* Fix typo in log warning message (`#737 <https://github.com/ros2/rclcpp/issues/737>`_)
-* Throw nice errors when creating a publisher with intraprocess communication and incompatible qos policy (`#729 <https://github.com/ros2/rclcpp/issues/729>`_)
-* Contributors: Alberto Soragna, Dirk Thomas, Jacob Perron, William Woodall, ivanpauno, roderick-koehle
-
-0.7.3 (2019-05-20)
-------------------
-* Fixed misspelling, volitile -> volatile (`#724 <https://github.com/ros2/rclcpp/issues/724>`_), and then fixed that since it is a C++ keyword to be ``durability_volatile`` (`#725 <https://github.com/ros2/rclcpp/issues/725>`_)
-* Fixed a clang warning (`#723 <https://github.com/ros2/rclcpp/issues/723>`_)
-* Added ``on_parameter_event`` static method to the ``AsyncParametersClient`` (`#688 <https://github.com/ros2/rclcpp/issues/688>`_)
-* Added a guard against ``ParameterNotDeclaredException`` throwing from within the parameter service callbacks. (`#718 <https://github.com/ros2/rclcpp/issues/718>`_)
-* Added missing template functionality to lifecycle_node. (`#707 <https://github.com/ros2/rclcpp/issues/707>`_)
-* Fixed heap-use-after-free and memory leaks reported from ``test_node.cpp`` (`#719 <https://github.com/ros2/rclcpp/issues/719>`_)
-* Contributors: Alberto Soragna, Dirk Thomas, Emerson Knapp, Jacob Perron, Michael Jeronimo, Prajakta Gokhale
-
 0.7.2 (2019-05-08)
 ------------------
 * Added new way to specify QoS settings for publishers and subscriptions. (`#713 <https://github.com/ros2/rclcpp/issues/713>`_)

rclcpp/CMakeLists.txt

@@ -85,19 +85,40 @@ configure_file(
   COPYONLY
 )
 # generate header with logging macros
-set(python_code
+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 "${python_code}")
+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 ${PYTHON_EXECUTABLE} ARGS -c "${python_code}"
+  COMMAND ${PYTHON_EXECUTABLE} 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)
+
+# "watch" template for changes
+configure_file(
+  "resource/interface_traits.hpp.em"
+  "interface_traits.hpp.em.watch"
+  COPYONLY
+)
+set(python_code_interface_traits
+  "import em"
+  "em.invoke(['-o', 'include/rclcpp/node_interfaces/interface_traits.hpp', '${CMAKE_CURRENT_SOURCE_DIR}/resource/interface_traits.hpp.em'])")
+string(REPLACE ";" "$<SEMICOLON>" python_code_interface_traits "${python_code_interface_traits}")
+add_custom_command(OUTPUT include/rclcpp/node_interfaces/interface_traits.hpp
+  COMMAND ${CMAKE_COMMAND} -E make_directory "include/rclcpp/node_interfaces"
+  COMMAND ${PYTHON_EXECUTABLE} ARGS -c "${python_code_interface_traits}"
+  DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/interface_traits.hpp.em.watch"
+  COMMENT "Expanding interfae_traits.hpp.em"
+  VERBATIM
+)
+list(APPEND ${PROJECT_NAME}_SRCS
+  include/rclcpp/node_interfaces/interface_traits.hpp)
+
 include_directories("${CMAKE_CURRENT_BINARY_DIR}/include")
 
 add_library(${PROJECT_NAME}
@@ -242,13 +263,6 @@ if(BUILD_TESTING)
     )
     target_link_libraries(test_node_global_args ${PROJECT_NAME})
   endif()
-  ament_add_gtest(test_parameter_client test/test_parameter_client.cpp)
-  if(TARGET test_parameter_client)
-    ament_target_dependencies(test_parameter_client
-      "rcl_interfaces"
-    )
-    target_link_libraries(test_parameter_client ${PROJECT_NAME})
-  endif()
   ament_add_gtest(test_parameter_events_filter test/test_parameter_events_filter.cpp)
   if(TARGET test_parameter_events_filter)
     ament_target_dependencies(test_parameter_events_filter
@@ -455,6 +469,14 @@ if(BUILD_TESTING)
     target_link_libraries(test_init ${PROJECT_NAME})
   endif()
 
+  ament_add_gtest(test_interface_traits test/test_interface_traits.cpp
+    APPEND_LIBRARY_DIRS "${append_library_dirs}")
+  if(TARGET test_interface_traits)
+    ament_target_dependencies(test_interface_traits
+      "rcl")
+    target_link_libraries(test_interface_traits ${PROJECT_NAME})
+  endif()
+
   ament_add_gtest(test_multi_threaded_executor test/executors/test_multi_threaded_executor.cpp
     APPEND_LIBRARY_DIRS "${append_library_dirs}")
   if(TARGET test_multi_threaded_executor)

rclcpp/include/rclcpp/executor.hpp

@@ -364,8 +364,7 @@ protected:
 private:
   RCLCPP_DISABLE_COPY(Executor)
 
-  std::list<rclcpp::node_interfaces::NodeBaseInterface::WeakPtr> weak_nodes_;
-  std::list<const rcl_guard_condition_t *> guard_conditions_;
+  std::vector<rclcpp::node_interfaces::NodeBaseInterface::WeakPtr> weak_nodes_;
 };
 
 }  // namespace executor

rclcpp/include/rclcpp/memory_strategy.hpp

@@ -15,8 +15,8 @@
 #ifndef RCLCPP__MEMORY_STRATEGY_HPP_
 #define RCLCPP__MEMORY_STRATEGY_HPP_
 
-#include <list>
 #include <memory>
+#include <vector>
 
 #include "rcl/allocator.h"
 #include "rcl/wait.h"
@@ -42,11 +42,11 @@ class RCLCPP_PUBLIC MemoryStrategy
 {
 public:
   RCLCPP_SMART_PTR_DEFINITIONS_NOT_COPYABLE(MemoryStrategy)
-  using WeakNodeList = std::list<rclcpp::node_interfaces::NodeBaseInterface::WeakPtr>;
+  using WeakNodeVector = std::vector<rclcpp::node_interfaces::NodeBaseInterface::WeakPtr>;
 
   virtual ~MemoryStrategy() = default;
 
-  virtual bool collect_entities(const WeakNodeList & weak_nodes) = 0;
+  virtual bool collect_entities(const WeakNodeVector & weak_nodes) = 0;
 
   virtual size_t number_of_ready_subscriptions() const = 0;
   virtual size_t number_of_ready_services() const = 0;
@@ -67,22 +67,22 @@ public:
   virtual void
   get_next_subscription(
     rclcpp::executor::AnyExecutable & any_exec,
-    const WeakNodeList & weak_nodes) = 0;
+    const WeakNodeVector & weak_nodes) = 0;
 
   virtual void
   get_next_service(
     rclcpp::executor::AnyExecutable & any_exec,
-    const WeakNodeList & weak_nodes) = 0;
+    const WeakNodeVector & weak_nodes) = 0;
 
   virtual void
   get_next_client(
     rclcpp::executor::AnyExecutable & any_exec,
-    const WeakNodeList & weak_nodes) = 0;
+    const WeakNodeVector & weak_nodes) = 0;
 
   virtual void
   get_next_waitable(
     rclcpp::executor::AnyExecutable & any_exec,
-    const WeakNodeList & weak_nodes) = 0;
+    const WeakNodeVector & weak_nodes) = 0;
 
   virtual rcl_allocator_t
   get_allocator() = 0;
@@ -90,42 +90,42 @@ public:
   static rclcpp::SubscriptionBase::SharedPtr
   get_subscription_by_handle(
     std::shared_ptr<const rcl_subscription_t> subscriber_handle,
-    const WeakNodeList & weak_nodes);
+    const WeakNodeVector & weak_nodes);
 
   static rclcpp::ServiceBase::SharedPtr
   get_service_by_handle(
     std::shared_ptr<const rcl_service_t> service_handle,
-    const WeakNodeList & weak_nodes);
+    const WeakNodeVector & weak_nodes);
 
   static rclcpp::ClientBase::SharedPtr
   get_client_by_handle(
     std::shared_ptr<const rcl_client_t> client_handle,
-    const WeakNodeList & weak_nodes);
+    const WeakNodeVector & weak_nodes);
 
   static rclcpp::node_interfaces::NodeBaseInterface::SharedPtr
   get_node_by_group(
     rclcpp::callback_group::CallbackGroup::SharedPtr group,
-    const WeakNodeList & weak_nodes);
+    const WeakNodeVector & weak_nodes);
 
   static rclcpp::callback_group::CallbackGroup::SharedPtr
   get_group_by_subscription(
     rclcpp::SubscriptionBase::SharedPtr subscription,
-    const WeakNodeList & weak_nodes);
+    const WeakNodeVector & weak_nodes);
 
   static rclcpp::callback_group::CallbackGroup::SharedPtr
   get_group_by_service(
     rclcpp::ServiceBase::SharedPtr service,
-    const WeakNodeList & weak_nodes);
+    const WeakNodeVector & weak_nodes);
 
   static rclcpp::callback_group::CallbackGroup::SharedPtr
   get_group_by_client(
     rclcpp::ClientBase::SharedPtr client,
-    const WeakNodeList & weak_nodes);
+    const WeakNodeVector & weak_nodes);
 
   static rclcpp::callback_group::CallbackGroup::SharedPtr
   get_group_by_waitable(
     rclcpp::Waitable::SharedPtr waitable,
-    const WeakNodeList & weak_nodes);
+    const WeakNodeVector & weak_nodes);
 };
 
 }  // namespace memory_strategy

rclcpp/include/rclcpp/node.hpp

@@ -940,6 +940,7 @@ public:
   void
   register_param_change_callback(CallbackT && callback);
 
+
   /// Get the fully-qualified names of all available nodes.
   /**
    * The fully-qualified name includes the local namespace and name of the node.

rclcpp/include/rclcpp/node_interfaces/node_parameters.hpp

@@ -63,13 +63,13 @@ public:
     const node_interfaces::NodeTopicsInterface::SharedPtr node_topics,
     const node_interfaces::NodeServicesInterface::SharedPtr node_services,
     const node_interfaces::NodeClockInterface::SharedPtr node_clock,
-    const std::vector<Parameter> & parameter_overrides,
+    const std::vector<Parameter> & initial_parameters,
     bool start_parameter_services,
     bool start_parameter_event_publisher,
     const rclcpp::QoS & parameter_event_qos,
     const rclcpp::PublisherOptionsBase & parameter_event_publisher_options,
     bool allow_undeclared_parameters,
-    bool automatically_declare_parameters_from_overrides);
+    bool automatically_declare_initial_parameters);
 
   RCLCPP_PUBLIC
   virtual
@@ -143,7 +143,7 @@ public:
 
   RCLCPP_PUBLIC
   const std::map<std::string, rclcpp::ParameterValue> &
-  get_parameter_overrides() const override;
+  get_initial_parameter_values() const override;
 
 private:
   RCLCPP_DISABLE_COPY(NodeParameters)
@@ -154,7 +154,7 @@ private:
 
   std::map<std::string, ParameterInfo> parameters_;
 
-  std::map<std::string, rclcpp::ParameterValue> parameter_overrides_;
+  std::map<std::string, rclcpp::ParameterValue> initial_parameter_values_;
 
   bool allow_undeclared_ = false;
 

rclcpp/include/rclcpp/node_interfaces/node_parameters_interface.hpp

@@ -183,7 +183,7 @@ public:
   RCLCPP_PUBLIC
   virtual
   const std::map<std::string, rclcpp::ParameterValue> &
-  get_parameter_overrides() const = 0;
+  get_initial_parameter_values() const = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_options.hpp

@@ -40,7 +40,7 @@ public:
    *
    *   - context = rclcpp::contexts::default_context::get_global_default_context()
    *   - arguments = {}
-   *   - parameter_overrides = {}
+   *   - initial_parameters = {}
    *   - use_global_arguments = true
    *   - use_intra_process_comms = false
    *   - start_parameter_services = true
@@ -49,7 +49,7 @@ public:
    *     - with history setting and depth from rmw_qos_profile_parameter_events
    *   - parameter_event_publisher_options = rclcpp::PublisherOptionsBase
    *   - allow_undeclared_parameters = false
-   *   - automatically_declare_parameters_from_overrides = false
+   *   - automatically_declare_initial_parameters = false
    *   - allocator = rcl_get_default_allocator()
    *
    * \param[in] allocator allocator to use in construction of NodeOptions.
@@ -107,31 +107,31 @@ public:
   NodeOptions &
   arguments(const std::vector<std::string> & arguments);
 
-  /// Return a reference to the list of parameter overrides.
+  /// Return a reference to the list of initial parameters.
   RCLCPP_PUBLIC
   std::vector<rclcpp::Parameter> &
-  parameter_overrides();
+  initial_parameters();
 
   RCLCPP_PUBLIC
   const std::vector<rclcpp::Parameter> &
-  parameter_overrides() const;
+  initial_parameters() const;
 
-  /// Set the parameters overrides, return this for parameter idiom.
+  /// Set the initial parameters, return this for parameter idiom.
   /**
-   * These parameter overrides are used to change the initial value
+   * These initial parameter values are used to change the initial value
    * of declared parameters within the node, overriding hard coded default
    * values if necessary.
    */
   RCLCPP_PUBLIC
   NodeOptions &
-  parameter_overrides(const std::vector<rclcpp::Parameter> & parameter_overrides);
+  initial_parameters(const std::vector<rclcpp::Parameter> & initial_parameters);
 
-  /// Append a single parameter override, parameter idiom style.
+  /// Append a single initial parameter, parameter idiom style.
   template<typename ParameterT>
   NodeOptions &
-  append_parameter_override(const std::string & name, const ParameterT & value)
+  append_initial_parameter(const std::string & name, const ParameterT & value)
   {
-    this->parameter_overrides().emplace_back(name, rclcpp::ParameterValue(value));
+    this->initial_parameters().emplace_back(name, rclcpp::ParameterValue(value));
     return *this;
   }
 
@@ -247,35 +247,29 @@ public:
    * If true, allow any parameter name to be set on the node without first
    * being declared.
    * Otherwise, setting an undeclared parameter will raise an exception.
-   *
-   * This option being true does not affect parameter_overrides, as the first
-   * set action will implicitly declare the parameter and therefore consider
-   * any parameter overrides.
    */
   RCLCPP_PUBLIC
   NodeOptions &
   allow_undeclared_parameters(bool allow_undeclared_parameters);
 
-  /// Return the automatically_declare_parameters_from_overrides flag.
+  /// Return the automatically_declare_initial_parameters flag.
   RCLCPP_PUBLIC
   bool
-  automatically_declare_parameters_from_overrides() const;
+  automatically_declare_initial_parameters() const;
 
-  /// Set the automatically_declare_parameters_from_overrides, return this.
+  /// Set the automatically_declare_initial_parameters, return this.
   /**
-   * If true, automatically iterate through the node's parameter overrides and
+   * If true, automatically iterate through the node's initial parameters and
    * implicitly declare any that have not already been declared.
-   * Otherwise, parameters passed to the node's parameter_overrides, and/or the
-   * global arguments (e.g. parameter overrides from a YAML file), which are
-   * not explicitly declared will not appear on the node at all, even if
-   * `allow_undeclared_parameters` is true.
+   * Otherwise, parameters passed to the node's initial_parameters, and/or the
+   * global initial parameter values, which are not explicitly declared will
+   * not appear on the node at all.
    * Already declared parameters will not be re-declared, and parameters
    * declared in this way will use the default constructed ParameterDescriptor.
    */
   RCLCPP_PUBLIC
   NodeOptions &
-  automatically_declare_parameters_from_overrides(
-    bool automatically_declare_parameters_from_overrides);
+  automatically_declare_initial_parameters(bool automatically_declare_initial_parameters);
 
   /// Return the rcl_allocator_t to be used.
   RCLCPP_PUBLIC
@@ -308,7 +302,7 @@ private:
 
   std::vector<std::string> arguments_ {};
 
-  std::vector<rclcpp::Parameter> parameter_overrides_ {};
+  std::vector<rclcpp::Parameter> initial_parameters_ {};
 
   bool use_global_arguments_ {true};
 
@@ -326,7 +320,7 @@ private:
 
   bool allow_undeclared_parameters_ {false};
 
-  bool automatically_declare_parameters_from_overrides_ {false};
+  bool automatically_declare_initial_parameters_ {false};
 
   rcl_allocator_t allocator_ {rcl_get_default_allocator()};
 };

rclcpp/include/rclcpp/parameter_client.hpp

@@ -120,36 +120,9 @@ public:
     const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options = (
       rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()
   ))
-  {
-    return this->on_parameter_event(
-      this->node_topics_interface_,
-      callback,
-      qos,
-      options);
-  }
-
-  /**
-   * The NodeT type only needs to have a method called get_node_topics_interface()
-   * which returns a shared_ptr to a NodeTopicsInterface, or be a
-   * NodeTopicsInterface pointer itself.
-   */
-  template<
-    typename CallbackT,
-    typename NodeT,
-    typename AllocatorT = std::allocator<void>>
-  static typename rclcpp::Subscription<rcl_interfaces::msg::ParameterEvent>::SharedPtr
-  on_parameter_event(
-    NodeT && node,
-    CallbackT && callback,
-    const rclcpp::QoS & qos = (
-      rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(rmw_qos_profile_default))
-    ),
-    const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options = (
-      rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()
-  ))
   {
     return rclcpp::create_subscription<rcl_interfaces::msg::ParameterEvent>(
-      node,
+      this->node_topics_interface_,
       "parameter_events",
       qos,
       std::forward<CallbackT>(callback),
@@ -293,26 +266,7 @@ public:
   typename rclcpp::Subscription<rcl_interfaces::msg::ParameterEvent>::SharedPtr
   on_parameter_event(CallbackT && callback)
   {
-    return async_parameters_client_->on_parameter_event(
-      std::forward<CallbackT>(callback));
-  }
-
-  /**
-   * The NodeT type only needs to have a method called get_node_topics_interface()
-   * which returns a shared_ptr to a NodeTopicsInterface, or be a
-   * NodeTopicsInterface pointer itself.
-   */
-  template<
-    typename CallbackT,
-    typename NodeT>
-  static typename rclcpp::Subscription<rcl_interfaces::msg::ParameterEvent>::SharedPtr
-  on_parameter_event(
-    NodeT && node,
-    CallbackT && callback)
-  {
-    return AsyncParametersClient::on_parameter_event(
-      node,
-      std::forward<CallbackT>(callback));
+    return async_parameters_client_->on_parameter_event(std::forward<CallbackT>(callback));
   }
 
   RCLCPP_PUBLIC

rclcpp/include/rclcpp/qos.hpp

@@ -105,11 +105,8 @@ public:
   durability(rmw_qos_durability_policy_t durability);
 
   /// Set the durability setting to volatile.
-  /**
-    * Note that this cannot be named `volatile` because it is a C++ keyword.
-    */
   QoS &
-  durability_volatile();
+  volitile();
 
   /// Set the durability setting to transient local.
   QoS &

rclcpp/include/rclcpp/strategies/allocator_memory_strategy.hpp

@@ -150,7 +150,7 @@ public:
     );
   }
 
-  bool collect_entities(const WeakNodeList & weak_nodes)
+  bool collect_entities(const WeakNodeVector & weak_nodes)
   {
     bool has_invalid_weak_nodes = false;
     for (auto & weak_node : weak_nodes) {
@@ -265,7 +265,7 @@ public:
   virtual void
   get_next_subscription(
     executor::AnyExecutable & any_exec,
-    const WeakNodeList & weak_nodes)
+    const WeakNodeVector & weak_nodes)
   {
     auto it = subscription_handles_.begin();
     while (it != subscription_handles_.end()) {
@@ -309,7 +309,7 @@ public:
   virtual void
   get_next_service(
     executor::AnyExecutable & any_exec,
-    const WeakNodeList & weak_nodes)
+    const WeakNodeVector & weak_nodes)
   {
     auto it = service_handles_.begin();
     while (it != service_handles_.end()) {
@@ -342,7 +342,7 @@ public:
   }
 
   virtual void
-  get_next_client(executor::AnyExecutable & any_exec, const WeakNodeList & weak_nodes)
+  get_next_client(executor::AnyExecutable & any_exec, const WeakNodeVector & weak_nodes)
   {
     auto it = client_handles_.begin();
     while (it != client_handles_.end()) {
@@ -375,7 +375,7 @@ public:
   }
 
   virtual void
-  get_next_waitable(executor::AnyExecutable & any_exec, const WeakNodeList & weak_nodes)
+  get_next_waitable(executor::AnyExecutable & any_exec, const WeakNodeVector & weak_nodes)
   {
     auto it = waitable_handles_.begin();
     while (it != waitable_handles_.end()) {

rclcpp/include/rclcpp/subscription.hpp

@@ -178,11 +178,10 @@ public:
         intra_process_subscription_id_,
         msg);
       if (!msg) {
-        // This can happen when having two nodes in different process both using intraprocess
-        // communication. It could happen too if the publisher no longer exists or the requested
-        // message is not longer being stored.
-        // TODO(ivanpauno): Print a warn message in the last two cases described above,
-        // but not in the first one.
+        // This either occurred because the publisher no longer exists or the
+        // message requested is no longer being stored.
+        RCLCPP_WARN(get_logger("rclcpp"),
+          "Intra process message not longer being stored when trying to handle it");
         return;
       }
       any_callback_.dispatch_intra_process(msg, message_info);
@@ -194,11 +193,10 @@ public:
         intra_process_subscription_id_,
         msg);
       if (!msg) {
-        // This can happen when having two nodes in different process both using intraprocess
-        // communication. It could happen too if the publisher no longer exists or the requested
-        // message is not longer being stored.
-        // TODO(ivanpauno): Print a warn message in the last two cases described above,
-        // but not in the first one.
+        // This either occurred because the publisher no longer exists or the
+        // message requested is no longer being stored.
+        RCLCPP_WARN(get_logger("rclcpp"),
+          "Intra process message not longer being stored when trying to handle it");
         return;
       }
       any_callback_.dispatch_intra_process(std::move(msg), message_info);

rclcpp/include/rclcpp/time_source.hpp

@@ -25,6 +25,8 @@
 #include "rcl_interfaces/msg/parameter_event.hpp"
 
 #include "rclcpp/node.hpp"
+#include "rclcpp/parameter_client.hpp"
+#include "rclcpp/parameter_events_filter.hpp"
 
 
 namespace rclcpp
@@ -98,6 +100,9 @@ private:
   // Destroy the subscription for the clock topic
   void destroy_clock_sub();
 
+  // Parameter Client pointer
+  std::shared_ptr<rclcpp::AsyncParametersClient> parameter_client_;
+
   // Parameter Event subscription
   using ParamMessageT = rcl_interfaces::msg::ParameterEvent;
   using ParamSubscriptionT = rclcpp::Subscription<ParamMessageT, Alloc>;

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>0.7.5</version>
+  <version>0.7.2</version>
   <description>The ROS client library in C++.</description>
   <maintainer email="dthomas@osrfoundation.org">Dirk Thomas</maintainer>
   <license>Apache License 2.0</license>

rclcpp/resource/interface_traits.hpp.em

@@ -0,0 +1,77 @@
+// Copyright 2019 Open Source Robotics Foundation, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef RCLCPP__NODE_INTERFACES__INTERFACE_TRAITS_HPP_
+#define RCLCPP__NODE_INTERFACES__INTERFACE_TRAITS_HPP_
+
+#include <functional>
+#include <type_traits>
+
+@{
+node_interfaces = [
+  'node_base_interface',
+  'node_clock_interface',
+  'node_graph_interface',
+  'node_logging_interface',
+  'node_parameters_interface',
+  'node_services_interface',
+  'node_time_source_interface',
+  'node_timers_interface',
+  'node_topics_interface',
+  'node_waitables_interface',
+]
+
+node_interface_types = [
+  'NodeBaseInterface',
+  'NodeClockInterface',
+  'NodeGraphInterface',
+  'NodeLoggingInterface',
+  'NodeParametersInterface',
+  'NodeServicesInterface',
+  'NodeTimeSourceInterface',
+  'NodeTimersInterface',
+  'NodeTopicsInterface',
+  'NodeWaitablesInterface',
+]
+
+assert (len(node_interfaces) == len(node_interface_types))
+}@
+
+@[for interface_ in node_interfaces]@
+#include "rclcpp/node_interfaces/@(interface_).hpp"
+@[end for]@
+
+namespace rclcpp
+{
+namespace node_interfaces
+{
+
+@[for (interface_, type_) in zip(node_interfaces, node_interface_types)]@
+using @(interface_)_getter_t = std::shared_ptr<rclcpp::node_interfaces::@(type_)>;
+
+template<class T, typename = void>
+struct has_@(interface_) : std::false_type
+{};
+
+template<class T>
+struct has_@(interface_)<
+  T, typename std::enable_if<
+    std::is_same<
+      @(interface_)_getter_t, decltype(std::declval<T>().get_@(interface_)())>::value>::type> : std::true_type
+{};
+
+@[end for]@
+}  // namespace node_interfaces
+}  // namespace rclcpp
+#endif  // RCLCPP__NODE_INTERFACES__INTERFACE_TRAITS_HPP_

rclcpp/src/rclcpp/executor.cpp

@@ -91,10 +91,6 @@ Executor::~Executor()
     }
   }
   weak_nodes_.clear();
-  for (auto & guard_condition : guard_conditions_) {
-    memory_strategy_->remove_guard_condition(guard_condition);
-  }
-  guard_conditions_.clear();
 
   // Finalize the wait set.
   if (rcl_wait_set_fini(&wait_set_) != RCL_RET_OK) {
@@ -132,7 +128,6 @@ Executor::add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_pt
     }
   }
   weak_nodes_.push_back(node_ptr);
-  guard_conditions_.push_back(node_ptr->get_notify_guard_condition());
   if (notify) {
     // Interrupt waiting to handle new node
     if (rcl_trigger_guard_condition(&interrupt_guard_condition_) != RCL_RET_OK) {
@@ -153,21 +148,17 @@ void
 Executor::remove_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify)
 {
   bool node_removed = false;
-  {
-    auto node_it = weak_nodes_.begin();
-    auto gc_it = guard_conditions_.begin();
-    while (node_it != weak_nodes_.end()) {
-      bool matched = (node_it->lock() == node_ptr);
-      if (matched) {
-        node_it = weak_nodes_.erase(node_it);
-        gc_it = guard_conditions_.erase(gc_it);
-        node_removed = true;
-      } else {
-        ++node_it;
-        ++gc_it;
+  weak_nodes_.erase(
+    std::remove_if(
+      weak_nodes_.begin(), weak_nodes_.end(),
+      [&](rclcpp::node_interfaces::NodeBaseInterface::WeakPtr & i)
+      {
+        bool matched = (i.lock() == node_ptr);
+        node_removed |= matched;
+        return matched;
       }
-    }
-  }
+    )
+  );
   std::atomic_bool & has_executor = node_ptr->get_associated_with_executor_atomic();
   has_executor.store(false);
   if (notify) {
@@ -429,18 +420,15 @@ Executor::wait_for_work(std::chrono::nanoseconds timeout)
 
   // Clean up any invalid nodes, if they were detected
   if (has_invalid_weak_nodes) {
-    auto node_it = weak_nodes_.begin();
-    auto gc_it = guard_conditions_.begin();
-    while (node_it != weak_nodes_.end()) {
-      if (node_it->expired()) {
-        node_it = weak_nodes_.erase(node_it);
-        memory_strategy_->remove_guard_condition(*gc_it);
-        gc_it = guard_conditions_.erase(gc_it);
-      } else {
-        ++node_it;
-        ++gc_it;
-      }
-    }
+    weak_nodes_.erase(
+      remove_if(
+        weak_nodes_.begin(), weak_nodes_.end(),
+        [](rclcpp::node_interfaces::NodeBaseInterface::WeakPtr i)
+        {
+          return i.expired();
+        }
+      )
+    );
   }
   // clear wait set
   if (rcl_wait_set_clear(&wait_set_) != RCL_RET_OK) {

rclcpp/src/rclcpp/memory_strategy.cpp

@@ -20,7 +20,7 @@ using rclcpp::memory_strategy::MemoryStrategy;
 rclcpp::SubscriptionBase::SharedPtr
 MemoryStrategy::get_subscription_by_handle(
   std::shared_ptr<const rcl_subscription_t> subscriber_handle,
-  const WeakNodeList & weak_nodes)
+  const WeakNodeVector & weak_nodes)
 {
   for (auto & weak_node : weak_nodes) {
     auto node = weak_node.lock();
@@ -51,7 +51,7 @@ MemoryStrategy::get_subscription_by_handle(
 rclcpp::ServiceBase::SharedPtr
 MemoryStrategy::get_service_by_handle(
   std::shared_ptr<const rcl_service_t> service_handle,
-  const WeakNodeList & weak_nodes)
+  const WeakNodeVector & weak_nodes)
 {
   for (auto & weak_node : weak_nodes) {
     auto node = weak_node.lock();
@@ -77,7 +77,7 @@ MemoryStrategy::get_service_by_handle(
 rclcpp::ClientBase::SharedPtr
 MemoryStrategy::get_client_by_handle(
   std::shared_ptr<const rcl_client_t> client_handle,
-  const WeakNodeList & weak_nodes)
+  const WeakNodeVector & weak_nodes)
 {
   for (auto & weak_node : weak_nodes) {
     auto node = weak_node.lock();
@@ -103,7 +103,7 @@ MemoryStrategy::get_client_by_handle(
 rclcpp::node_interfaces::NodeBaseInterface::SharedPtr
 MemoryStrategy::get_node_by_group(
   rclcpp::callback_group::CallbackGroup::SharedPtr group,
-  const WeakNodeList & weak_nodes)
+  const WeakNodeVector & weak_nodes)
 {
   if (!group) {
     return nullptr;
@@ -126,7 +126,7 @@ MemoryStrategy::get_node_by_group(
 rclcpp::callback_group::CallbackGroup::SharedPtr
 MemoryStrategy::get_group_by_subscription(
   rclcpp::SubscriptionBase::SharedPtr subscription,
-  const WeakNodeList & weak_nodes)
+  const WeakNodeVector & weak_nodes)
 {
   for (auto & weak_node : weak_nodes) {
     auto node = weak_node.lock();
@@ -152,7 +152,7 @@ MemoryStrategy::get_group_by_subscription(
 rclcpp::callback_group::CallbackGroup::SharedPtr
 MemoryStrategy::get_group_by_service(
   rclcpp::ServiceBase::SharedPtr service,
-  const WeakNodeList & weak_nodes)
+  const WeakNodeVector & weak_nodes)
 {
   for (auto & weak_node : weak_nodes) {
     auto node = weak_node.lock();
@@ -178,7 +178,7 @@ MemoryStrategy::get_group_by_service(
 rclcpp::callback_group::CallbackGroup::SharedPtr
 MemoryStrategy::get_group_by_client(
   rclcpp::ClientBase::SharedPtr client,
-  const WeakNodeList & weak_nodes)
+  const WeakNodeVector & weak_nodes)
 {
   for (auto & weak_node : weak_nodes) {
     auto node = weak_node.lock();
@@ -204,7 +204,7 @@ MemoryStrategy::get_group_by_client(
 rclcpp::callback_group::CallbackGroup::SharedPtr
 MemoryStrategy::get_group_by_waitable(
   rclcpp::Waitable::SharedPtr waitable,
-  const WeakNodeList & weak_nodes)
+  const WeakNodeVector & weak_nodes)
 {
   for (auto & weak_node : weak_nodes) {
     auto node = weak_node.lock();

rclcpp/src/rclcpp/node.cpp

@@ -132,13 +132,13 @@ Node::Node(
       node_topics_,
       node_services_,
       node_clock_,
-      options.parameter_overrides(),
+      options.initial_parameters(),
       options.start_parameter_services(),
       options.start_parameter_event_publisher(),
       options.parameter_event_qos(),
       options.parameter_event_publisher_options(),
       options.allow_undeclared_parameters(),
-      options.automatically_declare_parameters_from_overrides()
+      options.automatically_declare_initial_parameters()
     )),
   node_time_source_(new rclcpp::node_interfaces::NodeTimeSource(
       node_base_,

rclcpp/src/rclcpp/node_interfaces/node_parameters.cpp

@@ -26,9 +26,6 @@
 
 #include <rcl_yaml_param_parser/parser.h>
 
-#include <cmath>
-#include <cstdlib>
-#include <limits>
 #include <map>
 #include <memory>
 #include <sstream>
@@ -51,13 +48,13 @@ NodeParameters::NodeParameters(
   rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr node_topics,
   const rclcpp::node_interfaces::NodeServicesInterface::SharedPtr node_services,
   const rclcpp::node_interfaces::NodeClockInterface::SharedPtr node_clock,
-  const std::vector<rclcpp::Parameter> & parameter_overrides,
+  const std::vector<rclcpp::Parameter> & initial_parameters,
   bool start_parameter_services,
   bool start_parameter_event_publisher,
   const rclcpp::QoS & parameter_event_qos,
   const rclcpp::PublisherOptionsBase & parameter_event_publisher_options,
   bool allow_undeclared_parameters,
-  bool automatically_declare_parameters_from_overrides)
+  bool automatically_declare_initial_parameters)
 : allow_undeclared_(allow_undeclared_parameters),
   events_publisher_(nullptr),
   node_logging_(node_logging),
@@ -151,21 +148,21 @@ NodeParameters::NodeParameters(
 
     // Combine parameter yaml files, overwriting values in older ones
     for (auto & param : iter->second) {
-      parameter_overrides_[param.get_name()] =
+      initial_parameter_values_[param.get_name()] =
         rclcpp::ParameterValue(param.get_value_message());
     }
   }
 
-  // parameter overrides passed to constructor will overwrite overrides from yaml file sources
-  for (auto & param : parameter_overrides) {
-    parameter_overrides_[param.get_name()] =
+  // initial values passed to constructor overwrite yaml file sources
+  for (auto & param : initial_parameters) {
+    initial_parameter_values_[param.get_name()] =
       rclcpp::ParameterValue(param.get_value_message());
   }
 
   // If asked, initialize any parameters that ended up in the initial parameter values,
   // but did not get declared explcitily by this point.
-  if (automatically_declare_parameters_from_overrides) {
-    for (const auto & pair : this->get_parameter_overrides()) {
+  if (automatically_declare_initial_parameters) {
+    for (const auto & pair : this->get_initial_parameter_values()) {
       if (!this->has_parameter(pair.first)) {
         this->declare_parameter(
           pair.first,
@@ -188,103 +185,6 @@ __lockless_has_parameter(
   return parameters.find(name) != parameters.end();
 }
 
-// see https://en.cppreference.com/w/cpp/types/numeric_limits/epsilon
-RCLCPP_LOCAL
-bool
-__are_doubles_equal(double x, double y, size_t ulp = 100)
-{
-  return std::abs(x - y) <= std::numeric_limits<double>::epsilon() * std::abs(x + y) * ulp;
-}
-
-RCLCPP_LOCAL
-inline
-void
-format_reason(std::string & reason, const std::string & name, const char * range_type)
-{
-  std::ostringstream ss;
-  ss << "Parameter {" << name << "} doesn't comply with " << range_type << " range.";
-  reason = ss.str();
-}
-
-RCLCPP_LOCAL
-rcl_interfaces::msg::SetParametersResult
-__check_parameter_value_in_range(
-  const rcl_interfaces::msg::ParameterDescriptor & descriptor,
-  const rclcpp::ParameterValue & value)
-{
-  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;
-    }
-    if ((v < integer_range.from_value) || (v > integer_range.to_value)) {
-      result.successful = false;
-      format_reason(result.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;
-    format_reason(result.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;
-      format_reason(result.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;
-    format_reason(result.reason, descriptor.name, "floating point");
-    return result;
-  }
-  return result;
-}
-
-// Return true if parameter values comply with the descriptors in parameter_infos.
-RCLCPP_LOCAL
-rcl_interfaces::msg::SetParametersResult
-__check_parameters(
-  std::map<std::string, rclcpp::node_interfaces::ParameterInfo> & parameter_infos,
-  const std::vector<rclcpp::Parameter> & parameters)
-{
-  rcl_interfaces::msg::SetParametersResult result;
-  result.successful = true;
-  for (const rclcpp::Parameter & parameter : parameters) {
-    const rcl_interfaces::msg::ParameterDescriptor & descriptor =
-      parameter_infos[parameter.get_name()].descriptor;
-    result = __check_parameter_value_in_range(
-      descriptor,
-      parameter.get_parameter_value());
-    if (!result.successful) {
-      break;
-    }
-  }
-  return result;
-}
-
 using OnParametersSetCallbackType =
   rclcpp::node_interfaces::NodeParametersInterface::OnParametersSetCallbackType;
 
@@ -301,14 +201,7 @@ __set_parameters_atomically_common(
   if (on_set_parameters_callback) {
     result = on_set_parameters_callback(parameters);
   }
-  if (!result.successful) {
-    return result;
-  }
-  // Check if the value being set complies with the descriptor.
-  result = __check_parameters(parameter_infos, parameters);
-  if (!result.successful) {
-    return result;
-  }
+
   // If accepted, actually set the values.
   if (result.successful) {
     for (size_t i = 0; i < parameters.size(); ++i) {
@@ -389,7 +282,7 @@ NodeParameters::declare_parameter(
     default_value,
     parameter_descriptor,
     parameters_,
-    parameter_overrides_,
+    initial_parameter_values_,
     on_parameters_set_callback_,
     &parameter_event);
 
@@ -520,7 +413,7 @@ NodeParameters::set_parameters_atomically(const std::vector<rclcpp::Parameter> &
       parameter_to_be_declared->get_parameter_value(),
       rcl_interfaces::msg::ParameterDescriptor(),  // Implicit declare uses default descriptor.
       staged_parameter_changes,
-      parameter_overrides_,
+      initial_parameter_values_,
       nullptr,  // callback is explicitly null, so that it is called only once, when setting below.
       &parameter_event_msg);
     if (!result.successful) {
@@ -600,10 +493,10 @@ NodeParameters::set_parameters_atomically(const std::vector<rclcpp::Parameter> &
     // assumption: the parameter to be undeclared should be in the parameter infos map
     assert(it != parameters_.end());
     if (it != parameters_.end()) {
-      // Update the parameter event message and remove it.
+      // Remove it and update the parameter event message.
+      parameters_.erase(it);
       parameter_event_msg.deleted_parameters.push_back(
         rclcpp::Parameter(it->first, it->second.value).to_parameter_msg());
-      parameters_.erase(it);
     }
   }
 
@@ -840,7 +733,7 @@ NodeParameters::register_param_change_callback(ParametersCallbackFunction callba
 #endif
 
 const std::map<std::string, rclcpp::ParameterValue> &
-NodeParameters::get_parameter_overrides() const
+NodeParameters::get_initial_parameter_values() const
 {
-  return parameter_overrides_;
+  return initial_parameter_values_;
 }

rclcpp/src/rclcpp/node_interfaces/node_topics.cpp

@@ -47,14 +47,6 @@ NodeTopics::create_publisher(
     // Get the intra process manager instance for this context.
     auto ipm = context->get_sub_context<rclcpp::intra_process_manager::IntraProcessManager>();
     // Register the publisher with the intra process manager.
-    if (publisher_options.qos.history == RMW_QOS_POLICY_HISTORY_KEEP_ALL) {
-      throw std::invalid_argument(
-              "intraprocess communication is not allowed with keep all history qos policy");
-    }
-    if (publisher_options.qos.depth == 0) {
-      throw std::invalid_argument(
-              "intraprocess communication is not allowed with a zero qos history depth value");
-    }
     uint64_t intra_process_publisher_id = ipm->add_publisher(publisher);
     publisher->setup_intra_process(
       intra_process_publisher_id,

rclcpp/src/rclcpp/node_options.cpp

@@ -44,9 +44,6 @@ rcl_node_options_t_destructor(rcl_node_options_t * node_options)
         "failed to finalize rcl node options: %s", rcl_get_error_string().str);
       rcl_reset_error();
     }
-
-    delete node_options;
-    node_options = nullptr;
   }
 }
 }  // namespace detail
@@ -67,14 +64,14 @@ NodeOptions::operator=(const NodeOptions & other)
   if (this != &other) {
     this->context_ = other.context_;
     this->arguments_ = other.arguments_;
-    this->parameter_overrides_ = other.parameter_overrides_;
+    this->initial_parameters_ = other.initial_parameters_;
     this->use_global_arguments_ = other.use_global_arguments_;
     this->use_intra_process_comms_ = other.use_intra_process_comms_;
     this->start_parameter_services_ = other.start_parameter_services_;
     this->allocator_ = other.allocator_;
     this->allow_undeclared_parameters_ = other.allow_undeclared_parameters_;
-    this->automatically_declare_parameters_from_overrides_ =
-      other.automatically_declare_parameters_from_overrides_;
+    this->automatically_declare_initial_parameters_ =
+      other.automatically_declare_initial_parameters_;
   }
   return *this;
 }
@@ -142,21 +139,21 @@ NodeOptions::arguments(const std::vector<std::string> & arguments)
 }
 
 std::vector<rclcpp::Parameter> &
-NodeOptions::parameter_overrides()
+NodeOptions::initial_parameters()
 {
-  return this->parameter_overrides_;
+  return this->initial_parameters_;
 }
 
 const std::vector<rclcpp::Parameter> &
-NodeOptions::parameter_overrides() const
+NodeOptions::initial_parameters() const
 {
-  return this->parameter_overrides_;
+  return this->initial_parameters_;
 }
 
 NodeOptions &
-NodeOptions::parameter_overrides(const std::vector<rclcpp::Parameter> & parameter_overrides)
+NodeOptions::initial_parameters(const std::vector<rclcpp::Parameter> & initial_parameters)
 {
-  this->parameter_overrides_ = parameter_overrides;
+  this->initial_parameters_ = initial_parameters;
   return *this;
 }
 
@@ -254,17 +251,16 @@ NodeOptions::allow_undeclared_parameters(bool allow_undeclared_parameters)
 }
 
 bool
-NodeOptions::automatically_declare_parameters_from_overrides() const
+NodeOptions::automatically_declare_initial_parameters() const
 {
-  return this->automatically_declare_parameters_from_overrides_;
+  return this->automatically_declare_initial_parameters_;
 }
 
 NodeOptions &
-NodeOptions::automatically_declare_parameters_from_overrides(
-  bool automatically_declare_parameters_from_overrides)
+NodeOptions::automatically_declare_initial_parameters(
+  bool automatically_declare_initial_parameters)
 {
-  this->automatically_declare_parameters_from_overrides_ =
-    automatically_declare_parameters_from_overrides;
+  this->automatically_declare_initial_parameters_ = automatically_declare_initial_parameters;
   return *this;
 }
 

rclcpp/src/rclcpp/parameter_service.cpp

@@ -57,15 +57,11 @@ ParameterService::ParameterService(
       const std::shared_ptr<rcl_interfaces::srv::GetParameterTypes::Request> request,
       std::shared_ptr<rcl_interfaces::srv::GetParameterTypes::Response> response)
     {
-      try {
-        auto types = node_params->get_parameter_types(request->names);
-        std::transform(types.cbegin(), types.cend(),
-        std::back_inserter(response->types), [](const uint8_t & type) {
-          return static_cast<rclcpp::ParameterType>(type);
-        });
-      } catch (const rclcpp::exceptions::ParameterNotDeclaredException & ex) {
-        RCLCPP_WARN(rclcpp::get_logger("rclcpp"), "Failed to get parameter types: %s", ex.what());
-      }
+      auto types = node_params->get_parameter_types(request->names);
+      std::transform(types.cbegin(), types.cend(),
+      std::back_inserter(response->types), [](const uint8_t & type) {
+        return static_cast<rclcpp::ParameterType>(type);
+      });
     },
     qos_profile, nullptr);
 
@@ -77,20 +73,12 @@ ParameterService::ParameterService(
       const std::shared_ptr<rcl_interfaces::srv::SetParameters::Request> request,
       std::shared_ptr<rcl_interfaces::srv::SetParameters::Response> response)
     {
-      // Set parameters one-by-one, since there's no way to return a partial result if
-      // set_parameters() fails.
-      auto result = rcl_interfaces::msg::SetParametersResult();
+      std::vector<rclcpp::Parameter> pvariants;
       for (auto & p : request->parameters) {
-        try {
-          result = node_params->set_parameters_atomically(
-            {rclcpp::Parameter::from_parameter_msg(p)});
-        } catch (const rclcpp::exceptions::ParameterNotDeclaredException & ex) {
-          RCLCPP_WARN(rclcpp::get_logger("rclcpp"), "Failed to set parameter: %s", ex.what());
-          result.successful = false;
-          result.reason = ex.what();
-        }
-        response->results.push_back(result);
+        pvariants.push_back(rclcpp::Parameter::from_parameter_msg(p));
       }
+      auto results = node_params->set_parameters(pvariants);
+      response->results = results;
     },
     qos_profile, nullptr);
 
@@ -108,15 +96,8 @@ ParameterService::ParameterService(
       [](const rcl_interfaces::msg::Parameter & p) {
         return rclcpp::Parameter::from_parameter_msg(p);
       });
-      try {
-        auto result = node_params->set_parameters_atomically(pvariants);
-        response->result = result;
-      } catch (const rclcpp::exceptions::ParameterNotDeclaredException & ex) {
-        RCLCPP_WARN(
-          rclcpp::get_logger("rclcpp"), "Failed to set parameters atomically: %s", ex.what());
-        response->result.successful = false;
-        response->result.reason = "One or more parameters wer not declared before setting";
-      }
+      auto result = node_params->set_parameters_atomically(pvariants);
+      response->result = result;
     },
     qos_profile, nullptr);
 
@@ -128,12 +109,8 @@ ParameterService::ParameterService(
       const std::shared_ptr<rcl_interfaces::srv::DescribeParameters::Request> request,
       std::shared_ptr<rcl_interfaces::srv::DescribeParameters::Response> response)
     {
-      try {
-        auto descriptors = node_params->describe_parameters(request->names);
-        response->descriptors = descriptors;
-      } catch (const rclcpp::exceptions::ParameterNotDeclaredException & ex) {
-        RCLCPP_WARN(rclcpp::get_logger("rclcpp"), "Failed to describe parameters: %s", ex.what());
-      }
+      auto descriptors = node_params->describe_parameters(request->names);
+      response->descriptors = descriptors;
     },
     qos_profile, nullptr);
 

rclcpp/src/rclcpp/publisher_base.cpp

@@ -265,7 +265,7 @@ PublisherBase::setup_intra_process(
 {
   // Intraprocess configuration is not allowed with "durability" qos policy non "volatile".
   if (this->get_actual_qos().durability != RMW_QOS_POLICY_DURABILITY_VOLATILE) {
-    throw std::invalid_argument(
+    throw exceptions::InvalidParametersException(
             "intraprocess communication is not allowed with durability qos policy non-volatile");
   }
   const char * topic_name = this->get_topic_name();

rclcpp/src/rclcpp/qos.cpp

@@ -120,7 +120,7 @@ QoS::durability(rmw_qos_durability_policy_t durability)
 }
 
 QoS &
-QoS::durability_volatile()
+QoS::volitile()
 {
   return this->durability(RMW_QOS_POLICY_DURABILITY_VOLATILE);
 }

rclcpp/src/rclcpp/signal_handler.cpp

@@ -165,15 +165,13 @@ __safe_strerror(int errnum, char * buffer, size_t buffer_length)
 {
 #if defined(_WIN32)
   strerror_s(buffer, buffer_length, errnum);
-#elif defined(_GNU_SOURCE) && (!defined(ANDROID) || __ANDROID_API__ >= 23)
-  /* GNU-specific */
+#elif (defined(_GNU_SOURCE) && !defined(ANDROID))
   char * msg = strerror_r(errnum, buffer, buffer_length);
   if (msg != buffer) {
     strncpy(buffer, msg, buffer_length);
     buffer[buffer_length - 1] = '\0';
   }
 #else
-  /* XSI-compliant */
   int error_status = strerror_r(errnum, buffer, buffer_length);
   if (error_status != 0) {
     throw std::runtime_error("Failed to get error string for errno: " + std::to_string(errnum));

rclcpp/src/rclcpp/time_source.cpp

@@ -25,8 +25,6 @@
 #include "rclcpp/exceptions.hpp"
 #include "rclcpp/logging.hpp"
 #include "rclcpp/node.hpp"
-#include "rclcpp/parameter_client.hpp"
-#include "rclcpp/parameter_events_filter.hpp"
 #include "rclcpp/time.hpp"
 #include "rclcpp/time_source.hpp"
 
@@ -105,16 +103,22 @@ void TimeSource::attachNode(
   }
 
   // TODO(tfoote) use parameters interface not subscribe to events via topic ticketed #609
-  parameter_subscription_ = rclcpp::AsyncParametersClient::on_parameter_event(
+  parameter_client_ = std::make_shared<rclcpp::AsyncParametersClient>(
+    node_base_,
     node_topics_,
-    std::bind(&TimeSource::on_parameter_event, this, std::placeholders::_1));
+    node_graph_,
+    node_services_
+  );
+  parameter_subscription_ =
+    parameter_client_->on_parameter_event(std::bind(&TimeSource::on_parameter_event,
+      this, std::placeholders::_1));
 }
 
 void TimeSource::detachNode()
 {
   this->ros_time_active_ = false;
   clock_subscription_.reset();
-  parameter_subscription_.reset();
+  parameter_client_.reset();
   node_base_.reset();
   node_topics_.reset();
   node_graph_.reset();

rclcpp/test/test_executor.cpp

@@ -60,10 +60,3 @@ TEST_F(TestExecutors, detachOnDestruction) {
     EXPECT_NO_THROW(executor.add_node(node));
   }
 }
-
-// Make sure that the executor can automatically remove expired nodes correctly
-TEST_F(TestExecutors, addTemporaryNode) {
-  rclcpp::executors::SingleThreadedExecutor executor;
-  executor.add_node(std::make_shared<rclcpp::Node>("temporary_node"));
-  EXPECT_NO_THROW(executor.spin_some());
-}

rclcpp/test/test_find_weak_nodes.cpp

@@ -36,15 +36,15 @@ TEST_F(TestFindWeakNodes, allocator_strategy_with_weak_nodes) {
     rclcpp::memory_strategies::allocator_memory_strategy::AllocatorMemoryStrategy<>>();
   auto existing_node = rclcpp::Node::make_shared("existing_node");
   auto dead_node = rclcpp::Node::make_shared("dead_node");
-  rclcpp::memory_strategy::MemoryStrategy::WeakNodeList weak_nodes;
+  rclcpp::memory_strategy::MemoryStrategy::WeakNodeVector weak_nodes;
   weak_nodes.push_back(existing_node->get_node_base_interface());
   weak_nodes.push_back(dead_node->get_node_base_interface());
 
   // AND
   // Delete dead_node, creating a dangling pointer in weak_nodes
   dead_node.reset();
-  ASSERT_FALSE(weak_nodes.front().expired());
-  ASSERT_TRUE(weak_nodes.back().expired());
+  ASSERT_FALSE(weak_nodes[0].expired());
+  ASSERT_TRUE(weak_nodes[1].expired());
 
   // WHEN
   bool has_invalid_weak_nodes = memory_strategy->collect_entities(weak_nodes);
@@ -64,11 +64,11 @@ TEST_F(TestFindWeakNodes, allocator_strategy_no_weak_nodes) {
     rclcpp::memory_strategies::allocator_memory_strategy::AllocatorMemoryStrategy<>>();
   auto existing_node1 = rclcpp::Node::make_shared("existing_node1");
   auto existing_node2 = rclcpp::Node::make_shared("existing_node2");
-  rclcpp::memory_strategy::MemoryStrategy::WeakNodeList weak_nodes;
+  rclcpp::memory_strategy::MemoryStrategy::WeakNodeVector weak_nodes;
   weak_nodes.push_back(existing_node1->get_node_base_interface());
   weak_nodes.push_back(existing_node2->get_node_base_interface());
-  ASSERT_FALSE(weak_nodes.front().expired());
-  ASSERT_FALSE(weak_nodes.back().expired());
+  ASSERT_FALSE(weak_nodes[0].expired());
+  ASSERT_FALSE(weak_nodes[1].expired());
 
   // WHEN
   bool has_invalid_weak_nodes = memory_strategy->collect_entities(weak_nodes);

rclcpp/test/test_interface_traits.cpp

@@ -0,0 +1,51 @@
+// Copyright 2019 Open Source Robotics Foundation, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <gtest/gtest.h>
+
+#include "rclcpp/node_interfaces/interface_traits.hpp"
+#include "rclcpp/node_interfaces/node_base.hpp"
+#include "rclcpp/node.hpp"
+
+class MyNode
+{
+public:
+  std::shared_ptr<rclcpp::node_interfaces::NodeBaseInterface> get_node_base_interface() const
+  {
+    return std::make_shared<rclcpp::node_interfaces::NodeBase>("my_node_name", "my_node_namespace", nullptr, rclcpp::NodeOptions());
+  }
+};
+
+class WrongNode
+{
+public:
+  std::shared_ptr<rclcpp::node_interfaces::NodeBaseInterface> not_get_node_base_interface()
+  {
+    return nullptr;
+  }
+};
+
+template<class T, typename std::enable_if<rclcpp::node_interfaces::has_node_base_interface<T>::value>::type* = nullptr>
+void get_node_name(const T & nodelike) {
+  ASSERT_STREQ("my_node_name", nodelike.get_node_base_interface()->get_name());
+}
+
+TEST(TestInterfaceTraits, has_node_base_interface) {
+  ASSERT_TRUE(rclcpp::node_interfaces::has_node_base_interface<MyNode>::value);
+  ASSERT_FALSE(rclcpp::node_interfaces::has_node_base_interface<WrongNode>::value);
+  ASSERT_TRUE(rclcpp::node_interfaces::has_node_base_interface<rclcpp::Node>::value);
+
+  get_node_name(MyNode());
+}
+

rclcpp/test/test_intra_process_manager.cpp

@@ -37,9 +37,6 @@ public:
   PublisherBase()
   : mock_topic_name(""), mock_queue_size(0) {}
 
-  virtual ~PublisherBase()
-  {}
-
   const char * get_topic_name() const
   {
     return mock_topic_name.c_str();

rclcpp/test/test_node.cpp

@@ -365,10 +365,8 @@ TEST_F(TestNode, declare_parameter_with_no_initial_values) {
 TEST_F(TestNode, declare_parameter_with_initial_values) {
   // test cases with initial values
   rclcpp::NodeOptions no;
-  no.parameter_overrides({
+  no.initial_parameters({
     {"parameter_no_default", 42},
-    {"parameter_no_default_set", 42},
-    {"parameter_no_default_set_cvref", 42},
     {"parameter_and_default", 42},
     {"parameter_custom", 42},
     {"parameter_template", 42},
@@ -383,25 +381,6 @@ TEST_F(TestNode, declare_parameter_with_initial_values) {
     EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);
     EXPECT_EQ(value.get<int>(), 42);
   }
-  {
-    // no default, with initial, and set after
-    rclcpp::ParameterValue value = node->declare_parameter("parameter_no_default_set");
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);
-    EXPECT_EQ(value.get<int>(), 42);
-    // check that the value is changed after a set
-    node->set_parameter({"parameter_no_default_set", 44});
-    EXPECT_EQ(node->get_parameter("parameter_no_default_set").get_value<int>(), 44);
-  }
-  {
-    // no default, with initial
-    const rclcpp::ParameterValue & value =
-      node->declare_parameter("parameter_no_default_set_cvref");
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);
-    EXPECT_EQ(value.get<int>(), 42);
-    // check that the value is changed after a set
-    node->set_parameter({"parameter_no_default_set_cvref", 44});
-    EXPECT_EQ(value.get<int>(), 44);
-  }
   {
     // int default, with initial
     rclcpp::ParameterValue default_value(43);
@@ -716,353 +695,6 @@ TEST_F(TestNode, set_parameter_undeclared_parameters_not_allowed) {
 
     EXPECT_FALSE(node->has_parameter(name));
   }
-  {
-    // setting a 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, 10, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);
-    EXPECT_EQ(value.get_value<int64_t>(), 10);
-
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 14)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 14);
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 18)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 15)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 20)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 8)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-  }
-  {
-    // setting a 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, 20, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);
-    EXPECT_EQ(value.get_value<int64_t>(), 20);
-
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 18)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 19)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 10)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 25)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-  }
-  {
-    // setting a 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, 18, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);
-    EXPECT_EQ(value.get_value<int64_t>(), 18);
-
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 17)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 19)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-  }
-  {
-    // setting a 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, 18, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);
-    EXPECT_EQ(value.get_value<int64_t>(), 18);
-
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 25)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 25);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 17)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 25);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 19)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 25);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 26)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 25);
-  }
-  {
-    // setting a 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, 18, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);
-    EXPECT_EQ(value.get_value<int64_t>(), 18);
-
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 28)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 28);
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 25)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 25);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 17)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 25);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 19)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 25);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 32)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 25);
-  }
-  {
-    // setting a 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, 10, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);
-    EXPECT_EQ(value.get_value<int64_t>(), 10);
-
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 11)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 11);
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 15)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 15);
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 18)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 9)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 19)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<int64_t>(), 18);
-  }
-  {
-    // setting a 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, 42, descriptor),
-      rclcpp::exceptions::InvalidParameterValueException);
-  }
-  {
-    // setting a 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, 10.0, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE);
-    EXPECT_EQ(value.get_value<double>(), 10.0);
-
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 10.2)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 10.2);
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 11.0)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 11.3)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 12.0)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 9.4)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-  }
-  {
-    // setting a 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, 10.0, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE);
-    EXPECT_EQ(value.get_value<double>(), 10.0);
-
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 10.2)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 10.2);
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 11.0)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 11.3)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 12.0)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 9.4)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-  }
-  {
-    // setting a 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, 10.0, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE);
-    EXPECT_EQ(value.get_value<double>(), 10.0);
-
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 11.0)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 11.2)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 12.0)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 9.4)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-  }
-  {
-    // setting a 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, 10.0, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE);
-    EXPECT_EQ(value.get_value<double>(), 10.0);
-
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 11.2)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 10.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 12.0)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 10.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 9.4)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 10.0);
-  }
-  {
-    // setting a 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, 10.0, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE);
-    EXPECT_EQ(value.get_value<double>(), 10.0);
-
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 11.0)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 12.2)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 7.8)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-  }
-  {
-    // setting a 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, 10.0, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE);
-    EXPECT_EQ(value.get_value<double>(), 10.0);
-
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 11.0)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 10.7)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 10.7);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 11.4)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 10.7);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 9.3)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 10.7);
-  }
-  {
-    // setting a 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, 10.0, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE);
-    EXPECT_EQ(value.get_value<double>(), 10.0);
-
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 10.0001)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 10.0001);
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 10.5479051)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 10.5479051);
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 11.0)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 11.001)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 11.0);
-    EXPECT_FALSE(node->set_parameter(rclcpp::Parameter(name, 9.999)).successful);
-    EXPECT_EQ(node->get_parameter(name).get_value<double>(), 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).
-    auto name = "parameter"_unq;
-    rcl_interfaces::msg::ParameterDescriptor descriptor;
-    descriptor.type = rclcpp::PARAMETER_INTEGER;
-    node->declare_parameter(name, 42, descriptor);
-    EXPECT_TRUE(node->has_parameter(name));
-    auto value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);
-    EXPECT_EQ(value.get_value<int64_t>(), 42);
-
-    EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, "asd")).successful);
-    EXPECT_TRUE(node->has_parameter(name));
-    value = node->get_parameter(name);
-    EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_STRING);
-    EXPECT_EQ(value.get_value<std::string>(), "asd");
-  }
 }
 
 TEST_F(TestNode, set_parameter_undeclared_parameters_allowed) {

rclcpp/test/test_parameter_client.cpp

@@ -1,155 +0,0 @@
-// Copyright 2019 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <gtest/gtest.h>
-
-#include <string>
-#include <memory>
-
-#include "rclcpp/rclcpp.hpp"
-
-#include "rcl_interfaces/msg/parameter_event.hpp"
-
-class TestParameterClient : public ::testing::Test
-{
-public:
-  void OnMessage(const rcl_interfaces::msg::ParameterEvent::SharedPtr event)
-  {
-    (void)event;
-  }
-
-protected:
-  static void SetUpTestCase()
-  {
-    rclcpp::init(0, nullptr);
-  }
-
-  void SetUp()
-  {
-    node = std::make_shared<rclcpp::Node>("test_parameter_client", "/ns");
-  }
-
-  void TearDown()
-  {
-    node.reset();
-  }
-
-  rclcpp::Node::SharedPtr node;
-};
-
-/*
-   Testing async parameter client construction and destruction.
- */
-TEST_F(TestParameterClient, async_construction_and_destruction) {
-  {
-    auto asynchronous_client = std::make_shared<rclcpp::AsyncParametersClient>(node);
-    (void)asynchronous_client;
-  }
-
-  {
-    auto asynchronous_client = std::make_shared<rclcpp::AsyncParametersClient>(
-      node->get_node_base_interface(),
-      node->get_node_topics_interface(),
-      node->get_node_graph_interface(),
-      node->get_node_services_interface());
-    (void)asynchronous_client;
-  }
-
-  {
-    ASSERT_THROW({
-      std::make_shared<rclcpp::AsyncParametersClient>(node, "invalid_remote_node?");
-    }, rclcpp::exceptions::InvalidServiceNameError);
-  }
-}
-
-/*
-   Testing sync parameter client construction and destruction.
- */
-TEST_F(TestParameterClient, sync_construction_and_destruction) {
-  {
-    auto synchronous_client = std::make_shared<rclcpp::SyncParametersClient>(node);
-    (void)synchronous_client;
-  }
-
-  {
-    auto synchronous_client = std::make_shared<rclcpp::SyncParametersClient>(
-      std::make_shared<rclcpp::executors::SingleThreadedExecutor>(),
-      node);
-    (void)synchronous_client;
-  }
-
-  {
-    auto synchronous_client = std::make_shared<rclcpp::SyncParametersClient>(
-      std::make_shared<rclcpp::executors::SingleThreadedExecutor>(),
-      node->get_node_base_interface(),
-      node->get_node_topics_interface(),
-      node->get_node_graph_interface(),
-      node->get_node_services_interface());
-    (void)synchronous_client;
-  }
-
-  {
-    ASSERT_THROW({
-      std::make_shared<rclcpp::SyncParametersClient>(node, "invalid_remote_node?");
-    }, rclcpp::exceptions::InvalidServiceNameError);
-  }
-}
-
-/*
-   Testing different methods for parameter event subscription from asynchronous clients.
- */
-TEST_F(TestParameterClient, async_parameter_event_subscription) {
-  auto callback = std::bind(&TestParameterClient::OnMessage, this, std::placeholders::_1);
-  {
-    auto asynchronous_client = std::make_shared<rclcpp::AsyncParametersClient>(node);
-    auto event_sub = asynchronous_client->on_parameter_event(callback);
-    (void)event_sub;
-  }
-
-  {
-    auto event_sub = rclcpp::AsyncParametersClient::on_parameter_event(node, callback);
-    (void)event_sub;
-  }
-
-  {
-    auto event_sub = rclcpp::AsyncParametersClient::on_parameter_event(
-      node->get_node_topics_interface(),
-      callback);
-    (void)event_sub;
-  }
-}
-
-/*
-   Testing different methods for parameter event subscription from synchronous clients.
- */
-TEST_F(TestParameterClient, sync_parameter_event_subscription) {
-  auto callback = std::bind(&TestParameterClient::OnMessage, this, std::placeholders::_1);
-  {
-    auto synchronous_client = std::make_shared<rclcpp::SyncParametersClient>(node);
-    auto event_sub = synchronous_client->on_parameter_event(callback);
-    (void)event_sub;
-  }
-
-  {
-    auto event_sub = rclcpp::SyncParametersClient::on_parameter_event(node, callback);
-    (void)event_sub;
-  }
-
-  {
-    auto event_sub = rclcpp::SyncParametersClient::on_parameter_event(
-      node->get_node_topics_interface(),
-      callback);
-    (void)event_sub;
-  }
-}

rclcpp/test/test_publisher.cpp

@@ -16,7 +16,6 @@
 
 #include <string>
 #include <memory>
-#include <vector>
 
 #include "rclcpp/exceptions.hpp"
 #include "rclcpp/rclcpp.hpp"
@@ -25,13 +24,12 @@
 
 class TestPublisher : public ::testing::Test
 {
-public:
+protected:
   static void SetUpTestCase()
   {
     rclcpp::init(0, nullptr);
   }
 
-protected:
   void initialize(const rclcpp::NodeOptions & node_options = rclcpp::NodeOptions())
   {
     node = std::make_shared<rclcpp::Node>("my_node", "/ns", node_options);
@@ -45,25 +43,6 @@ protected:
   rclcpp::Node::SharedPtr node;
 };
 
-struct TestParameters
-{
-  TestParameters(rclcpp::QoS qos, std::string description)
-  : qos(qos), description(description) {}
-  rclcpp::QoS qos;
-  std::string description;
-};
-
-std::ostream & operator<<(std::ostream & out, const TestParameters & params)
-{
-  out << params.description;
-  return out;
-}
-
-class TestPublisherInvalidIntraprocessQos
-  : public TestPublisher,
-  public ::testing::WithParamInterface<TestParameters>
-{};
-
 class TestPublisherSub : public ::testing::Test
 {
 protected:
@@ -86,6 +65,14 @@ protected:
   rclcpp::Node::SharedPtr subnode;
 };
 
+static constexpr rmw_qos_profile_t invalid_qos_profile()
+{
+  rmw_qos_profile_t profile = rmw_qos_profile_default;
+  profile.depth = 1;
+  profile.durability = RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL;
+  return profile;
+}
+
 /*
    Testing publisher construction and destruction.
  */
@@ -178,43 +165,29 @@ TEST_F(TestPublisher, various_creation_signatures) {
 /*
    Testing publisher with intraprocess enabled and invalid QoS
  */
-TEST_P(TestPublisherInvalidIntraprocessQos, test_publisher_throws) {
+TEST_F(TestPublisher, intraprocess_with_invalid_qos) {
   initialize(rclcpp::NodeOptions().use_intra_process_comms(true));
-  rclcpp::QoS qos = GetParam().qos;
+  rmw_qos_profile_t qos = invalid_qos_profile();
   using rcl_interfaces::msg::IntraProcessMessage;
   {
+#if !defined(_WIN32)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#else  // !defined(_WIN32)
+# pragma warning(push)
+# pragma warning(disable: 4996)
+#endif
     ASSERT_THROW(
       {auto publisher = node->create_publisher<IntraProcessMessage>("topic", qos);},
-      std::invalid_argument);
+      rclcpp::exceptions::InvalidParametersException);
+#if !defined(_WIN32)
+# pragma GCC diagnostic pop
+#else  // !defined(_WIN32)
+# pragma warning(pop)
+#endif
   }
 }
 
-static std::vector<TestParameters> invalid_qos_profiles()
-{
-  std::vector<TestParameters> parameters;
-
-  parameters.reserve(3);
-  parameters.push_back(
-    TestParameters(
-      rclcpp::QoS(rclcpp::KeepLast(10)).transient_local(),
-      "transient_local_qos"));
-  parameters.push_back(
-    TestParameters(
-      rclcpp::QoS(rclcpp::KeepLast(0)),
-      "keep_last_qos_with_zero_history_depth"));
-  parameters.push_back(
-    TestParameters(
-      rclcpp::QoS(rclcpp::KeepAll()),
-      "keep_all_qos"));
-
-  return parameters;
-}
-
-INSTANTIATE_TEST_CASE_P(
-  TestPublisherThrows, TestPublisherInvalidIntraprocessQos,
-  ::testing::ValuesIn(invalid_qos_profiles()),
-  ::testing::PrintToStringParamName());
-
 /*
    Testing publisher construction and destruction for subnodes.
  */

rclcpp_action/CHANGELOG.rst

@@ -3,17 +3,6 @@ Changelog for package rclcpp_action
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 
-0.7.5 (2019-05-30)
-------------------
-
-0.7.4 (2019-05-29)
-------------------
-* Guard against calling null goal response callback (`#738 <https://github.com/ros2/rclcpp/issues/738>`_)
-* Contributors: Jacob Perron
-
-0.7.3 (2019-05-20)
-------------------
-
 0.7.2 (2019-05-08)
 ------------------
 * Added return code to CancelGoal service response. (`#710 <https://github.com/ros2/rclcpp/issues/710>`_)

rclcpp_action/include/rclcpp_action/client.hpp

@@ -368,23 +368,21 @@ public:
         // Do not use std::make_shared as friendship cannot be forwarded.
         std::shared_ptr<GoalHandle> goal_handle(
           new GoalHandle(goal_info, options.feedback_callback, options.result_callback));
-        {
-          std::lock_guard<std::mutex> guard(goal_handles_mutex_);
-          goal_handles_[goal_handle->get_goal_id()] = goal_handle;
-        }
-        promise->set_value(goal_handle);
-        if (options.goal_response_callback) {
-          options.goal_response_callback(future);
-        }
-
         if (options.result_callback) {
           try {
             this->make_result_aware(goal_handle);
           } catch (...) {
             promise->set_exception(std::current_exception());
+            options.goal_response_callback(future);
             return;
           }
         }
+        std::lock_guard<std::mutex> guard(goal_handles_mutex_);
+        goal_handles_[goal_handle->get_goal_id()] = goal_handle;
+        promise->set_value(goal_handle);
+        if (options.goal_response_callback) {
+          options.goal_response_callback(future);
+        }
       });
     return future;
   }

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>0.7.5</version>
+  <version>0.7.2</version>
   <description>Adds action APIs for C++.</description>
   <maintainer email="dthomas@osrfoundation.org">Dirk Thomas</maintainer>
   <license>Apache License 2.0</license>

rclcpp_components/CHANGELOG.rst

@@ -2,18 +2,6 @@
 Changelog for package rclcpp_components
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-0.7.5 (2019-05-30)
-------------------
-
-0.7.4 (2019-05-29)
-------------------
-* Rename parameter options (`#745 <https://github.com/ros2/rclcpp/issues/745>`_)
-* don't use global arguments for components loaded into the manager (`#736 <https://github.com/ros2/rclcpp/issues/736>`_)
-* Contributors: Dirk Thomas, William Woodall
-
-0.7.3 (2019-05-20)
-------------------
-
 0.7.2 (2019-05-08)
 ------------------
 * Updated to support changes to ``Node::get_node_names()``. (`#698 <https://github.com/ros2/rclcpp/issues/698>`_)

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>0.7.5</version>
+  <version>0.7.2</version>
   <description>Package containing tools for dynamically loadable components</description>
   <maintainer email="michael@openrobotics.org">Michael Carroll</maintainer>
   <license>Apache License 2.0</license>

rclcpp_components/src/component_manager.cpp

@@ -149,8 +149,7 @@ ComponentManager::OnLoadNode(
       }
 
       auto options = rclcpp::NodeOptions()
-        .use_global_arguments(false)
-        .parameter_overrides(parameters)
+        .initial_parameters(parameters)
         .arguments(remap_rules);
 
       auto node_id = unique_id++;

rclcpp_lifecycle/CHANGELOG.rst

@@ -3,19 +3,6 @@ Changelog for package rclcpp_lifecycle
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 
-0.7.5 (2019-05-30)
-------------------
-
-0.7.4 (2019-05-29)
-------------------
-* Rename parameter options (`#745 <https://github.com/ros2/rclcpp/issues/745>`_)
-* Contributors: William Woodall
-
-0.7.3 (2019-05-20)
-------------------
-* Added missing template functionality to lifecycle_node. (`#707 <https://github.com/ros2/rclcpp/issues/707>`_)
-* Contributors: Michael Jeronimo
-
 0.7.2 (2019-05-08)
 ------------------
 * Added new way to specify QoS settings for publishers and subscriptions. (`#713 <https://github.com/ros2/rclcpp/issues/713>`_)

rclcpp_lifecycle/include/rclcpp_lifecycle/lifecycle_node.hpp

@@ -15,11 +15,10 @@
 #ifndef RCLCPP_LIFECYCLE__LIFECYCLE_NODE_HPP_
 #define RCLCPP_LIFECYCLE__LIFECYCLE_NODE_HPP_
 
-#include <map>
-#include <memory>
 #include <string>
-#include <utility>
+#include <map>
 #include <vector>
+#include <memory>
 
 #include "rcl/error_handling.h"
 #include "rcl/node.h"
@@ -334,100 +333,15 @@ public:
     const rmw_qos_profile_t & qos_profile = rmw_qos_profile_services_default,
     rclcpp::callback_group::CallbackGroup::SharedPtr group = nullptr);
 
-  /// Declare and initialize a parameter, return the effective value.
-  /**
-   * \sa rclcpp::Node::declare_parameter
-   */
-  RCLCPP_LIFECYCLE_PUBLIC
-  const rclcpp::ParameterValue &
-  declare_parameter(
-    const std::string & name,
-    const rclcpp::ParameterValue & default_value = rclcpp::ParameterValue(),
-    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
-    rcl_interfaces::msg::ParameterDescriptor());
-
-  /// Declare and initialize a parameter with a type.
-  /**
-   * \sa rclcpp::Node::declare_parameter
-   */
-  template<typename ParameterT>
-  auto
-  declare_parameter(
-    const std::string & name,
-    const ParameterT & default_value,
-    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
-    rcl_interfaces::msg::ParameterDescriptor());
-
-  /// Declare and initialize several parameters with the same namespace and type.
-  /**
-   * \sa rclcpp::Node::declare_parameters
-   */
-  template<typename ParameterT>
-  std::vector<ParameterT>
-  declare_parameters(
-    const std::string & namespace_,
-    const std::map<std::string, ParameterT> & parameters);
-
-  /// Declare and initialize several parameters with the same namespace and type.
-  /**
-   * \sa rclcpp::Node::declare_parameters
-   */
-  template<typename ParameterT>
-  std::vector<ParameterT>
-  declare_parameters(
-    const std::string & namespace_,
-    const std::map<
-      std::string,
-      std::pair<ParameterT, rcl_interfaces::msg::ParameterDescriptor>
-    > & parameters);
-
-  /// Undeclare a previously declared parameter.
-  /**
-   * \sa rclcpp::Node::undeclare_parameter
-   */
-  RCLCPP_LIFECYCLE_PUBLIC
-  void
-  undeclare_parameter(const std::string & name);
-
-  /// Return true if a given parameter is declared.
-  /**
-   * \sa rclcpp::Node::has_parameter
-   */
-  RCLCPP_LIFECYCLE_PUBLIC
-  bool
-  has_parameter(const std::string & name) const;
-
-  /// Set a single parameter.
-  /**
-   * \sa rclcpp::Node::set_parameter
-   */
-  RCLCPP_LIFECYCLE_PUBLIC
-  rcl_interfaces::msg::SetParametersResult
-  set_parameter(const rclcpp::Parameter & parameter);
-
-  /// Set one or more parameters, one at a time.
-  /**
-   * \sa rclcpp::Node::set_parameters
-   */
   RCLCPP_LIFECYCLE_PUBLIC
   std::vector<rcl_interfaces::msg::SetParametersResult>
   set_parameters(const std::vector<rclcpp::Parameter> & parameters);
 
-  /// Set one or more parameters, all at once.
-  /**
-   * \sa rclcpp::Node::set_parameters_atomically
-   */
   RCLCPP_LIFECYCLE_PUBLIC
   rcl_interfaces::msg::SetParametersResult
   set_parameters_atomically(const std::vector<rclcpp::Parameter> & parameters);
 
-  /// Set one parameter, unless that parameter has already been set.
-  /**
-   * \sa rclcpp::Node::set_parameter_if_not_set
-   */
   template<typename ParameterT>
-  // cppcheck-suppress syntaxError // bug in cppcheck 1.82 for [[deprecated]] on templated function
-  [[deprecated("use declare_parameter() instead")]]
   void
   set_parameter_if_not_set(
     const std::string & name,
@@ -435,46 +349,54 @@ public:
 
   /// Set a map of parameters with the same prefix.
   /**
-   * \sa rclcpp::Node::set_parameters_if_not_set
+   * For each key in the map, a parameter with a name of "name.key" will be set
+   * to the value in the map.
+   *
+   * \param[in] name The prefix of the parameters to set.
+   * \param[in] values The parameters to set in the given prefix.
    */
   template<typename MapValueT>
-  // cppcheck-suppress syntaxError // bug in cppcheck 1.82 for [[deprecated]] on templated function
-  [[deprecated("use declare_parameters() instead")]]
   void
   set_parameters_if_not_set(
     const std::string & name,
     const std::map<std::string, MapValueT> & values);
 
-  /// Return the parameter by the given name.
-  /**
-   * \sa rclcpp::Node::get_parameter
-   */
+  RCLCPP_LIFECYCLE_PUBLIC
+  std::vector<rclcpp::Parameter>
+  get_parameters(const std::vector<std::string> & names) const;
+
   RCLCPP_LIFECYCLE_PUBLIC
   rclcpp::Parameter
   get_parameter(const std::string & name) const;
 
-  /// Get the value of a parameter by the given name, and return true if it was set.
-  /**
-   * \sa rclcpp::Node::get_parameter
-   */
   RCLCPP_LIFECYCLE_PUBLIC
   bool
   get_parameter(
     const std::string & name,
     rclcpp::Parameter & parameter) const;
 
-  /// Get the value of a parameter by the given name, and return true if it was set.
-  /**
-   * \sa rclcpp::Node::get_parameter
-   */
   template<typename ParameterT>
   bool
   get_parameter(const std::string & name, ParameterT & parameter) const;
 
-  /// Get the parameter value, or the "alternative_value" if not set, and assign it to "parameter".
+  /// Assign the value of the map parameter if set into the values argument.
   /**
-   * \sa rclcpp::Node::get_parameter_or
+   * Parameter names that are part of a map are of the form "name.member".
+   * This API gets all parameters that begin with "name", storing them into the
+   * map with the name of the parameter and their value.
+   * If there are no members in the named map, then the "values" argument is not changed.
+   *
+   * \param[in] name The prefix of the parameters to get.
+   * \param[out] values The map of output values, with one std::string,MapValueT
+   *                    per parameter.
+   * \returns true if values was changed, false otherwise
    */
+  template<typename MapValueT>
+  bool
+  get_parameters(
+    const std::string & name,
+    std::map<std::string, MapValueT> & values) const;
+
   template<typename ParameterT>
   bool
   get_parameter_or(
@@ -482,88 +404,42 @@ public:
     ParameterT & value,
     const ParameterT & alternative_value) const;
 
-  /// Return the parameters by the given parameter names.
-  /**
-   * \sa rclcpp::Node::get_parameters
-   */
-  RCLCPP_LIFECYCLE_PUBLIC
-  std::vector<rclcpp::Parameter>
-  get_parameters(const std::vector<std::string> & names) const;
-
-  /// Get the parameter values for all parameters that have a given prefix.
-  /**
-   * \sa rclcpp::Node::get_parameters
-   */
-  template<typename MapValueT>
-  bool
-  get_parameters(
-    const std::string & prefix,
-    std::map<std::string, MapValueT> & values) const;
-
   /// Get the parameter value; if not set, set the "alternative value" and store it in the node.
   /**
-   * \sa rclcpp::Node::get_parameter_or_set
+   * If the parameter is set, then the "value" argument is assigned the value
+   * in the parameter.
+   * If the parameter is not set, then the "value" argument is assigned the "alternative_value",
+   * and the parameter is set to the "alternative_value" on the node.
+   *
+   * \param[in] name The name of the parameter to get.
+   * \param[out] value The output where the value of the parameter should be assigned.
+   * \param[in] alternative_value Value to be stored in output and parameter if the parameter was not set.
    */
   template<typename ParameterT>
-  // cppcheck-suppress syntaxError // bug in cppcheck 1.82 for [[deprecated]] on templated function
-  [[deprecated("use declare_parameter() and it's return value instead")]]
   void
   get_parameter_or_set(
     const std::string & name,
     ParameterT & value,
     const ParameterT & alternative_value);
 
-  /// Return the parameter descriptor for the given parameter name.
-  /**
-   * \sa rclcpp::Node::describe_parameter
-   */
-  RCLCPP_LIFECYCLE_PUBLIC
-  rcl_interfaces::msg::ParameterDescriptor
-  describe_parameter(const std::string & name) const;
-
-  /// Return a vector of parameter descriptors, one for each of the given names.
-  /**
-   * \sa rclcpp::Node::describe_parameters
-   */
   RCLCPP_LIFECYCLE_PUBLIC
   std::vector<rcl_interfaces::msg::ParameterDescriptor>
   describe_parameters(const std::vector<std::string> & names) const;
 
-  /// Return a vector of parameter types, one for each of the given names.
-  /**
-   * \sa rclcpp::Node::get_parameter_types
-   */
   RCLCPP_LIFECYCLE_PUBLIC
   std::vector<uint8_t>
   get_parameter_types(const std::vector<std::string> & names) const;
 
-  /// Return a list of parameters with any of the given prefixes, up to the given depth.
-  /**
-   * \sa rclcpp::Node::list_parameters
-   */
   RCLCPP_LIFECYCLE_PUBLIC
   rcl_interfaces::msg::ListParametersResult
   list_parameters(const std::vector<std::string> & prefixes, uint64_t depth) const;
 
-  using OnParametersSetCallbackType =
-    rclcpp::node_interfaces::NodeParametersInterface::OnParametersSetCallbackType;
-
-  /// Register a callback to be called anytime a parameter is about to be changed.
-  /**
-   * \sa rclcpp::Node::set_on_parameters_set_callback
-   */
-  RCLCPP_LIFECYCLE_PUBLIC
-  rclcpp_lifecycle::LifecycleNode::OnParametersSetCallbackType
-  set_on_parameters_set_callback(
-    rclcpp_lifecycle::LifecycleNode::OnParametersSetCallbackType callback);
-
   /// Register the callback for parameter changes
   /**
-   * \sa rclcpp::Node::register_param_change_callback
+   * \param[in] callback User defined function which is expected to atomically set parameters.
+   * \note Repeated invocations of this function will overwrite previous callbacks
    */
   template<typename CallbackT>
-  // cppcheck-suppress syntaxError // bug in cppcheck 1.82 for [[deprecated]] on templated function
-  [[deprecated("use set_on_parameters_set_callback() instead")]]
   void
   register_param_change_callback(CallbackT && callback);
 

rclcpp_lifecycle/include/rclcpp_lifecycle/lifecycle_node_impl.hpp

@@ -223,62 +223,6 @@ LifecycleNode::create_service(
     service_name, std::forward<CallbackT>(callback), qos_profile, group);
 }
 
-template<typename ParameterT>
-auto
-LifecycleNode::declare_parameter(
-  const std::string & name,
-  const ParameterT & default_value,
-  const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor)
-{
-  return this->declare_parameter(
-    name,
-    rclcpp::ParameterValue(default_value),
-    parameter_descriptor
-  ).get<ParameterT>();
-}
-
-template<typename ParameterT>
-std::vector<ParameterT>
-LifecycleNode::declare_parameters(
-  const std::string & namespace_,
-  const std::map<std::string, ParameterT> & parameters)
-{
-  std::vector<ParameterT> result;
-  std::string normalized_namespace = namespace_.empty() ? "" : (namespace_ + ".");
-  std::transform(
-    parameters.begin(), parameters.end(), std::back_inserter(result),
-    [this, &normalized_namespace](auto element) {
-      return this->declare_parameter(normalized_namespace + element.first, element.second);
-    }
-  );
-  return result;
-}
-
-template<typename ParameterT>
-std::vector<ParameterT>
-LifecycleNode::declare_parameters(
-  const std::string & namespace_,
-  const std::map<
-    std::string,
-    std::pair<ParameterT, rcl_interfaces::msg::ParameterDescriptor>
-  > & parameters)
-{
-  std::vector<ParameterT> result;
-  std::string normalized_namespace = namespace_.empty() ? "" : (namespace_ + ".");
-  std::transform(
-    parameters.begin(), parameters.end(), std::back_inserter(result),
-    [this, &normalized_namespace](auto element) {
-      return static_cast<ParameterT>(
-        this->declare_parameter(
-          normalized_namespace + element.first,
-          element.second.first,
-          element.second.second)
-      );
-    }
-  );
-  return result;
-}
-
 template<typename ParameterT>
 bool
 LifecycleNode::get_parameter(const std::string & name, ParameterT & parameter) const
@@ -339,11 +283,11 @@ LifecycleNode::set_parameters_if_not_set(
 template<typename MapValueT>
 bool
 LifecycleNode::get_parameters(
-  const std::string & prefix,
+  const std::string & name,
   std::map<std::string, MapValueT> & values) const
 {
   std::map<std::string, rclcpp::Parameter> params;
-  bool result = node_parameters_->get_parameters_by_prefix(prefix, params);
+  bool result = node_parameters_->get_parameters_by_prefix(name, params);
   if (result) {
     for (const auto & param : params) {
       values[param.first] = param.second.get_value<MapValueT>();

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>0.7.5</version>
+  <version>0.7.2</version>
   <description>Package containing a prototype for lifecycle implementation</description>
   <maintainer email="karsten@osrfoundation.org">Karsten Knese</maintainer>
   <license>Apache License 2.0</license>

rclcpp_lifecycle/src/lifecycle_node.cpp

@@ -91,13 +91,13 @@ LifecycleNode::LifecycleNode(
       node_topics_,
       node_services_,
       node_clock_,
-      options.parameter_overrides(),
+      options.initial_parameters(),
       options.start_parameter_services(),
       options.start_parameter_event_publisher(),
       options.parameter_event_qos(),
       options.parameter_event_publisher_options(),
       options.allow_undeclared_parameters(),
-      options.automatically_declare_parameters_from_overrides()
+      options.automatically_declare_initial_parameters()
     )),
   node_time_source_(new rclcpp::node_interfaces::NodeTimeSource(
       node_base_,
@@ -154,33 +154,6 @@ LifecycleNode::create_callback_group(
   return node_base_->create_callback_group(group_type);
 }
 
-const rclcpp::ParameterValue &
-LifecycleNode::declare_parameter(
-  const std::string & name,
-  const rclcpp::ParameterValue & default_value,
-  const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor)
-{
-  return this->node_parameters_->declare_parameter(name, default_value, parameter_descriptor);
-}
-
-void
-LifecycleNode::undeclare_parameter(const std::string & name)
-{
-  this->node_parameters_->undeclare_parameter(name);
-}
-
-bool
-LifecycleNode::has_parameter(const std::string & name) const
-{
-  return this->node_parameters_->has_parameter(name);
-}
-
-rcl_interfaces::msg::SetParametersResult
-LifecycleNode::set_parameter(const rclcpp::Parameter & parameter)
-{
-  return this->set_parameters_atomically({parameter});
-}
-
 bool
 LifecycleNode::group_in_node(rclcpp::callback_group::CallbackGroup::SharedPtr group)
 {
@@ -214,27 +187,13 @@ LifecycleNode::get_parameter(const std::string & name) const
   return node_parameters_->get_parameter(name);
 }
 
-bool
-LifecycleNode::get_parameter(
+bool LifecycleNode::get_parameter(
   const std::string & name,
   rclcpp::Parameter & parameter) const
 {
   return node_parameters_->get_parameter(name, parameter);
 }
 
-rcl_interfaces::msg::ParameterDescriptor
-LifecycleNode::describe_parameter(const std::string & name) const
-{
-  auto result = node_parameters_->describe_parameters({name});
-  if (0 == result.size()) {
-    throw rclcpp::exceptions::ParameterNotDeclaredException(name);
-  }
-  if (result.size() > 1) {
-    throw std::runtime_error("number of described parameters unexpectedly more than one");
-  }
-  return result.front();
-}
-
 std::vector<rcl_interfaces::msg::ParameterDescriptor>
 LifecycleNode::describe_parameters(
   const std::vector<std::string> & names) const
@@ -256,12 +215,6 @@ LifecycleNode::list_parameters(
   return node_parameters_->list_parameters(prefixes, depth);
 }
 
-rclcpp::Node::OnParametersSetCallbackType
-LifecycleNode::set_on_parameters_set_callback(rclcpp::Node::OnParametersSetCallbackType callback)
-{
-  return node_parameters_->set_on_parameters_set_callback(callback);
-}
-
 std::vector<std::string>
 LifecycleNode::get_node_names() const
 {