Replace constructor method procedure

For backward compatibility, it is better to retain constructor method
but deperecated.
As for now, constructors only use NodeBuilder.

Author: Soya-Onishi

rclrs/src/context.rs

@@ -1,5 +1,5 @@
 use crate::rcl_bindings::*;
-use crate::{Node, RclReturnCode, ToResult};
+use crate::{Node, NodeBuilder, RclReturnCode, ToResult};
 
 use std::ffi::CString;
 use std::os::raw::c_char;
@@ -115,7 +115,7 @@ impl Context {
     /// # Ok::<(), RclReturnCode>(())
     /// ```
     pub fn create_node(&self, node_name: &str) -> Result<Node, RclReturnCode> {
-        Node::new(node_name, self)
+        NodeBuilder::new(node_name, self).build()
     }
 
     /// Creates a new node in a namespace.
@@ -138,7 +138,24 @@ impl Context {
         node_namespace: &str,
         node_name: &str,
     ) -> Result<Node, RclReturnCode> {
-        Node::new_with_namespace(node_namespace, node_name, self)
+        NodeBuilder::new(node_name, self)
+            .namespace(node_namespace)
+            .build()
+    }
+
+    /// Creates a [`NodeBuilder`][1]
+    ///
+    /// [1]: crate::NodeBuilder
+    ///
+    /// # Example
+    /// ```
+    /// # use rclrs::Context;
+    /// let ctx = Context::new([]).unwrap();
+    /// let builder = ctx.node_builder("foo_node");
+    /// let node = builder.build();
+    /// ```
+    pub fn create_node_builder<'a>(&'a self, node_name: &'a str) -> NodeBuilder<'a> {
+        NodeBuilder::new(node_name, self)
     }
 
     /// Checks if the context is still valid.

rclrs/src/node/mod.rs

@@ -80,17 +80,22 @@ impl fmt::Debug for Node {
 
 impl Node {
     /// Creates a new node in the empty namespace.
+<<<<<<< HEAD
     ///
     /// See [`Node::new_with_namespace`] for documentation.
+=======
+    #[deprecated(since = "0.2.0", note = "please use `NodeBuilder` instead")]
+>>>>>>> Replace constructor method procedure
     #[allow(clippy::new_ret_no_self)]
     pub fn new(node_name: &str, context: &Context) -> Result<Node, RclReturnCode> {
-        Self::new_with_namespace("", node_name, context)
+        NodeBuilder::new(node_name, context).build()
     }
 
     /// Creates a new node in a namespace.
     ///
     /// A namespace without a leading forward slash is automatically changed to have a leading
     /// forward slash.
+<<<<<<< HEAD
     ///
     /// # Naming
     /// The node namespace will be prefixed to the node name itself to form the *fully qualified
@@ -138,42 +143,17 @@ impl Node {
     /// [1]: https://docs.ros.org/en/rolling/How-To-Guides/Node-arguments.html
     /// [2]: https://docs.ros2.org/latest/api/rmw/validate__namespace_8h.html
     /// [3]: https://docs.ros2.org/latest/api/rmw/validate__node__name_8h.html
+=======
+    #[deprecated(since = "0.2.0", note = "please use `NodeBuilder` instead")]
+>>>>>>> Replace constructor method procedure
     pub fn new_with_namespace(
         node_ns: &str,
         node_name: &str,
         context: &Context,
     ) -> Result<Node, RclReturnCode> {
-        let raw_node_name = CString::new(node_name).unwrap();
-        let raw_node_ns = CString::new(node_ns).unwrap();
-
-        // SAFETY: Getting a zero-initialized value is always safe.
-        let mut node_handle = unsafe { rcl_get_zero_initialized_node() };
-        let context_handle = &mut *context.handle.lock();
-
-        unsafe {
-            // SAFETY: No preconditions for this function.
-            let node_options = rcl_node_get_default_options();
-            // 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
-            // to keep them alive.
-            // The context handle is kept alive because it is co-owned by the node.
-            rcl_node_init(
-                &mut node_handle,
-                raw_node_name.as_ptr(),
-                raw_node_ns.as_ptr(),
-                context_handle,
-                &node_options,
-            )
-            .ok()?;
-        }
-
-        let handle = Arc::new(Mutex::new(node_handle));
-
-        Ok(Node {
-            handle,
-            context: context.handle.clone(),
-            subscriptions: std::vec![],
-        })
+        NodeBuilder::new(node_name, context)
+            .namespace(node_ns)
+            .build()
     }
 
     /// Returns the name of the node.