Update spin* to take an Arc

docs/writing-your-first-rclrs-node.md

@@ -76,7 +76,7 @@ Next, add a main function to launch it:
 fn main() -> Result<(), rclrs::RclrsError> {
  let context = rclrs::Context::new(std::env::args())?;
  let republisher = RepublisherNode::new(&context)?;
- rclrs::spin(&republisher.node)
+ rclrs::spin(republisher.node)
 }
 ```
 
@@ -190,7 +190,7 @@ fn main() -> Result<(), rclrs::RclrsError> {
  republisher.republish()?;
  }
  });
- rclrs::spin(&republisher.node)
+ rclrs::spin(republisher.node)
 }
 ```
 
@@ -212,7 +212,7 @@ fn main() -> Result<(), rclrs::RclrsError> {
  republisher_other_thread.republish()?;
  }
  });
- rclrs::spin(&republisher.node)
+ rclrs::spin(republisher.node)
 }
 ```
 

examples/message_demo/src/message_demo.rs

@@ -1,5 +1,6 @@
 use std::convert::TryInto;
 use std::env;
+use std::sync::Arc;
 
 use anyhow::{Error, Result};
 use rosidl_runtime_rs::{seq, BoundedSequence, Message, Sequence};
@@ -159,10 +160,10 @@ fn demonstrate_pubsub() -> Result<(), Error> {
  )?;
  println!("Sending idiomatic message.");
  idiomatic_publisher.publish(rclrs_example_msgs::msg::VariousTypes::default())?;
- rclrs::spin_once(&node, None)?;
+ rclrs::spin_once(Arc::clone(&node), None)?;
  println!("Sending RMW-native message.");
  direct_publisher.publish(rclrs_example_msgs::msg::rmw::VariousTypes::default())?;
- rclrs::spin_once(&node, None)?;
+ rclrs::spin_once(Arc::clone(&node), None)?;
 
  Ok(())
 }

examples/minimal_client_service/src/minimal_client.rs

@@ -28,5 +28,5 @@ fn main() -> Result<(), Error> {
  std::thread::sleep(std::time::Duration::from_millis(500));
 
  println!("Waiting for response");
- rclrs::spin(&node).map_err(|err| err.into())
+ rclrs::spin(node).map_err(|err| err.into())
 }

examples/minimal_client_service/src/minimal_client_async.rs

@@ -20,7 +20,7 @@ async fn main() -> Result<(), Error> {
 
  println!("Waiting for response");
 
- let rclrs_spin = tokio::task::spawn_blocking(move || rclrs::spin(&node));
+ let rclrs_spin = tokio::task::spawn_blocking(move || rclrs::spin(node));
 
  let response = future.await?;
  println!(

examples/minimal_client_service/src/minimal_service.rs

@@ -21,5 +21,5 @@ fn main() -> Result<(), Error> {
  .create_service::<example_interfaces::srv::AddTwoInts, _>("add_two_ints", handle_service)?;
 
  println!("Starting server");
- rclrs::spin(&node).map_err(|err| err.into())
+ rclrs::spin(node).map_err(|err| err.into())
 }

examples/minimal_pub_sub/src/minimal_subscriber.rs

@@ -19,5 +19,5 @@ fn main() -> Result<(), Error> {
  },
  )?;
 
- rclrs::spin(&node).map_err(|err| err.into())
+ rclrs::spin(node).map_err(|err| err.into())
 }

examples/minimal_pub_sub/src/zero_copy_subscriber.rs

@@ -19,5 +19,5 @@ fn main() -> Result<(), Error> {
  },
  )?;
 
- rclrs::spin(&node).map_err(|err| err.into())
+ rclrs::spin(node).map_err(|err| err.into())
 }

rclrs/src/lib.rs

@@ -50,8 +50,8 @@ pub use wait::*;
 /// This can usually be ignored.
 ///
 /// [1]: crate::RclReturnCode
-pub fn spin_once(node: &Node, timeout: Option<Duration>) -> Result<(), RclrsError> {
- let wait_set = WaitSet::new_for_node(node)?;
+pub fn spin_once(node: Arc<Node>, timeout: Option<Duration>) -> Result<(), RclrsError> {
+ let wait_set = WaitSet::new_for_node(&*node)?;
  let ready_entities = wait_set.wait(timeout)?;
 
  for ready_subscription in ready_entities.subscriptions {
@@ -72,19 +72,21 @@ pub fn spin_once(node: &Node, timeout: Option<Duration>) -> Result<(), RclrsErro
 /// Convenience function for calling [`spin_once`] in a loop.
 ///
 /// This function additionally checks that the context is still valid.
-pub fn spin(node: &Node) -> Result<(), RclrsError> {
+pub fn spin(node: Arc<Node>) -> Result<(), RclrsError> {
  // The context_is_valid functions exists only to abstract away ROS distro differences
  #[cfg(ros_distro = "foxy")]
  // SAFETY: No preconditions for this function.
  let context_is_valid =
  || unsafe { rcl_context_is_valid(&mut *node.rcl_context_mtx.lock().unwrap()) };
  #[cfg(not(ros_distro = "foxy"))]
  // SAFETY: No preconditions for this function.
- let context_is_valid =
- || unsafe { rcl_context_is_valid(&*node.rcl_context_mtx.lock().unwrap()) };
+ let context_is_valid = {
+ let node = Arc::clone(&node);
+ move || unsafe { rcl_context_is_valid(&*node.rcl_context_mtx.lock().unwrap()) }
+ };
 
  while context_is_valid() {
- match spin_once(node, None) {
+ match spin_once(Arc::clone(&node), None) {
  Ok(_)
  | Err(RclrsError::RclError {
  code: RclReturnCode::Timeout,