Read only parameters

rclcpp/include/rclcpp/exceptions.hpp

@@ -185,14 +185,35 @@ class EventNotRegisteredError : public std::runtime_error
 class InvalidParametersException : public std::runtime_error
 {
 public:
-  // Inherit constructors from runtime_error;
+  // Inherit constructors from runtime_error.
   using std::runtime_error::runtime_error;
 };
 
-/// Throwing if passed parameter value is invalid.
+/// Thrown if passed parameter value is invalid.
 class InvalidParameterValueException : public std::runtime_error
 {
-  // Inherit constructors from runtime_error;
+  // Inherit constructors from runtime_error.
+  using std::runtime_error::runtime_error;
+};
+
+/// Thrown if parameter is already declared.
+class ParameterAlreadyDeclaredException : public std::runtime_error
+{
+  // Inherit constructors from runtime_error.
+  using std::runtime_error::runtime_error;
+};
+
+/// Thrown if parameter is not declared, e.g. either set or get was called without first declaring.
+class ParameterNotDeclaredException : public std::runtime_error
+{
+  // Inherit constructors from runtime_error.
+  using std::runtime_error::runtime_error;
+};
+
+/// Thrown if parameter is immutable and therefore cannot be undeclared.
+class ParameterImmutableException : public std::runtime_error
+{
+  // Inherit constructors from runtime_error.
   using std::runtime_error::runtime_error;
 };
 

rclcpp/include/rclcpp/node_impl.hpp

@@ -221,11 +221,58 @@ Node::create_service(
     group);
 }
 
-template<typename CallbackT>
-void
-Node::register_param_change_callback(CallbackT && callback)
+template<typename ParameterT>
+ParameterT
+Node::declare_parameter(
+  const std::string & name,
+  const ParameterT & default_value,
+  rcl_interfaces::msg::ParameterDescriptor parameter_descriptor)
 {
-  this->node_parameters_->register_param_change_callback(std::forward<CallbackT>(callback));
+  return this->declare_parameter(
+    name,
+    rclcpp::ParameterValue(default_value),
+    parameter_descriptor
+  ).get<ParameterT>();
+}
+
+template<typename ParameterT>
+std::vector<ParameterT>
+Node::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>
+Node::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 this->declare_parameter(
+        normalized_namespace + element.first,
+        element.second.first,
+        element.second.second);
+    }
+  );
+  return result;
 }
 
 template<typename ParameterT>
