Move create_node and create_node_builder back to the rclrs module

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

@@ -78,6 +78,47 @@ 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)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -87,7 +128,7 @@ mod tests {
     #[test]
     fn test_spin_once() -> Result<(), RclrsError> {
         let context = Context::new(vec![]).unwrap();
-        let mut subscriber_node = context.create_node("minimal_subscriber")?;
+        let mut subscriber_node = create_node(&context, "minimal_subscriber")?;
         let num_messages = Arc::new(Mutex::new(0));
         let received_msg = Arc::new(Mutex::new(String::new()));
         let n = num_messages.clone();

rclrs/src/node.rs

@@ -107,12 +107,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>(())
     /// ```
@@ -130,15 +130,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>(())
     /// ```
@@ -155,8 +155,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");
@@ -230,7 +230,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>(())
@@ -290,7 +290,7 @@ unsafe fn call_string_getter_with_handle(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{Context, Node, QOS_PROFILE_DEFAULT};
+    use crate::{create_node, Context, Node, QOS_PROFILE_DEFAULT};
 
     #[test]
     fn test_new() -> Result<(), RclrsError> {
@@ -305,7 +305,7 @@ mod tests {
     fn test_create_subscription() -> Result<(), RclrsError> {
         let context =
             Context::new(vec![]).expect("Context instantiation is expected to be a success");
-        let mut node = context.create_node("test_create_subscription")?;
+        let mut node = create_node(&context, "test_create_subscription")?;
         let _subscription = node.create_subscription::<std_msgs::msg::String, _>(
             "topic",
             QOS_PROFILE_DEFAULT,
@@ -318,7 +318,7 @@ mod tests {
     fn test_create_publisher() -> Result<(), RclrsError> {
         let context =
             Context::new(vec![]).expect("Context instantiation is expected to be a success");
-        let node = context.create_node("test_create_publisher")?;
+        let node = create_node(&context, "test_create_publisher")?;
         let _publisher =
             node.create_publisher::<std_msgs::msg::String>("topic", QOS_PROFILE_DEFAULT)?;
         Ok(())

rclrs/src/node/builder.rs

@@ -162,14 +162,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");
@@ -200,8 +200,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");

rclrs/src/node/publisher.rs

@@ -167,14 +167,13 @@ impl<'a, T: Message> MessageCow<'a, T> for &'a T {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{Context, Publisher, QOS_PROFILE_DEFAULT};
+    use crate::{create_node, Context, Publisher, QOS_PROFILE_DEFAULT};
 
     fn create_fixture(name: &str) -> (Context, Node) {
         let context =
             Context::new(vec![]).expect("Context instantiation is expected to be a success");
-        let node = context
-            .create_node(name)
-            .expect("Node instantiation is expected to be a success");
+        let node =
+            create_node(&context, name).expect("Node instantiation is expected to be a success");
 
         (context, node)
     }

rclrs/src/node/subscription.rs

@@ -210,13 +210,13 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{Context, Subscription, QOS_PROFILE_DEFAULT};
+    use crate::{create_node, Context, Subscription, QOS_PROFILE_DEFAULT};
 
     #[test]
     fn test_instantiate_subscriber() -> Result<(), RclrsError> {
         let context =
             Context::new(vec![]).expect("Context instantiation is expected to be a success");
-        let node = context.create_node("test_new_subscriber")?;
+        let node = create_node(&context, "test_new_subscriber")?;
         let _subscriber = Subscription::<std_msgs::msg::String>::new(
             &node,
             "test",