Update examples

Signed-off-by: Michael X. Grey <[email protected]>

Author: mxgrey

examples/message_demo/src/message_demo.rs

@@ -1,4 +1,4 @@
-use std::{convert::TryInto, env, sync::Arc};
+use std::convert::TryInto;
 
 use anyhow::{Error, Result};
 use rosidl_runtime_rs::{seq, BoundedSequence, Message, Sequence};
@@ -138,8 +138,8 @@ fn demonstrate_sequences() {
 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 node = rclrs::create_node(&context, "message_demo")?;
+    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
+    let node = executor.create_node("message_demo")?;
 
     let idiomatic_publisher = node.create_publisher::<rclrs_example_msgs::msg::VariousTypes>(
         "topic",
@@ -166,10 +166,10 @@ fn demonstrate_pubsub() -> Result<(), Error> {
         )?;
     println!("Sending idiomatic message.");
     idiomatic_publisher.publish(rclrs_example_msgs::msg::VariousTypes::default())?;
-    rclrs::spin_once(Arc::clone(&node), None)?;
+    executor.spin(rclrs::SpinOptions::spin_once())?;
     println!("Sending RMW-native message.");
     direct_publisher.publish(rclrs_example_msgs::msg::rmw::VariousTypes::default())?;
-    rclrs::spin_once(Arc::clone(&node), None)?;
+    executor.spin(rclrs::SpinOptions::spin_once())?;
 
     Ok(())
 }

examples/minimal_client_service/src/minimal_client.rs

@@ -1,11 +1,9 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_client")?;
+    let node = executor.create_node("minimal_client")?;
 
     let client = node.create_client::<example_interfaces::srv::AddTwoInts>("add_two_ints")?;
 
@@ -30,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())
+    executor.spin(rclrs::SpinOptions::default()).map_err(|err| err.into())
 }

examples/minimal_client_service/src/minimal_client_async.rs

@@ -1,12 +1,10 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 #[tokio::main]
 async fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_client")?;
+    let node = executor.create_node("minimal_client")?;
 
     let client = node.create_client::<example_interfaces::srv::AddTwoInts>("add_two_ints")?;
 
@@ -22,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 || executor.spin(rclrs::SpinOptions::default()));
 
     let response = future.await?;
     println!(

examples/minimal_client_service/src/minimal_service.rs

@@ -1,5 +1,3 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 fn handle_service(
@@ -13,13 +11,13 @@ fn handle_service(
 }
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_service")?;
+    let node = executor.create_node("minimal_service")?;
 
     let _server = node
         .create_service::<example_interfaces::srv::AddTwoInts, _>("add_two_ints", handle_service)?;
 
     println!("Starting server");
-    rclrs::spin(node).map_err(|err| err.into())
+    executor.spin(rclrs::SpinOptions::default()).map_err(|err| err.into())
 }

examples/minimal_pub_sub/src/minimal_publisher.rs

@@ -1,11 +1,10 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let context = rclrs::Context::default_from_env()?;
+    let executor = context.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_publisher")?;
+    let node = executor.create_node("minimal_publisher")?;
 
     let publisher =
         node.create_publisher::<std_msgs::msg::String>("topic", rclrs::QOS_PROFILE_DEFAULT)?;

examples/minimal_pub_sub/src/minimal_subscriber.rs

@@ -1,11 +1,10 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let context = rclrs::Context::default_from_env()?;
+    let mut executor = context.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_subscriber")?;
+    let node = executor.create_node("minimal_subscriber")?;
 
     let mut num_messages: usize = 0;
 
@@ -19,5 +18,5 @@ fn main() -> Result<(), Error> {
         },
     )?;
 
-    rclrs::spin(node).map_err(|err| err.into())
+    executor.spin(rclrs::SpinOptions::default()).map_err(|err| err.into())
 }

examples/minimal_pub_sub/src/minimal_two_nodes.rs

