Introduce CreateBasicExecutor trait

mxgrey · mxgrey · commit a75cd24455d0 · 2025-01-14T12:52:11.000+08:00
Signed-off-by: Michael X. Grey &lt;greyxmike@gmail.com&gt;
diff --git a/examples/message_demo/src/message_demo.rs b/examples/message_demo/src/message_demo.rs
@@ -3,7 +3,7 @@ use std::convert::TryInto;
 use anyhow::{Error, Result};
 use rosidl_runtime_rs::{seq, BoundedSequence, Message, Sequence};
 
-use rclrs::RclrsErrorFilter;
+use rclrs::*;
 
 fn check_default_values() {
     let msg = rclrs_example_msgs::msg::rmw::VariousTypes::default();
@@ -140,41 +140,41 @@ fn demonstrate_sequences() {
 fn demonstrate_pubsub() -> Result<(), Error> {
     println!("================== Interoperability demo ==================");
     // Demonstrate interoperability between idiomatic and RMW-native message types
-    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
+    let mut executor = 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",
-        rclrs::QOS_PROFILE_DEFAULT,
+        QOS_PROFILE_DEFAULT,
     )?;
     let direct_publisher = node.create_publisher::<rclrs_example_msgs::msg::rmw::VariousTypes>(
         "topic",
-        rclrs::QOS_PROFILE_DEFAULT,
+        QOS_PROFILE_DEFAULT,
     )?;
 
     let _idiomatic_subscription = node
         .create_subscription::<rclrs_example_msgs::msg::VariousTypes, _>(
             "topic",
-            rclrs::QOS_PROFILE_DEFAULT,
+            QOS_PROFILE_DEFAULT,
             move |_msg: rclrs_example_msgs::msg::VariousTypes| println!("Got idiomatic message!"),
         )?;
     let _direct_subscription = node
         .create_subscription::<rclrs_example_msgs::msg::rmw::VariousTypes, _>(
             "topic",
-            rclrs::QOS_PROFILE_DEFAULT,
+            QOS_PROFILE_DEFAULT,
             move |_msg: rclrs_example_msgs::msg::rmw::VariousTypes| {
                 println!("Got RMW-native message!")
             },
         )?;
     println!("Sending idiomatic message.");
     idiomatic_publisher.publish(rclrs_example_msgs::msg::VariousTypes::default())?;
     executor
-        .spin(rclrs::SpinOptions::spin_once())
+        .spin(SpinOptions::spin_once())
         .first_error()?;
     println!("Sending RMW-native message.");
     direct_publisher.publish(rclrs_example_msgs::msg::rmw::VariousTypes::default())?;
     executor
-        .spin(rclrs::SpinOptions::spin_once())
+        .spin(SpinOptions::spin_once())
         .first_error()?;
 
     Ok(())
diff --git a/examples/minimal_client_service/src/minimal_client.rs b/examples/minimal_client_service/src/minimal_client.rs
@@ -1,8 +1,8 @@
 use anyhow::{Error, Result};
-use rclrs::RclrsErrorFilter;
+use rclrs::*;
 
 fn main() -> Result<(), Error> {
-    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
+    let mut executor = Context::default_from_env()?.create_basic_executor();
 
     let node = executor.create_node("minimal_client")?;
 
@@ -30,7 +30,7 @@ fn main() -> Result<(), Error> {
 
     println!("Waiting for response");
     executor
-        .spin(rclrs::SpinOptions::default())
+        .spin(SpinOptions::default())
         .first_error()
         .map_err(|err| err.into())
 }
diff --git a/examples/minimal_client_service/src/minimal_client_async.rs b/examples/minimal_client_service/src/minimal_client_async.rs
@@ -1,8 +1,9 @@
 use anyhow::{Error, Result};
+use rclrs::*;
 
 #[tokio::main]
 async fn main() -> Result<(), Error> {
-    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
+    let mut executor = Context::default_from_env()?.create_basic_executor();
 
     let node = executor.create_node("minimal_client")?;
 
@@ -21,7 +22,7 @@ async fn main() -> Result<(), Error> {
     println!("Waiting for response");
 
     let rclrs_spin =
-        tokio::task::spawn_blocking(move || executor.spin(rclrs::SpinOptions::default()));
+        tokio::task::spawn_blocking(move || executor.spin(SpinOptions::default()));
 
     let response = future.await?;
     println!(
diff --git a/examples/minimal_client_service/src/minimal_service.rs b/examples/minimal_client_service/src/minimal_service.rs
@@ -1,5 +1,5 @@
 use anyhow::{Error, Result};
-use rclrs::RclrsErrorFilter;
+use rclrs::*;
 
 fn handle_service(
     _request_header: &rclrs::rmw_request_id_t,
@@ -12,7 +12,7 @@ fn handle_service(
 }
 
 fn main() -> Result<(), Error> {
-    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
+    let mut executor = Context::default_from_env()?.create_basic_executor();
 
     let node = executor.create_node("minimal_service")?;
 
@@ -21,7 +21,7 @@ fn main() -> Result<(), Error> {
 
     println!("Starting server");
     executor
-        .spin(rclrs::SpinOptions::default())
+        .spin(SpinOptions::default())
         .first_error()
         .map_err(|err| err.into())
 }
diff --git a/examples/minimal_pub_sub/src/minimal_publisher.rs b/examples/minimal_pub_sub/src/minimal_publisher.rs
@@ -1,13 +1,14 @@
 use anyhow::{Error, Result};
+use rclrs::*;
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::default_from_env()?;
+    let context = Context::default_from_env()?;
     let executor = context.create_basic_executor();
 
     let node = executor.create_node("minimal_publisher")?;
 
     let publisher =
-        node.create_publisher::<std_msgs::msg::String>("topic", rclrs::QOS_PROFILE_DEFAULT)?;
+        node.create_publisher::<std_msgs::msg::String>("topic", QOS_PROFILE_DEFAULT)?;
 
     let mut message = std_msgs::msg::String::default();
 
diff --git a/examples/minimal_pub_sub/src/minimal_subscriber.rs b/examples/minimal_pub_sub/src/minimal_subscriber.rs
@@ -1,8 +1,8 @@
 use anyhow::{Error, Result};
-use rclrs::RclrsErrorFilter;
+use rclrs::*;
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::default_from_env()?;
+    let context = Context::default_from_env()?;
     let mut executor = context.create_basic_executor();
 
     let node = executor.create_node("minimal_subscriber")?;
@@ -11,7 +11,7 @@ fn main() -> Result<(), Error> {
 
     let _subscription = node.create_subscription::<std_msgs::msg::String, _>(
         "topic",
-        rclrs::QOS_PROFILE_DEFAULT,
+        QOS_PROFILE_DEFAULT,
         move |msg: std_msgs::msg::String| {
             num_messages += 1;
             println!("I heard: '{}'", msg.data);
@@ -20,7 +20,7 @@ fn main() -> Result<(), Error> {
     )?;
 
     executor
-        .spin(rclrs::SpinOptions::default())
+        .spin(SpinOptions::default())
         .first_error()
         .map_err(|err| err.into())
 }
diff --git a/examples/minimal_pub_sub/src/minimal_two_nodes.rs b/examples/minimal_pub_sub/src/minimal_two_nodes.rs
@@ -1,4 +1,4 @@
-use rclrs::RclrsErrorFilter;
+use rclrs::*;
 use std::sync::{
     atomic::{AtomicU32, Ordering},
     Arc, Mutex,
@@ -8,16 +8,16 @@ use anyhow::{Error, Result};
 
 struct MinimalSubscriber {
     num_messages: AtomicU32,
-    node: Arc<rclrs::Node>,
-    subscription: Mutex<Option<Arc<rclrs::Subscription<std_msgs::msg::String>>>>,
+    node: Arc<Node>,
+    subscription: Mutex<Option<Arc<Subscription<std_msgs::msg::String>>>>,
 }
 
 impl MinimalSubscriber {
     pub fn new(
-        executor: &rclrs::Executor,
+        executor: &Executor,
         name: &str,
         topic: &str,
-    ) -> Result<Arc<Self>, rclrs::RclrsError> {
+    ) -> Result<Arc<Self>, RclrsError> {
         let node = executor.create_node(name)?;
         let minimal_subscriber = Arc::new(MinimalSubscriber {
             num_messages: 0.into(),
@@ -30,7 +30,7 @@ impl MinimalSubscriber {
             .node
             .create_subscription::<std_msgs::msg::String, _>(
                 topic,
-                rclrs::QOS_PROFILE_DEFAULT,
+                QOS_PROFILE_DEFAULT,
                 move |msg: std_msgs::msg::String| {
                     minimal_subscriber_aux.callback(msg);
                 },
@@ -51,7 +51,7 @@ impl MinimalSubscriber {
 }
 
 fn main() -> Result<(), Error> {
-    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
+    let mut executor = Context::default_from_env()?.create_basic_executor();
     let publisher_node = executor.create_node("minimal_publisher")?;
 
     let _subscriber_node_one =
@@ -60,9 +60,9 @@ fn main() -> Result<(), Error> {
         MinimalSubscriber::new(&executor, "minimal_subscriber_two", "topic")?;
 
     let publisher = publisher_node
-        .create_publisher::<std_msgs::msg::String>("topic", rclrs::QOS_PROFILE_DEFAULT)?;
+        .create_publisher::<std_msgs::msg::String>("topic", QOS_PROFILE_DEFAULT)?;
 
-    std::thread::spawn(move || -> Result<(), rclrs::RclrsError> {
+    std::thread::spawn(move || -> Result<(), RclrsError> {
         let mut message = std_msgs::msg::String::default();
         let mut publish_count: u32 = 1;
         loop {
@@ -75,7 +75,7 @@ fn main() -> Result<(), Error> {
     });
 
     executor
-        .spin(rclrs::SpinOptions::default())
+        .spin(SpinOptions::default())
         .first_error()
         .map_err(|err| err.into())
 }
diff --git a/examples/minimal_pub_sub/src/zero_copy_publisher.rs b/examples/minimal_pub_sub/src/zero_copy_publisher.rs
@@ -1,13 +1,14 @@
 use anyhow::{Error, Result};
+use rclrs::*;
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::default_from_env()?;
+    let context = Context::default_from_env()?;
     let executor = context.create_basic_executor();
 
     let node = executor.create_node("minimal_publisher")?;
 
     let publisher =
-        node.create_publisher::<std_msgs::msg::rmw::UInt32>("topic", rclrs::QOS_PROFILE_DEFAULT)?;
+        node.create_publisher::<std_msgs::msg::rmw::UInt32>("topic", QOS_PROFILE_DEFAULT)?;
 
     let mut publish_count: u32 = 1;
 
diff --git a/examples/minimal_pub_sub/src/zero_copy_subscriber.rs b/examples/minimal_pub_sub/src/zero_copy_subscriber.rs
@@ -1,25 +1,25 @@
 use anyhow::{Error, Result};
-use rclrs::RclrsErrorFilter;
+use rclrs::*;
 
 fn main() -> Result<(), Error> {
-    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
+    let mut executor = Context::default_from_env()?.create_basic_executor();
 
     let node = executor.create_node("minimal_subscriber")?;
 
     let mut num_messages: usize = 0;
 
     let _subscription = node.create_subscription::<std_msgs::msg::UInt32, _>(
         "topic",
-        rclrs::QOS_PROFILE_DEFAULT,
-        move |msg: rclrs::ReadOnlyLoanedMessage<'_, std_msgs::msg::UInt32>| {
+        QOS_PROFILE_DEFAULT,
+        move |msg: ReadOnlyLoanedMessage<'_, std_msgs::msg::UInt32>| {
             num_messages += 1;
             println!("I heard: '{}'", msg.data);
             println!("(Got {} messages so far)", num_messages);
         },
     )?;
 
     executor
-        .spin(rclrs::SpinOptions::default())
+        .spin(SpinOptions::default())
         .first_error()
         .map_err(|err| err.into())
 }
diff --git a/examples/rust_pubsub/src/simple_publisher.rs b/examples/rust_pubsub/src/simple_publisher.rs
@@ -1,6 +1,4 @@
-use rclrs::{
-    Context, Executor, Publisher, RclrsError, RclrsErrorFilter, SpinOptions, QOS_PROFILE_DEFAULT,
-};
+use rclrs::*;
 use std::{sync::Arc, thread, time::Duration};
 use std_msgs::msg::String as StringMsg;
 
diff --git a/examples/rust_pubsub/src/simple_subscriber.rs b/examples/rust_pubsub/src/simple_subscriber.rs
@@ -1,6 +1,4 @@
-use rclrs::{
-    Context, Executor, RclrsError, RclrsErrorFilter, SpinOptions, Subscription, QOS_PROFILE_DEFAULT,
-};
+use rclrs::*;
 use std::{
     sync::{Arc, Mutex},
     thread,
diff --git a/rclrs/src/context.rs b/rclrs/src/context.rs
@@ -6,7 +6,7 @@ use std::{
     vec::Vec,
 };
 
-use crate::{rcl_bindings::*, Executor, LoggingLifecycle, RclrsError, ToResult};
+use crate::{rcl_bindings::*, LoggingLifecycle, RclrsError, ToResult};
 
 /// This is locked whenever initializing or dropping any middleware entity
 /// because we have found issues in RCL and some RMW implementations that
@@ -183,11 +183,6 @@ impl Context {
         Self::new(std::env::args(), InitOptions::default())
     }
 
-    /// Create a basic executor that comes built into rclrs.
-    pub fn create_basic_executor(&self) -> Executor {
-        Executor::new(Arc::clone(&self.handle))
-    }
-
     /// Returns the ROS domain ID that the context is using.
     ///
     /// The domain ID controls which nodes can send messages to each other, see the [ROS 2 concept article][1].
diff --git a/rclrs/src/executor.rs b/rclrs/src/executor.rs
@@ -1,5 +1,6 @@
 use crate::{
-    rcl_bindings::rcl_context_is_valid, ContextHandle, IntoNodeOptions, Node, RclrsError, WaitSet,
+    rcl_bindings::rcl_context_is_valid, Context, ContextHandle, IntoNodeOptions, Node, RclrsError,
+    WaitSet,
 };
 use std::{
     sync::{Arc, Mutex, Weak},
@@ -128,3 +129,15 @@ impl SpinOptions {
         self
     }
 }
+
+/// This trait allows [`Context`] to create a basic executor.
+pub trait CreateBasicExecutor {
+    /// Create a basic executor associated with this [`Context`].
+    fn create_basic_executor(&self) -> Executor;
+}
+
+impl CreateBasicExecutor for Context {
+    fn create_basic_executor(&self) -> Executor {
+        Executor::new(Arc::clone(&self.handle))
+    }
+}
diff --git a/rclrs/src/logging.rs b/rclrs/src/logging.rs
@@ -25,7 +25,7 @@ pub use logger::*;
 /// # Examples
 ///
 /// ```
-/// use rclrs::{log, ToLogParams};
+/// use rclrs::*;
 /// use std::sync::Mutex;
 /// use std::time::Duration;
 /// use std::env;
diff --git a/rclrs/src/node.rs b/rclrs/src/node.rs
@@ -150,7 +150,7 @@ impl Node {
     ///
     /// # Example
     /// ```
-    /// # use rclrs::{Context, InitOptions, RclrsError};
+    /// # use rclrs::*;
     /// // Without remapping
     /// let executor = Context::default().create_basic_executor();
     /// let node = executor.create_node("my_node")?;
@@ -173,7 +173,7 @@ impl Node {
     ///
     /// # Example
     /// ```
-    /// # use rclrs::{Context, InitOptions, RclrsError, IntoNodeOptions};
+    /// # use rclrs::*;
     /// // Without remapping
     /// let executor = Context::default().create_basic_executor();
     /// let node = executor.create_node(
@@ -199,7 +199,7 @@ impl Node {
     ///
     /// # Example
     /// ```
-    /// # use rclrs::{Context, RclrsError, IntoNodeOptions};
+    /// # use rclrs::*;
     /// let executor = Context::default().create_basic_executor();
     /// let node = executor.create_node(
     ///     "my_node"
@@ -375,7 +375,7 @@ impl Node {
     ///
     /// # Example
     /// ```
-    /// # use rclrs::{Context, RclrsError};
+    /// # use rclrs::*;
     /// // Set default ROS domain ID to 10 here
     /// std::env::set_var("ROS_DOMAIN_ID", "10");
     /// let executor = Context::default().create_basic_executor();
@@ -403,7 +403,7 @@ impl Node {
     ///
     /// # Example
     /// ```
-    /// # use rclrs::{Context, ParameterRange, RclrsError};
+    /// # use rclrs::*;
     /// let executor = Context::default().create_basic_executor();
     /// let node = executor.create_node("domain_id_node")?;
     /// // Set it to a range of 0-100, with a step of 2
diff --git a/rclrs/src/node/graph.rs b/rclrs/src/node/graph.rs
diff --git a/rclrs/src/node/node_options.rs b/rclrs/src/node/node_options.rs
diff --git a/rclrs/src/parameter.rs b/rclrs/src/parameter.rs
diff --git a/rclrs/src/parameter/service.rs b/rclrs/src/parameter/service.rs
diff --git a/rclrs/src/test_helpers/graph_helpers.rs b/rclrs/src/test_helpers/graph_helpers.rs
diff --git a/rclrs/src/time_source.rs b/rclrs/src/time_source.rs
