From 42bf5d990608a79efdef5cfd3136f2691684bb2a Mon Sep 17 00:00:00 2001 From: Martin Dahl Date: Tue, 17 Aug 2021 13:22:20 +0200 Subject: [PATCH] cargo fmt --- examples/untyped_client.rs | 3 ++- rcl/src/lib.rs | 4 +-- src/action_clients.rs | 44 +++++++++++++++++--------------- src/clients.rs | 51 ++++++++++++++++---------------------- src/clocks.rs | 1 - src/context.rs | 1 - src/lib.rs | 9 ++++--- src/msg_types.rs | 8 ++---- src/nodes.rs | 50 ++++++++++++++++++++++++++----------- src/parameters.rs | 10 ++------ src/publishers.rs | 10 +++----- src/services.rs | 22 ++++++++-------- src/subscribers.rs | 1 - 13 files changed, 111 insertions(+), 103 deletions(-) diff --git a/examples/untyped_client.rs b/examples/untyped_client.rs index 99c4433..650e578 100644 --- a/examples/untyped_client.rs +++ b/examples/untyped_client.rs @@ -21,7 +21,8 @@ async fn requester_task(c: r2r::UntypedClient) -> Result<(), Box Result<(), Box> { let ctx = r2r::Context::create()?; let mut node = r2r::Node::create(ctx, "testnode", "")?; - let client = node.create_client_untyped("/add_two_ints", "example_interfaces/srv/AddTwoInts")?; + let client = + node.create_client_untyped("/add_two_ints", "example_interfaces/srv/AddTwoInts")?; // wait for service to be available println!("waiting for service..."); diff --git a/rcl/src/lib.rs b/rcl/src/lib.rs index 37b7924..a653c84 100644 --- a/rcl/src/lib.rs +++ b/rcl/src/lib.rs @@ -140,10 +140,10 @@ macro_rules! primitive_sequence { primitive_sequence!(rosidl_runtime_c__float32, f32); primitive_sequence!(rosidl_runtime_c__float64, f64); -#[cfg(all(target_os="macos", target_arch = "aarch64"))] +#[cfg(all(target_os = "macos", target_arch = "aarch64"))] primitive_sequence!(rosidl_runtime_c__long_double, f64); -#[cfg(not(all(target_os="macos", target_arch = "aarch64")))] +#[cfg(not(all(target_os = "macos", target_arch = "aarch64")))] primitive_sequence!(rosidl_runtime_c__long_double, u128); primitive_sequence!(rosidl_runtime_c__char, i8); diff --git a/src/action_clients.rs b/src/action_clients.rs index 7f24d6a..bc3e2cd 100644 --- a/src/action_clients.rs +++ b/src/action_clients.rs @@ -53,12 +53,14 @@ where &self, goal: T::Goal, ) -> Result< - impl Future, - impl Future>, - impl Stream + Unpin, - )>>> + impl Future< + Output = Result<( + ClientGoal, + impl Future>, + impl Stream + Unpin, + )>, + >, + > where T: WrappedActionTypeSupport, { @@ -112,12 +114,14 @@ where c.send_result_request(uuid.clone()); } - Ok((ClientGoal { - client: fut_client, - uuid, - }, result_receiver - .map_err(|_| Error::RCL_RET_ACTION_CLIENT_INVALID), - feedback_receiver)) + Ok(( + ClientGoal { + client: fut_client, + uuid, + }, + result_receiver.map_err(|_| Error::RCL_RET_ACTION_CLIENT_INVALID), + feedback_receiver, + )) } else { println!("goal rejected"); Err(Error::RCL_RET_ACTION_GOAL_REJECTED) @@ -137,9 +141,7 @@ pub fn make_action_client(client: Weak>>) -> Act where T: WrappedActionTypeSupport, { - ActionClient { - client - } + ActionClient { client } } pub fn action_server_available(node: &rcl_node_t, client: &ActionClient) -> Result @@ -152,9 +154,7 @@ where .ok_or(Error::RCL_RET_CLIENT_INVALID)?; let client = client.lock().unwrap(); let mut avail = false; - let result = unsafe { - rcl_action_server_is_available(node, client.handle(), &mut avail) - }; + let result = unsafe { rcl_action_server_is_available(node, client.handle(), &mut avail) }; if result == RCL_RET_OK as i32 { Ok(avail) @@ -230,7 +230,8 @@ where <::SendGoal as WrappedServiceTypeSupport>::Response, >, )>, - pub cancel_response_channels: Vec<(i64, oneshot::Sender)>, + pub cancel_response_channels: + Vec<(i64, oneshot::Sender)>, pub feedback_senders: Vec<(uuid::Uuid, mpsc::Sender)>, pub result_requests: Vec<(i64, uuid::Uuid)>, pub result_senders: Vec<(uuid::Uuid, oneshot::Sender<(GoalStatus, T::Result)>)>, @@ -265,7 +266,10 @@ where *self.goal_status.get(uuid).unwrap_or(&GoalStatus::Unknown) } - pub fn send_cancel_request(&mut self, goal: &uuid::Uuid) -> Result>> + pub fn send_cancel_request( + &mut self, + goal: &uuid::Uuid, + ) -> Result>> where T: WrappedActionTypeSupport, { diff --git a/src/clients.rs b/src/clients.rs index 0907820..31c8f39 100644 --- a/src/clients.rs +++ b/src/clients.rs @@ -18,29 +18,23 @@ where T: WrappedServiceTypeSupport, { // upgrade to actual ref. if still alive - let client = self - .client - .upgrade() - .ok_or(Error::RCL_RET_CLIENT_INVALID)?; + let client = self.client.upgrade().ok_or(Error::RCL_RET_CLIENT_INVALID)?; let mut client = client.lock().unwrap(); client.request(msg) } } -pub struct UntypedClient -{ +pub struct UntypedClient { client: Weak>, } -impl UntypedClient -{ - pub fn request(&self, msg: serde_json::Value) -> Result>>> - { +impl UntypedClient { + pub fn request( + &self, + msg: serde_json::Value, + ) -> Result>>> { // upgrade to actual ref. if still alive - let client = self - .client - .upgrade() - .ok_or(Error::RCL_RET_CLIENT_INVALID)?; + let client = self.client.upgrade().ok_or(Error::RCL_RET_CLIENT_INVALID)?; let mut client = client.lock().unwrap(); client.request(msg) } @@ -50,15 +44,11 @@ pub fn make_client(client: Weak>>) -> Client where T: WrappedServiceTypeSupport, { - Client { - client - } + Client { client } } pub fn make_untyped_client(client: Weak>) -> UntypedClient { - UntypedClient { - client - } + UntypedClient { client } } unsafe impl Send for TypedClient where T: WrappedServiceTypeSupport {} @@ -92,8 +82,10 @@ where unsafe impl Send for UntypedClient_ {} impl UntypedClient_ { - pub fn request(&mut self, msg: serde_json::Value) -> Result>>> - { + pub fn request( + &mut self, + msg: serde_json::Value, + ) -> Result>>> { let mut native_msg = (self.service_type.make_request_msg)(); native_msg.from_json(msg)?; @@ -184,15 +176,13 @@ where } } -pub struct UntypedClient_ -{ +pub struct UntypedClient_ { pub service_type: UntypedServiceSupport, pub rcl_handle: rcl_client_t, pub response_channels: Vec<(i64, oneshot::Sender>)>, } -impl Client_ for UntypedClient_ -{ +impl Client_ for UntypedClient_ { fn handle(&self) -> &rcl_client_t { &self.rcl_handle } @@ -273,9 +263,7 @@ pub fn create_client_helper( pub fn service_available_helper(node: &mut rcl_node_t, client: &rcl_client_t) -> Result { let mut avail = false; - let result = unsafe { - rcl_service_server_is_available(node, client, &mut avail) - }; + let result = unsafe { rcl_service_server_is_available(node, client, &mut avail) }; if result == RCL_RET_OK as i32 { Ok(avail) @@ -284,7 +272,10 @@ pub fn service_available_helper(node: &mut rcl_node_t, client: &rcl_client_t) -> } } -pub fn service_available(node: &mut rcl_node_t, client: &Client) -> Result { +pub fn service_available( + node: &mut rcl_node_t, + client: &Client, +) -> Result { let client = client .client .upgrade() diff --git a/src/clocks.rs b/src/clocks.rs index d4a88c1..2dea6f1 100644 --- a/src/clocks.rs +++ b/src/clocks.rs @@ -21,7 +21,6 @@ pub fn clock_type_to_rcl(ct: &ClockType) -> rcl_clock_type_t { } } - impl Clock { pub fn create(ct: ClockType) -> Result { let mut clock_handle = MaybeUninit::::uninit(); diff --git a/src/context.rs b/src/context.rs index c89c134..f499c34 100644 --- a/src/context.rs +++ b/src/context.rs @@ -1,6 +1,5 @@ use super::*; - #[derive(Debug, Clone)] pub struct Context { pub context_handle: Arc>, diff --git a/src/lib.rs b/src/lib.rs index 0334e5d..6e41f86 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -23,7 +23,7 @@ use actions::*; use rcl::*; mod error; -use error::*; +pub use error::{Error, Result}; mod msg_types; use msg_types::*; @@ -39,8 +39,10 @@ use subscribers::*; mod publishers; use publishers::*; +pub use publishers::{Publisher, PublisherUntyped}; mod services; +pub use services::ServiceRequest; use services::*; mod clients; @@ -48,18 +50,19 @@ use clients::*; pub use clients::{Client, UntypedClient}; mod action_clients; +pub use action_clients::ActionClient; use action_clients::*; mod action_servers; use action_servers::*; -pub use action_servers::{ActionServer, GoalRequest, ServerGoal, CancelRequest}; +pub use action_servers::{ActionServer, CancelRequest, GoalRequest, ServerGoal}; mod context; pub use context::Context; mod parameters; -use parameters::*; pub use parameters::ParameterValue; +use parameters::*; mod clocks; pub use clocks::{Clock, ClockType}; diff --git a/src/msg_types.rs b/src/msg_types.rs index e93b18a..9117730 100644 --- a/src/msg_types.rs +++ b/src/msg_types.rs @@ -127,12 +127,8 @@ impl UntypedServiceSupport { where T: WrappedServiceTypeSupport, { - let make_request_msg = || { - WrappedNativeMsgUntyped::new::() - }; - let make_response_msg = || { - WrappedNativeMsgUntyped::new::() - }; + let make_request_msg = || WrappedNativeMsgUntyped::new::(); + let make_response_msg = || WrappedNativeMsgUntyped::new::(); UntypedServiceSupport { ts: T::get_ts(), diff --git a/src/nodes.rs b/src/nodes.rs index aec3468..c4e4ac8 100644 --- a/src/nodes.rs +++ b/src/nodes.rs @@ -162,7 +162,8 @@ impl Node { where T: WrappedTypesupport, { - let subscription_handle = create_subscription_helper(self.node_handle.as_mut(), topic, T::get_ts())?; + let subscription_handle = + create_subscription_helper(self.node_handle.as_mut(), topic, T::get_ts())?; let (sender, receiver) = mpsc::channel::(10); let ws = TypedSubscriber { @@ -180,7 +181,8 @@ impl Node { where T: WrappedTypesupport, { - let subscription_handle = create_subscription_helper(self.node_handle.as_mut(), topic, T::get_ts())?; + let subscription_handle = + create_subscription_helper(self.node_handle.as_mut(), topic, T::get_ts())?; let (sender, receiver) = mpsc::channel::>(10); let ws = NativeSubscriber { @@ -198,7 +200,8 @@ impl Node { topic_type: &str, ) -> Result> + Unpin> { let msg = WrappedNativeMsgUntyped::new_from(topic_type)?; - let subscription_handle = create_subscription_helper(self.node_handle.as_mut(), topic, msg.ts)?; + let subscription_handle = + create_subscription_helper(self.node_handle.as_mut(), topic, msg.ts)?; let (sender, receiver) = mpsc::channel::>(10); let ws = UntypedSubscriber { @@ -217,7 +220,8 @@ impl Node { where T: WrappedServiceTypeSupport, { - let service_handle = create_service_helper(self.node_handle.as_mut(), service_name, T::get_ts())?; + let service_handle = + create_service_helper(self.node_handle.as_mut(), service_name, T::get_ts())?; let (sender, receiver) = mpsc::channel::>(10); let ws = TypedService:: { @@ -234,7 +238,8 @@ impl Node { where T: WrappedServiceTypeSupport, { - let client_handle = create_client_helper(self.node_handle.as_mut(), service_name, T::get_ts())?; + let client_handle = + create_client_helper(self.node_handle.as_mut(), service_name, T::get_ts())?; let ws = TypedClient:: { rcl_handle: client_handle, response_channels: Vec::new(), @@ -247,10 +252,14 @@ impl Node { } /// Create a service client without having the concrete rust type. - pub fn create_client_untyped(&mut self, service_name: &str, service_type: &str) -> Result - { + pub fn create_client_untyped( + &mut self, + service_name: &str, + service_type: &str, + ) -> Result { let service_type = UntypedServiceSupport::new_from(service_type)?; - let client_handle = create_client_helper(self.node_handle.as_mut(), service_name, service_type.ts)?; + let client_handle = + create_client_helper(self.node_handle.as_mut(), service_name, service_type.ts)?; let client = UntypedClient_ { service_type, rcl_handle: client_handle, @@ -263,7 +272,10 @@ impl Node { Ok(c) } - pub fn service_available(&mut self, client: &Client) -> Result { + pub fn service_available( + &mut self, + client: &Client, + ) -> Result { service_available(self.node_handle.as_mut(), client) } @@ -275,7 +287,8 @@ impl Node { where T: WrappedActionTypeSupport, { - let client_handle = create_action_client_helper(self.node_handle.as_mut(), action_name, T::get_ts())?; + let client_handle = + create_action_client_helper(self.node_handle.as_mut(), action_name, T::get_ts())?; let client = WrappedActionClient:: { rcl_handle: client_handle, goal_response_channels: Vec::new(), @@ -322,8 +335,12 @@ impl Node { let (goal_request_sender, goal_request_receiver) = mpsc::channel::>(10); - let server_handle = - create_action_server_helper(self.node_handle.as_mut(), action_name, clock_handle.as_mut(), T::get_ts())?; + let server_handle = create_action_server_helper( + self.node_handle.as_mut(), + action_name, + clock_handle.as_mut(), + T::get_ts(), + )?; let server = WrappedActionServer:: { rcl_handle: server_handle, clock_handle, @@ -344,7 +361,8 @@ impl Node { where T: WrappedTypesupport, { - let publisher_handle = create_publisher_helper(self.node_handle.as_mut(), topic, T::get_ts())?; + let publisher_handle = + create_publisher_helper(self.node_handle.as_mut(), topic, T::get_ts())?; let arc = Arc::new(publisher_handle); let p = make_publisher(Arc::downgrade(&arc)); self.pubs.push(arc); @@ -501,7 +519,11 @@ impl Node { } for acs in &self.action_servers { unsafe { - rcl_action_wait_set_add_action_server(&mut ws, acs.lock().unwrap().handle(), std::ptr::null_mut()); + rcl_action_wait_set_add_action_server( + &mut ws, + acs.lock().unwrap().handle(), + std::ptr::null_mut(), + ); } } diff --git a/src/parameters.rs b/src/parameters.rs index 81d3c77..4d17b39 100644 --- a/src/parameters.rs +++ b/src/parameters.rs @@ -45,18 +45,12 @@ pub fn parameter_value_from_rcl(v: &rcl_variant_t) -> ParameterValue { ParameterValue::IntegerArray(vals.iter().cloned().collect()) } else if v.double_array_value != std::ptr::null_mut() { let vals = unsafe { - std::slice::from_raw_parts( - (*v.double_array_value).values, - (*v.double_array_value).size, - ) + std::slice::from_raw_parts((*v.double_array_value).values, (*v.double_array_value).size) }; ParameterValue::DoubleArray(vals.iter().cloned().collect()) } else if v.string_array_value != std::ptr::null_mut() { let vals = unsafe { - std::slice::from_raw_parts( - (*v.string_array_value).data, - (*v.string_array_value).size, - ) + std::slice::from_raw_parts((*v.string_array_value).data, (*v.string_array_value).size) }; let s = vals .iter() diff --git a/src/publishers.rs b/src/publishers.rs index 119c52b..0f0fc91 100644 --- a/src/publishers.rs +++ b/src/publishers.rs @@ -44,7 +44,9 @@ pub struct PublisherUntyped { } pub fn make_publisher(handle: Weak) -> Publisher -where T: WrappedTypesupport { +where + T: WrappedTypesupport, +{ Publisher { handle, type_: PhantomData, @@ -52,10 +54,7 @@ where T: WrappedTypesupport { } pub fn make_publisher_untyped(handle: Weak, type_: String) -> PublisherUntyped { - PublisherUntyped { - handle, - type_, - } + PublisherUntyped { handle, type_ } } pub fn create_publisher_helper( @@ -84,7 +83,6 @@ pub fn create_publisher_helper( } } - impl PublisherUntyped { pub fn publish(&self, msg: serde_json::Value) -> Result<()> { // upgrade to actual ref. if still alive diff --git a/src/services.rs b/src/services.rs index 864bb2f..fb9e174 100644 --- a/src/services.rs +++ b/src/services.rs @@ -18,7 +18,10 @@ where { /// Complete the service request, consuming the request in the process. pub fn respond(self, msg: T::Response) -> Result<()> { - let service = self.service.upgrade().ok_or(Error::RCL_RET_ACTION_SERVER_INVALID)?; + let service = self + .service + .upgrade() + .ok_or(Error::RCL_RET_ACTION_SERVER_INVALID)?; let mut service = service.lock().unwrap(); let native_msg = WrappedNativeMsg::::from(&msg); service.send_response(self.request_id, Box::new(native_msg)) @@ -49,14 +52,13 @@ where &self.rcl_handle } - fn send_response(&mut self, mut request_id: rmw_request_id_t, mut msg: Box) -> Result<()> { - let res = unsafe { - rcl_send_response( - &self.rcl_handle, - &mut request_id, - msg.void_ptr_mut(), - ) - }; + fn send_response( + &mut self, + mut request_id: rmw_request_id_t, + mut msg: Box, + ) -> Result<()> { + let res = + unsafe { rcl_send_response(&self.rcl_handle, &mut request_id, msg.void_ptr_mut()) }; if res == RCL_RET_OK as i32 { Ok(()) } else { @@ -81,7 +83,7 @@ where let request = ServiceRequest:: { message: request_msg, request_id, - service: Arc::downgrade(&service) + service: Arc::downgrade(&service), }; match self.sender.try_send(request) { Err(e) => eprintln!("warning: could not send service request ({})", e), diff --git a/src/subscribers.rs b/src/subscribers.rs index c82836e..e4aaf34 100644 --- a/src/subscribers.rs +++ b/src/subscribers.rs @@ -130,7 +130,6 @@ impl Subscriber_ for UntypedSubscriber { } } - pub fn create_subscription_helper( node: &mut rcl_node_t, topic: &str,