@@ -1,23 +1,19 @@
-use std::{
-    env,
-    sync::{
-        atomic::{AtomicU32, Ordering},
-        Arc, Mutex,
-    },
+use std::sync::{
+    atomic::{AtomicU32, Ordering},
+    Arc, Mutex,
 };
 
 use anyhow::{Error, Result};
 
 struct MinimalSubscriber {
     num_messages: AtomicU32,
-    node: Arc<rclrs::Node>,
+    node: rclrs::Node,
     subscription: Mutex<Option<Arc<rclrs::Subscription<std_msgs::msg::String>>>>,
 }
 
 impl MinimalSubscriber {
-    pub fn new(name: &str, topic: &str) -> Result<Arc<Self>, rclrs::RclrsError> {
-        let context = rclrs::Context::new(env::args())?;
-        let node = rclrs::create_node(&context, name)?;
+    pub fn new(executor: &rclrs::Executor, name: &str, topic: &str) -> Result<Arc<Self>, rclrs::RclrsError> {
+        let node = executor.create_node(name)?;
         let minimal_subscriber = Arc::new(MinimalSubscriber {
             num_messages: 0.into(),
             node,
@@ -50,11 +46,11 @@ impl MinimalSubscriber {
 }
 
 fn main() -> Result<(), Error> {
-    let publisher_context = rclrs::Context::new(env::args())?;
-    let publisher_node = rclrs::create_node(&publisher_context, "minimal_publisher")?;
+    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
+    let publisher_node = executor.create_node("minimal_publisher")?;
 
-    let subscriber_node_one = MinimalSubscriber::new("minimal_subscriber_one", "topic")?;
-    let subscriber_node_two = MinimalSubscriber::new("minimal_subscriber_two", "topic")?;
+    let _subscriber_node_one = MinimalSubscriber::new(&executor, "minimal_subscriber_one", "topic")?;
+    let _subscriber_node_two = MinimalSubscriber::new(&executor, "minimal_subscriber_two", "topic")?;
 
     let publisher = publisher_node
         .create_publisher::<std_msgs::msg::String>("topic", rclrs::QOS_PROFILE_DEFAULT)?;
@@ -71,11 +67,5 @@ fn main() -> Result<(), Error> {
         }
     });
 
-    let executor = rclrs::SingleThreadedExecutor::new();
-
-    executor.add_node(&publisher_node)?;
-    executor.add_node(&subscriber_node_one.node)?;
-    executor.add_node(&subscriber_node_two.node)?;
-
-    executor.spin().map_err(|err| err.into())
+    executor.spin(rclrs::SpinOptions::default()).map_err(|err| err.into())
 }

examples/minimal_pub_sub/src/zero_copy_publisher.rs

@@ -1,11 +1,10 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let context = rclrs::Context::default_from_env()?;
+    let executor = context.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_publisher")?;
+    let node = executor.create_node("minimal_publisher")?;
 
     let publisher =
         node.create_publisher::<std_msgs::msg::rmw::UInt32>("topic", rclrs::QOS_PROFILE_DEFAULT)?;

examples/minimal_pub_sub/src/zero_copy_subscriber.rs

@@ -1,11 +1,9 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_subscriber")?;
+    let node = executor.create_node("minimal_subscriber")?;
 
     let mut num_messages: usize = 0;
 
@@ -19,5 +17,5 @@ fn main() -> Result<(), Error> {
         },
     )?;
 
-    rclrs::spin(node).map_err(|err| err.into())
+    executor.spin(rclrs::SpinOptions::default()).map_err(|err| err.into())
 }

examples/rust_pubsub/src/simple_publisher.rs

@@ -1,36 +1,37 @@
-use rclrs::{create_node, Context, Node, Publisher, RclrsError, QOS_PROFILE_DEFAULT};
+use rclrs::{Context, Executor, Publisher, RclrsError, SpinOptions, QOS_PROFILE_DEFAULT};
 use std::{sync::Arc, thread, time::Duration};
 use std_msgs::msg::String as StringMsg;
-struct SimplePublisherNode {
-    node: Arc<Node>,
-    _publisher: Arc<Publisher<StringMsg>>,
+
+struct SimplePublisher {
+    publisher: Arc<Publisher<StringMsg>>,
 }
-impl SimplePublisherNode {
-    fn new(context: &Context) -> Result<Self, RclrsError> {
-        let node = create_node(context, "simple_publisher").unwrap();
-        let _publisher = node
+
+impl SimplePublisher {
+    fn new(executor: &Executor) -> Result<Self, RclrsError> {
+        let node = executor.create_node("simple_publisher").unwrap();
+        let publisher = node
             .create_publisher("publish_hello", QOS_PROFILE_DEFAULT)
             .unwrap();
-        Ok(Self { node, _publisher })
+        Ok(Self { publisher })
     }
 
     fn publish_data(&self, increment: i32) -> Result<i32, RclrsError> {
         let msg: StringMsg = StringMsg {
             data: format!("Hello World {}", increment),
         };
-        self._publisher.publish(msg).unwrap();
+        self.publisher.publish(msg).unwrap();
         Ok(increment + 1_i32)
     }
 }
 
 fn main() -> Result<(), RclrsError> {
-    let context = Context::new(std::env::args()).unwrap();
-    let publisher = Arc::new(SimplePublisherNode::new(&context).unwrap());
+    let mut executor = Context::default_from_env().unwrap().create_basic_executor();
+    let publisher = Arc::new(SimplePublisher::new(&executor).unwrap());
     let publisher_other_thread = Arc::clone(&publisher);
     let mut count: i32 = 0;
     thread::spawn(move || loop {
         thread::sleep(Duration::from_millis(1000));
         count = publisher_other_thread.publish_data(count).unwrap();
     });
-    rclrs::spin(publisher.node.clone())
+    executor.spin(SpinOptions::default())
 }

examples/rust_pubsub/src/simple_subscriber.rs

@@ -1,19 +1,19 @@
-use rclrs::{create_node, Context, Node, RclrsError, Subscription, QOS_PROFILE_DEFAULT};
+use rclrs::{Context, Executor, RclrsError, SpinOptions, Subscription, QOS_PROFILE_DEFAULT};
 use std::{
-    env,
     sync::{Arc, Mutex},
     thread,
     time::Duration,
 };
 use std_msgs::msg::String as StringMsg;
+
 pub struct SimpleSubscriptionNode {
-    node: Arc<Node>,
     _subscriber: Arc<Subscription<StringMsg>>,
     data: Arc<Mutex<Option<StringMsg>>>,
 }
+
 impl SimpleSubscriptionNode {
-    fn new(context: &Context) -> Result<Self, RclrsError> {
-        let node = create_node(context, "simple_subscription").unwrap();
+    fn new(executor: &Executor) -> Result<Self, RclrsError> {
+        let node = executor.create_node("simple_subscription").unwrap();
         let data: Arc<Mutex<Option<StringMsg>>> = Arc::new(Mutex::new(None));
         let data_mut: Arc<Mutex<Option<StringMsg>>> = Arc::clone(&data);
         let _subscriber = node
@@ -26,7 +26,6 @@ impl SimpleSubscriptionNode {
             )
             .unwrap();
         Ok(Self {
-            node,
             _subscriber,
             data,
         })
@@ -41,12 +40,12 @@ impl SimpleSubscriptionNode {
     }
 }
 fn main() -> Result<(), RclrsError> {
-    let context = Context::new(env::args()).unwrap();
-    let subscription = Arc::new(SimpleSubscriptionNode::new(&context).unwrap());
+    let mut executor = Context::default_from_env().unwrap().create_basic_executor();
+    let subscription = Arc::new(SimpleSubscriptionNode::new(&executor).unwrap());
     let subscription_other_thread = Arc::clone(&subscription);
     thread::spawn(move || loop {
         thread::sleep(Duration::from_millis(1000));
         subscription_other_thread.data_callback().unwrap()
     });
-    rclrs::spin(subscription.node.clone())
+    executor.spin(SpinOptions::default())
 }