Add preliminary support for parameters

rclrs/src/node.rs

@@ -13,9 +13,9 @@ pub use self::builder::*;
 pub use self::graph::*;
 use crate::rcl_bindings::*;
 use crate::{
- Client, ClientBase, Context, GuardCondition, ParameterOverrideMap, Publisher, QoSProfile,
- RclrsError, Service, ServiceBase, Subscription, SubscriptionBase, SubscriptionCallback,
- ToResult,
+ Client, ClientBase, Context, Declarable, GuardCondition, ParameterBuilder, ParameterInterface,
+ ParameterVariant, Parameters, Publisher, QoSProfile, RclrsError, Service, ServiceBase,
+ Subscription, SubscriptionBase, SubscriptionCallback, ToResult,
 };
 
 impl Drop for rcl_node_t {
@@ -71,7 +71,7 @@ pub struct Node {
  pub(crate) guard_conditions_mtx: Mutex<Vec<Weak<GuardCondition>>>,
  pub(crate) services_mtx: Mutex<Vec<Weak<dyn ServiceBase>>>,
  pub(crate) subscriptions_mtx: Mutex<Vec<Weak<dyn SubscriptionBase>>>,
- _parameter_map: ParameterOverrideMap,
+ _parameter: ParameterInterface,
 }
 
 impl Eq for Node {}
@@ -360,6 +360,84 @@ impl Node {
  domain_id
  }
 
+ /// Creates a `ParameterBuilder` that can be used to set parameter declaration options and
+ /// declare a parameter as `Optional`, `Mandatory` or `ReadOnly`.
+ ///
+ /// # Example
+ /// ```
+ /// # use rclrs::{Context, ParameterRange, RclrsError};
+ /// let context = Context::new([])?;
+ /// let node = rclrs::create_node(&context, "domain_id_node")?;
+ /// // Set it to a range of 0-100, with a step of 2
+ /// let range = ParameterRange {
+ /// lower: Some(-100),
+ /// upper: Some(100),
+ /// step: Some(2),
+ /// };
+ /// let param = node.declare_parameter("int_param", 10)
+ /// .range(range)
+ /// .mandatory()
+ /// .unwrap();
+ /// assert_eq!(param.get(), 10);
+ /// param.set(50).unwrap();
+ /// assert_eq!(param.get(), 50);
+ /// // Out of range, will return an error
+ /// assert!(param.set(200).is_err());
+ /// # Ok::<(), RclrsError>(())
+ /// ```
+ pub fn declare_parameter<T: Declarable>(
+ &self,
+ name: &str,
+ default_value: T,
+ ) -> ParameterBuilder<'_, T> {
+ self._parameter.declare(name, default_value)
+ }
+
+ /// Creates a `ParameterBuilder` that can be used to set parameter declaration options and
+ /// declare a parameter from an iterable as `Optional`, `Mandatory` or `ReadOnly`.
+ pub fn declare_parameter_from_iter<U: IntoIterator>(
+ &self,
+ name: &str,
+ default_value: U,
+ ) -> ParameterBuilder<'_, Arc<[U::Item]>>
+ where
+ Arc<[U::Item]>: ParameterVariant,
+ {
+ self._parameter.declare_from_iter(name, default_value)
+ }
+
+ /// Creates a `ParameterBuilder` that can be used to set parameter declaration options and
+ /// declare a string array parameter as `Optional`, `Mandatory` or `ReadOnly`.
+ pub fn declare_string_array_parameter<U>(
+ &self,
+ name: &str,
+ default_value: U,
+ ) -> ParameterBuilder<'_, Arc<[Arc<str>]>>
+ where
+ U: IntoIterator,
+ U::Item: Into<Arc<str>>,
+ {
+ self._parameter.declare_string_array(name, default_value)
+ }
+
+ /// Helper function to declare an `Optional` parameter with a default unset value.
+ pub fn declare_unset_parameter<T: ParameterVariant>(
+ &self,
+ name: &str,
+ ) -> ParameterBuilder<'_, Option<T>> {
+ self._parameter.declare::<Option<T>>(name, None)
+ }
+
+ /// Enables usage of undeclared parameters for this node.
+ ///
+ /// Returns a `Parameter` struct that can be used to get and set all parameters.
+ pub fn use_undeclared_parameters(&self) -> Parameters {
+ self._parameter.allow_undeclared();
+ Parameters {
+ interface: &self._parameter,
+ }
+ }
+
  /// Creates a [`NodeBuilder`][1] with the given name.
  ///
  /// Convenience function equivalent to [`NodeBuilder::new()`][2].
@@ -384,7 +462,7 @@ impl Node {
 // function, which is why it's not merged into Node::call_string_getter().
 // This function is unsafe since it's possible to pass in an rcl_node_t with dangling
 // pointers etc.
-unsafe fn call_string_getter_with_handle(
+pub(crate) unsafe fn call_string_getter_with_handle(
  rcl_node: &rcl_node_t,
  getter: unsafe extern "C" fn(*const rcl_node_t) -> *const c_char,
 ) -> String {

rclrs/src/node/builder.rs

@@ -2,10 +2,7 @@ use std::ffi::CString;
 use std::sync::{Arc, Mutex};
 
 use crate::rcl_bindings::*;
-use crate::{
- node::call_string_getter_with_handle, resolve_parameter_overrides, Context, Node, RclrsError,
- ToResult,
-};
+use crate::{Context, Node, ParameterInterface, RclrsError, ToResult};
 
 /// A builder for creating a [`Node`][1].
 ///
@@ -262,24 +259,20 @@ impl NodeBuilder {
  .ok()?;
  };
 
- let _parameter_map = unsafe {
- let fqn = call_string_getter_with_handle(&rcl_node, rcl_node_get_fully_qualified_name);
- resolve_parameter_overrides(
- &fqn,
- &rcl_node_options.arguments,
- &rcl_context.global_arguments,
- )?
- };
  let rcl_node_mtx = Arc::new(Mutex::new(rcl_node));
-
+ let _parameter = ParameterInterface::new(
+ &rcl_node_mtx,
+ &rcl_node_options.arguments,
+ &rcl_context.global_arguments,
+ )?;
  Ok(Node {
  rcl_node_mtx,
  rcl_context_mtx: self.context.clone(),
  clients_mtx: Mutex::new(vec![]),
  guard_conditions_mtx: Mutex::new(vec![]),
  services_mtx: Mutex::new(vec![]),
  subscriptions_mtx: Mutex::new(vec![]),
- _parameter_map,
+ _parameter,
  })
  }