Fix formatting

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

Author: mxgrey

examples/message_demo/src/message_demo.rs

@@ -141,8 +141,10 @@ fn demonstrate_pubsub() -> Result<(), Error> {
     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")?;
-    let direct_publisher = node.create_publisher::<rclrs_example_msgs::msg::rmw::VariousTypes>("topic")?;
+    let idiomatic_publisher =
+        node.create_publisher::<rclrs_example_msgs::msg::VariousTypes>("topic")?;
+    let direct_publisher =
+        node.create_publisher::<rclrs_example_msgs::msg::rmw::VariousTypes>("topic")?;
 
     let _idiomatic_subscription = node
         .create_subscription::<rclrs_example_msgs::msg::VariousTypes, _>(

examples/minimal_client_service/src/minimal_client.rs

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

examples/minimal_client_service/src/minimal_client_async.rs

@@ -20,7 +20,8 @@ async fn main() -> Result<(), Error> {
 
     println!("Waiting for response");
 
-    let rclrs_spin = tokio::task::spawn_blocking(move || executor.spin(rclrs::SpinOptions::default()));
+    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

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

examples/minimal_pub_sub/src/minimal_subscriber.rs

@@ -17,5 +17,7 @@ fn main() -> Result<(), Error> {
         },
     )?;
 
-    executor.spin(rclrs::SpinOptions::default()).map_err(|err| err.into())
+    executor
+        .spin(rclrs::SpinOptions::default())
+        .map_err(|err| err.into())
 }

examples/minimal_pub_sub/src/minimal_two_nodes.rs

@@ -12,7 +12,11 @@ struct MinimalSubscriber {
 }
 
 impl MinimalSubscriber {
-    pub fn new(executor: &rclrs::Executor, name: &str, topic: &str) -> Result<Arc<Self>, rclrs::RclrsError> {
+    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(),
@@ -48,8 +52,10 @@ fn main() -> Result<(), Error> {
     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(&executor, "minimal_subscriber_one", "topic")?;
-    let _subscriber_node_two = MinimalSubscriber::new(&executor, "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")?;
 
@@ -65,5 +71,7 @@ fn main() -> Result<(), Error> {
         }
     });
 
-    executor.spin(rclrs::SpinOptions::default()).map_err(|err| err.into())
+    executor
+        .spin(rclrs::SpinOptions::default())
+        .map_err(|err| err.into())
 }

examples/minimal_pub_sub/src/zero_copy_subscriber.rs

@@ -16,5 +16,7 @@ fn main() -> Result<(), Error> {
         },
     )?;
 
-    executor.spin(rclrs::SpinOptions::default()).map_err(|err| err.into())
+    executor
+        .spin(rclrs::SpinOptions::default())
+        .map_err(|err| err.into())
 }

examples/rust_pubsub/src/simple_subscriber.rs

@@ -17,17 +17,11 @@ impl SimpleSubscriptionNode {
         let data: Arc<Mutex<Option<StringMsg>>> = Arc::new(Mutex::new(None));
         let data_mut: Arc<Mutex<Option<StringMsg>>> = Arc::clone(&data);
         let _subscriber = node
-            .create_subscription::<StringMsg, _>(
-                "publish_hello",
-                move |msg: StringMsg| {
-                    *data_mut.lock().unwrap() = Some(msg);
-                },
-            )
+            .create_subscription::<StringMsg, _>("publish_hello", move |msg: StringMsg| {
+                *data_mut.lock().unwrap() = Some(msg);
+            })
             .unwrap();
-        Ok(Self {
-            _subscriber,
-            data,
-        })
+        Ok(Self { _subscriber, data })
     }
     fn data_callback(&self) -> Result<(), RclrsError> {
         if let Some(data) = self.data.lock().unwrap().as_ref() {

rclrs/src/client.rs

@@ -11,7 +11,7 @@ use rosidl_runtime_rs::Message;
 use crate::{
     error::{RclReturnCode, ToResult},
     rcl_bindings::*,
-    IntoPrimitiveOptions, MessageCow, NodeHandle, RclrsError, ENTITY_LIFECYCLE_MUTEX, QoSProfile,
+    IntoPrimitiveOptions, MessageCow, NodeHandle, QoSProfile, RclrsError, ENTITY_LIFECYCLE_MUTEX,
 };
 
 // SAFETY: The functions accessing this type, including drop(), shouldn't care about the thread
@@ -97,10 +97,11 @@ where
         let mut rcl_client = unsafe { rcl_get_zero_initialized_client() };
         let type_support = <T as rosidl_runtime_rs::Service>::get_type_support()
             as *const rosidl_service_type_support_t;
-        let topic_c_string = CString::new(service_name).map_err(|err| RclrsError::StringContainsNul {
-            err,
-            s: service_name.into(),
-        })?;
+        let topic_c_string =
+            CString::new(service_name).map_err(|err| RclrsError::StringContainsNul {
+                err,
+                s: service_name.into(),
+            })?;
 
         // SAFETY: No preconditions for this function.
         let mut client_options = unsafe { rcl_client_get_default_options() };
@@ -296,7 +297,10 @@ pub struct ClientOptions<'a> {
 impl<'a> ClientOptions<'a> {
     /// Initialize a new [`ClientOptions`] with default settings.
     pub fn new(service_name: &'a str) -> Self {
-        Self { service_name, qos: QoSProfile::services_default() }
+        Self {
+            service_name,
+            qos: QoSProfile::services_default(),
+        }
     }
 }
 

rclrs/src/context.rs

@@ -6,7 +6,7 @@ use std::{
     vec::Vec,
 };
 
-use crate::{rcl_bindings::*, RclrsError, ToResult, Executor};
+use crate::{rcl_bindings::*, Executor, RclrsError, ToResult};
 
 /// This is locked whenever initializing or dropping any middleware entity
 /// because we have found issues in RCL and some RMW implementations that
@@ -74,8 +74,7 @@ impl Default for Context {
     fn default() -> Self {
         // SAFETY: It should always be valid to instantiate a context with no
         // arguments, no parameters, no options, etc.
-        Self::new([], InitOptions::default())
-        .expect("Failed to instantiate a default context")
+        Self::new([], InitOptions::default()).expect("Failed to instantiate a default context")
     }
 }