Add methods related to node options to NodeBuilder

rclrs/src/node/builder.rs

@@ -13,6 +13,10 @@ use std::sync::Arc;
 ///
 /// The default values for optional fields are:
 /// - `namespace: "/"`
+/// - `domain_id: ROS_DOMAIN_ID`
+/// - `use_global_arguments: true`
+/// - `arguments: []`
+/// - `enable_rosout`: true`
 ///
 /// # Example
 /// ```
@@ -40,6 +44,9 @@ pub struct NodeBuilder {
     context: Arc<Mutex<rcl_context_t>>,
     name: String,
     namespace: String,
+    use_global_arguments: bool,
+    arguments: Vec<String>,
+    enable_rosout: bool,
 }
 
 impl NodeBuilder {
@@ -84,6 +91,9 @@ impl NodeBuilder {
             context: context.handle.clone(),
             name: name.to_string(),
             namespace: "/".to_string(),
+            use_global_arguments: true,
+            arguments: vec![],
+            enable_rosout: true,
         }
     }
 
@@ -142,28 +152,124 @@ impl NodeBuilder {
         self
     }
 
+    /// Sets flag for using global arguments.
+    /// If false then only use arguments passed to this builder,
+    /// otherwise use global arguments also.
+    ///
+    /// # Example
+    /// ```
+    /// # use rclrs::{Context, Node, NodeBuilder, RclrsError};
+    /// let args = ["--ros-args", "--remap", "my_node:__node:=your_node"]
+    ///   .iter()
+    ///   .map(|s| s.to_string())
+    ///   .collect::<Vec<_>>();
+    /// let context = Context::new(args)?;
+    /// // Use global arguments
+    /// let node = context
+    ///   .create_node_builder("my_node")
+    ///   .use_global_arguments(true)
+    ///   .build()?;
+    /// assert_eq!(node.name(), "your_node");
+    ///
+    /// // Not use global arguments
+    /// let node = context
+    ///   .create_node_builder("my_node")
+    ///   .use_global_arguments(false)
+    ///   .build()?;
+    /// assert_eq!(node.name(), "my_node");
+    /// # Ok::<(), RclrsError>(())
+    pub fn use_global_arguments(mut self, enable: bool) -> Self {
+        self.use_global_arguments = enable;
+        self
+    }
+
+    /// Sets node specific command line arguments.
+    ///
+    /// Command line arguments can mix ROS specific and not specific arguments.
+    /// ROS specific arguments are wrapped between `--ros-args` and `--`.
+    /// Note that `--ros-args` followed by only ROS specific arguments is valid pattern.
+    ///
+    /// below arguments examples are valid:
+    ///   --ros-args -r from:=to -- user_arg0 user_arg1
+    ///   --ros-args -p name:=value
+    ///    
+    /// # Example
+    /// ```
+    /// # use rclrs::{Context, Node, NodeBuilder, RclrsError};
+    /// let context = Context::new([])?;
+    /// let node_args = ["--ros-args", "--remap", "my_node:__node:=your_node"]
+    ///   .iter()
+    ///   .map(|s| s.to_string())
+    ///   .collect::<Vec<_>>();
+    /// let node = context
+    ///   .create_node_builder("my_node")
+    ///   .arguments(node_args)
+    ///   .build()?;
+    /// assert_eq!(node.name(), "your_node");
+    /// # Ok::<(), RclrsError>(())
+    /// ```
+    pub fn arguments(mut self, arguments: impl IntoIterator<Item = String>) -> Self {
+        self.arguments = arguments.into_iter().collect();
+        self
+    }
+
+    /// Enables rosout.
+    /// If false, rosout logging is disabled.
+    pub fn enable_rosout(mut self, enable: bool) -> Self {
+        self.enable_rosout = enable;
+        self
+    }
+
     /// Builds the node instance.
     ///
     /// Node name and namespace validation is performed in this method.
     ///
     /// For example usage, see the [`NodeBuilder`][1] docs.
     ///
     /// # Panics
-    /// When the node name or namespace contain null bytes.
+    /// If any of below conditions are filled, panic occurs
+    ///  - node name contains null byte
+    ///  - namespace contains null byte
+    ///  - any of node argument strings contain null byte.
     ///
     /// [1]: crate::NodeBuilder
     pub fn build(&self) -> Result<Node, RclrsError> {
         let node_name = CString::new(self.name.as_str()).unwrap();
         let node_namespace = CString::new(self.namespace.as_str()).unwrap();
 
         // SAFETY: No preconditions for this function.
-        let mut node_handle = unsafe { rcl_get_zero_initialized_node() };
+        let mut node_options = unsafe { rcl_node_get_default_options() };
 
+        let cstr_args = self
+            .arguments
+            .iter()
+            .map(|s| CString::new(s.as_str()).unwrap())
+            .collect::<Vec<_>>();
+        let cstr_arg_ptrs = cstr_args.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
+        // SAFETY: No preconditions for this function.
+        let mut arguments = unsafe { rcl_get_zero_initialized_arguments() };
         unsafe {
             // SAFETY: No preconditions for this function.
-            let context_handle = &mut *self.context.lock();
+            rcl_parse_arguments(
+                cstr_arg_ptrs.len() as i32,
+                cstr_arg_ptrs.as_ptr(),
+                rcutils_get_default_allocator(),
+                &mut arguments,
+            )
+        }
+        .ok()?;
+
+        node_options.arguments = arguments;
+        node_options.use_global_arguments = self.use_global_arguments;
+        node_options.enable_rosout = self.enable_rosout;
+        // SAFETY: No preconditions for this function.
+        node_options.allocator = unsafe { rcutils_get_default_allocator() };
+
+        // SAFETY: No preconditions for this function.
+        let mut node_handle = unsafe { rcl_get_zero_initialized_node() };
+        unsafe {
             // SAFETY: No preconditions for this function.
-            let node_options = rcl_node_get_default_options();
+            let context_handle = &mut *self.context.lock();
 
             // SAFETY: The node handle is zero-initialized as expected by this function.
             // The strings and node options are copied by this function, so we don't need