Move create_node and create_node_builder back to the rclrs module

Author: esteve

examples/message_demo/src/message_demo.rs

@@ -132,7 +132,7 @@ fn demonstrate_pubsub() -> Result<(), Error> {
     println!("================== Interoperability demo ==================");
     // Demonstrate interoperability between idiomatic and RMW-native message types
     let context = rclrs::Context::new(env::args())?;
-    let mut node = context.create_node("message_demo")?;
+    let mut node = rclrs::create_node(&context, "message_demo")?;
 
     let idiomatic_publisher = node.create_publisher::<rclrs_example_msgs::msg::VariousTypes>(
         "topic",

examples/minimal_pub_sub/src/minimal_publisher.rs

@@ -4,7 +4,7 @@ use std::env;
 fn main() -> Result<(), Error> {
     let context = rclrs::Context::new(env::args())?;
 
-    let node = context.create_node("minimal_publisher")?;
+    let node = rclrs::create_node(&context, "minimal_publisher")?;
 
     let publisher =
         node.create_publisher::<std_msgs::msg::String>("topic", rclrs::QOS_PROFILE_DEFAULT)?;

examples/minimal_pub_sub/src/minimal_subscriber.rs

@@ -5,7 +5,7 @@ use anyhow::{Error, Result};
 fn main() -> Result<(), Error> {
     let context = rclrs::Context::new(env::args())?;
 
-    let mut node = context.create_node("minimal_subscriber")?;
+    let mut node = rclrs::create_node(&context, "minimal_subscriber")?;
 
     let mut num_messages: usize = 0;
 

rclrs/src/context.rs

@@ -1,5 +1,5 @@
 use crate::rcl_bindings::*;
-use crate::{Node, NodeBuilder, RclrsError, ToResult};
+use crate::{RclrsError, ToResult};
 
 use std::ffi::CString;
 use std::os::raw::c_char;
@@ -105,47 +105,6 @@ impl Context {
         })
     }
 
-    /// Creates a new node in the empty namespace.
-    ///
-    /// Convenience function equivalent to [`Node::new`][1].
-    /// Please see that function's documentation.
-    ///
-    /// [1]: crate::Node::new
-    ///
-    /// # Example
-    /// ```
-    /// # use rclrs::{Context, RclrsError};
-    /// let ctx = Context::new([])?;
-    /// let node = ctx.create_node("my_node");
-    /// assert!(node.is_ok());
-    /// # Ok::<(), RclrsError>(())
-    /// ```
-    pub fn create_node(&self, node_name: &str) -> Result<Node, RclrsError> {
-        Node::builder(self, node_name).build()
-    }
-
-    /// Creates a [`NodeBuilder`][1].
-    ///
-    /// Convenience function equivalent to [`NodeBuilder::new()`][2] and [`Node::builder()`][3].
-    /// Please see that function's documentation.
-    ///
-    /// [1]: crate::NodeBuilder
-    /// [2]: crate::NodeBuilder::new
-    /// [3]: crate::Node::builder
-    ///
-    /// # Example
-    /// ```
-    /// # use rclrs::{Context, RclrsError};
-    /// let context = Context::new([])?;
-    /// let node_builder = context.create_node_builder("my_node");
-    /// let node = node_builder.build()?;
-    /// assert_eq!(node.name(), "my_node");
-    /// # Ok::<(), RclrsError>(())
-    /// ```
-    pub fn create_node_builder(&self, node_name: &str) -> NodeBuilder {
-        Node::builder(self, node_name)
-    }
-
     /// Checks if the context is still valid.
     ///
     /// This will return `false` when a signal has caused the context to shut down (currently

rclrs/src/lib.rs

@@ -75,3 +75,44 @@ pub fn spin(node: &Node) -> Result<(), RclrsError> {
 
     Ok(())
 }
+
+/// Creates a new node in the empty namespace.
+///
+/// Convenience function equivalent to [`Node::new`][1].
+/// Please see that function's documentation.
+///
+/// [1]: crate::Node::new
+///
+/// # Example
+/// ```
+/// # use rclrs::{Context, RclrsError};
+/// let ctx = Context::new([])?;
+/// let node = rclrs::create_node(&ctx, "my_node");
+/// assert!(node.is_ok());
+/// # Ok::<(), RclrsError>(())
+/// ```
+pub fn create_node(context: &Context, node_name: &str) -> Result<Node, RclrsError> {
+    Node::builder(context, node_name).build()
+}
+
+/// Creates a [`NodeBuilder`][1].
+///
+/// Convenience function equivalent to [`NodeBuilder::new()`][2] and [`Node::builder()`][3].
+/// Please see that function's documentation.
+///
+/// [1]: crate::NodeBuilder
+/// [2]: crate::NodeBuilder::new
+/// [3]: crate::Node::builder
+///
+/// # Example
+/// ```
+/// # use rclrs::{Context, RclrsError};
+/// let context = Context::new([])?;
+/// let node_builder = rclrs::create_node_builder(&context, "my_node");
+/// let node = node_builder.build()?;
+/// assert_eq!(node.name(), "my_node");
+/// # Ok::<(), RclrsError>(())
+/// ```
+pub fn create_node_builder(context: &Context, node_name: &str) -> NodeBuilder {
+    Node::builder(context, node_name)
+}

rclrs/src/node.rs

@@ -106,12 +106,12 @@ impl Node {
     /// # use rclrs::{Context, RclrsError};
     /// // Without remapping
     /// let context = Context::new([])?;
-    /// let node = context.create_node("my_node")?;
+    /// let node = rclrs::create_node(&context, "my_node")?;
     /// assert_eq!(node.name(), "my_node");
     /// // With remapping
     /// let remapping = ["--ros-args", "-r", "__node:=your_node"].map(String::from);
     /// let context_r = Context::new(remapping)?;
-    /// let node_r = context_r.create_node("my_node")?;
+    /// let node_r = rclrs::create_node(&context_r, "my_node")?;
     /// assert_eq!(node_r.name(), "your_node");
     /// # Ok::<(), RclrsError>(())
     /// ```
@@ -129,15 +129,15 @@ impl Node {
     /// # use rclrs::{Context, RclrsError};
     /// // Without remapping
     /// let context = Context::new([])?;
-    /// let node = context
-    ///   .create_node_builder("my_node")
+    /// let node =
+    ///   rclrs::create_node_builder(&context, "my_node")
     ///   .namespace("/my/namespace")
     ///   .build()?;
     /// assert_eq!(node.namespace(), "/my/namespace");
     /// // With remapping
     /// let remapping = ["--ros-args", "-r", "__ns:=/your_namespace"].map(String::from);
     /// let context_r = Context::new(remapping)?;
-    /// let node_r = context_r.create_node("my_node")?;
+    /// let node_r = rclrs::create_node(&context_r, "my_node")?;
     /// assert_eq!(node_r.namespace(), "/your_namespace");
     /// # Ok::<(), RclrsError>(())
     /// ```
@@ -154,8 +154,8 @@ impl Node {
     /// ```
     /// # use rclrs::{Context, RclrsError};
     /// let context = Context::new([])?;
-    /// let node = context
-    ///   .create_node_builder("my_node")
+    /// let node =
+    ///   rclrs::create_node_builder(&context, "my_node")
     ///   .namespace("/my/namespace")
     ///   .build()?;
     /// assert_eq!(node.fully_qualified_name(), "/my/namespace/my_node");
@@ -240,7 +240,7 @@ impl Node {
     /// // Set default ROS domain ID to 10 here
     /// std::env::set_var("ROS_DOMAIN_ID", "10");
     /// let context = Context::new([])?;
-    /// let node = context.create_node("domain_id_node")?;
+    /// let node = rclrs::create_node(&context, "domain_id_node")?;
     /// let domain_id = node.domain_id();
     /// assert_eq!(domain_id, 10);
     /// # Ok::<(), RclrsError>(())

rclrs/src/node/builder.rs

@@ -159,14 +159,14 @@ impl NodeBuilder {
     ///   .map(String::from);
     /// let context = Context::new(context_args)?;
     /// // Ignore the global arguments:
-    /// let node_without_global_args = context
-    ///   .create_node_builder("my_node")
+    /// let node_without_global_args =
+    ///   rclrs::create_node_builder(&context, "my_node")
     ///   .use_global_arguments(false)
     ///   .build()?;
     /// assert_eq!(node_without_global_args.name(), "my_node");
     /// // Do not ignore the global arguments:
-    /// let node_with_global_args = context
-    ///   .create_node_builder("my_other_node")
+    /// let node_with_global_args =
+    ///   rclrs::create_node_builder(&context, "my_other_node")
     ///   .use_global_arguments(true)
     ///   .build()?;
     /// assert_eq!(node_with_global_args.name(), "your_node");
@@ -197,8 +197,8 @@ impl NodeBuilder {
     /// // But the node arguments will change it to "node_args_node":
     /// let node_args = ["--ros-args", "--remap", "my_node:__node:=node_args_node"]
     ///   .map(String::from);
-    /// let node = context
-    ///   .create_node_builder("my_node")
+    /// let node =
+    ///   rclrs::create_node_builder(&context, "my_node")
     ///   .arguments(node_args)
     ///   .build()?;
     /// assert_eq!(node.name(), "node_args_node");