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,
         })
     }