@@ -234,33 +281,26 @@ Node::set_parameter_if_not_set(
   const std::string & name,
   const ParameterT & value)
 {
-  std::string parameter_name_with_sub_namespace =
-    extend_name_with_sub_namespace(name, this->get_sub_namespace());
-
-  rclcpp::Parameter parameter;
-  if (!this->get_parameter(parameter_name_with_sub_namespace, parameter)) {
-    this->set_parameters({
-        rclcpp::Parameter(parameter_name_with_sub_namespace, value),
-      });
+  if (!this->has_parameter(name)) {
+    this->set_parameter(rclcpp::Parameter(name, value));
   }
 }
 
 // this is a partially-specialized version of set_parameter_if_not_set above,
 // where our concrete type for ParameterT is std::map, but the to-be-determined
 // type is the value in the map.
-template<typename MapValueT>
+template<typename ParameterT>
 void
 Node::set_parameters_if_not_set(
   const std::string & name,
-  const std::map<std::string, MapValueT> & values)
+  const std::map<std::string, ParameterT> & values)
 {
   std::vector<rclcpp::Parameter> params;
 
   for (const auto & val : values) {
-    std::string param_name = name + "." + val.first;
-    rclcpp::Parameter parameter;
-    if (!this->get_parameter(param_name, parameter)) {
-      params.push_back(rclcpp::Parameter(param_name, val.second));
+    std::string parameter_name = name + "." + val.first;
+    if (!this->has_parameter(parameter_name)) {
+      params.push_back(rclcpp::Parameter(parameter_name, val.second));
     }
   }
 
@@ -269,56 +309,56 @@ Node::set_parameters_if_not_set(
 
 template<typename ParameterT>
 bool
-Node::get_parameter(const std::string & name, ParameterT & value) const
+Node::get_parameter(const std::string & name, ParameterT & parameter) const
 {
   std::string sub_name = extend_name_with_sub_namespace(name, this->get_sub_namespace());
 
-  rclcpp::Parameter parameter;
+  rclcpp::Parameter parameter_variant;
 
-  bool result = get_parameter(sub_name, parameter);
+  bool result = get_parameter(sub_name, parameter_variant);
   if (result) {
-    value = parameter.get_value<ParameterT>();
+    parameter = parameter_variant.get_value<ParameterT>();
   }
 
   return result;
 }
 
+template<typename ParameterT>
+bool
+Node::get_parameter_or(
+  const std::string & name,
+  ParameterT & parameter,
+  const ParameterT & alternative_value) const
+{
+  std::string sub_name = extend_name_with_sub_namespace(name, this->get_sub_namespace());
+
+  bool got_parameter = get_parameter(sub_name, parameter);
+  if (!got_parameter) {
+    parameter = alternative_value;
+  }
+  return got_parameter;
+}
+
 // this is a partially-specialized version of get_parameter above,
 // where our concrete type for ParameterT is std::map, but the to-be-determined
 // type is the value in the map.
-template<typename MapValueT>
+template<typename ParameterT>
 bool
 Node::get_parameters(
-  const std::string & name,
-  std::map<std::string, MapValueT> & values) const
+  const std::string & prefix,
+  std::map<std::string, ParameterT> & values) const
 {
   std::map<std::string, rclcpp::Parameter> params;
-  bool result = node_parameters_->get_parameters_by_prefix(name, params);
+  bool result = node_parameters_->get_parameters_by_prefix(prefix, params);
   if (result) {
     for (const auto & param : params) {
-      values[param.first] = param.second.get_value<MapValueT>();
+      values[param.first] = param.second.get_value<ParameterT>();
     }
   }
 
   return result;
 }
 
-template<typename ParameterT>
-bool
-Node::get_parameter_or(
-  const std::string & name,
-  ParameterT & value,
-  const ParameterT & alternative_value) const
-{
-  std::string sub_name = extend_name_with_sub_namespace(name, this->get_sub_namespace());
-
-  bool got_parameter = get_parameter(sub_name, value);
-  if (!got_parameter) {
-    value = alternative_value;
-  }
-  return got_parameter;
-}
-
 template<typename ParameterT>
 void
 Node::get_parameter_or_set(
@@ -337,6 +377,13 @@ Node::get_parameter_or_set(
   }
 }
 
+template<typename CallbackT>
+void
+Node::register_param_change_callback(CallbackT && callback)
+{
+  this->node_parameters_->register_param_change_callback(std::forward<CallbackT>(callback));
+}
+
 }  // namespace rclcpp
 
 #endif  // RCLCPP__NODE_IMPL_HPP_

rclcpp/include/rclcpp/node_interfaces/node_parameters.hpp

@@ -40,6 +40,16 @@ namespace rclcpp
 namespace node_interfaces
 {
 
+// Internal struct for holding useful info about parameters
+struct ParameterInfo
+{
+  /// Current value of the parameter.
+  rclcpp::ParameterValue value;
+
+  /// A description of the parameter
+  rcl_interfaces::msg::ParameterDescriptor descriptor;
+};
+
 /// Implementation of the NodeParameters part of the Node API.
 class NodeParameters : public NodeParametersInterface
 {
@@ -49,90 +59,107 @@ class NodeParameters : public NodeParametersInterface
   RCLCPP_PUBLIC
   NodeParameters(
     const node_interfaces::NodeBaseInterface::SharedPtr node_base,
+    const node_interfaces::NodeLoggingInterface::SharedPtr node_logging,
     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> & initial_parameters,
     bool use_intra_process,
     bool start_parameter_services,
     bool start_parameter_event_publisher,
-    const rmw_qos_profile_t & parameter_event_qos_profile);
+    const rmw_qos_profile_t & parameter_event_qos_profile,
+    bool allow_undeclared_parameters);
 
   RCLCPP_PUBLIC
   virtual
   ~NodeParameters();
 
   RCLCPP_PUBLIC
-  virtual
+  const rclcpp::ParameterValue &
+  declare_parameter(
+    const std::string & name,
+    const rclcpp::ParameterValue & default_value,
+    rcl_interfaces::msg::ParameterDescriptor parameter_descriptor) override;
+
+  RCLCPP_PUBLIC
+  void
+  undeclare_parameter(const std::string & name) override;
+
+  RCLCPP_PUBLIC
+  bool
+  has_parameter(const std::string & name) const override;
+
+  RCLCPP_PUBLIC
   std::vector<rcl_interfaces::msg::SetParametersResult>
   set_parameters(
-    const std::vector<rclcpp::Parameter> & parameters);
+    const std::vector<rclcpp::Parameter> & parameters) override;
 
   RCLCPP_PUBLIC
-  virtual
   rcl_interfaces::msg::SetParametersResult
   set_parameters_atomically(
-    const std::vector<rclcpp::Parameter> & parameters);
+    const std::vector<rclcpp::Parameter> & parameters) override;
 
   RCLCPP_PUBLIC
-  virtual
   std::vector<rclcpp::Parameter>
-  get_parameters(const std::vector<std::string> & names) const;
+  get_parameters(const std::vector<std::string> & names) const override;
 
   RCLCPP_PUBLIC
-  virtual
   rclcpp::Parameter
-  get_parameter(const std::string & name) const;
+  get_parameter(const std::string & name) const override;
 
   RCLCPP_PUBLIC
-  virtual
   bool
   get_parameter(
     const std::string & name,
-    rclcpp::Parameter & parameter) const;
+    rclcpp::Parameter & parameter) const override;
 
   RCLCPP_PUBLIC
-  virtual
   bool
   get_parameters_by_prefix(
     const std::string & prefix,
-    std::map<std::string, rclcpp::Parameter> & parameters) const;
+    std::map<std::string, rclcpp::Parameter> & parameters) const override;
 
   RCLCPP_PUBLIC
-  virtual
   std::vector<rcl_interfaces::msg::ParameterDescriptor>
-  describe_parameters(const std::vector<std::string> & names) const;
+  describe_parameters(const std::vector<std::string> & names) const override;
 
   RCLCPP_PUBLIC
-  virtual
   std::vector<uint8_t>
-  get_parameter_types(const std::vector<std::string> & names) const;
+  get_parameter_types(const std::vector<std::string> & names) const override;
 
   RCLCPP_PUBLIC
-  virtual
   rcl_interfaces::msg::ListParametersResult
-  list_parameters(const std::vector<std::string> & prefixes, uint64_t depth) const;
+  list_parameters(const std::vector<std::string> & prefixes, uint64_t depth) const override;
 
   RCLCPP_PUBLIC
-  virtual
+  OnParametersSetCallbackType
+  set_on_parameters_set_callback(OnParametersSetCallbackType callback) override;
+
+  [[deprecated("use set_on_parameters_set_callback() instead")]]
+  RCLCPP_PUBLIC
   void
-  register_param_change_callback(ParametersCallbackFunction callback);
+  register_param_change_callback(OnParametersSetCallbackType callback) override;
 
 private:
   RCLCPP_DISABLE_COPY(NodeParameters)
 
   mutable std::mutex mutex_;
 
-  ParametersCallbackFunction parameters_callback_ = nullptr;
+  OnParametersSetCallbackType on_parameters_set_callback_ = nullptr;
+
+  std::map<std::string, ParameterInfo> parameters_;
+
+  std::map<std::string, rclcpp::ParameterValue> initial_parameter_values_;
 
-  std::map<std::string, rclcpp::Parameter> parameters_;
+  bool allow_undeclared_ = false;
 
   Publisher<rcl_interfaces::msg::ParameterEvent>::SharedPtr events_publisher_;
 
   std::shared_ptr<ParameterService> parameter_service_;
 
   std::string combined_name_;
 
+  node_interfaces::NodeLoggingInterface::SharedPtr node_logging_;
   node_interfaces::NodeClockInterface::SharedPtr node_clock_;
 };