mirror
/
r2r
mirror of https://github.com/sequenceplanner/r2r.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rustfmt

This commit is contained in:
Martin Dahl 2024-05-17 11:47:26 +02:00
parent 381f810d54
commit f7bbf8563f
9 changed files with 63 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
r2r/examples/client.rs
View File

@ -29,7 +29,8 @@ async fn requester_task(
fn main() -> Result<(), Box<dyn std::error::Error>> {
let ctx = r2r::Context::create()?;
let mut node = r2r::Node::create(ctx, "testnode", "")?;
let client = node.create_client::<AddTwoInts::Service>("/add_two_ints", QosProfile::default())?;
let client =
node.create_client::<AddTwoInts::Service>("/add_two_ints", QosProfile::default())?;
let service_available = r2r::Node::is_available(&client)?;

9
r2r/examples/service.rs
View File

@ -11,9 +11,12 @@ use r2r::{example_interfaces::srv::AddTwoInts, QosProfile};
fn main() -> Result<(), Box<dyn std::error::Error>> {
let ctx = r2r::Context::create()?;
let mut node = r2r::Node::create(ctx, "testnode", "")?;
let mut service = node.create_service::<AddTwoInts::Service>("/add_two_ints", QosProfile::default())?;
let service_delayed = node.create_service::<AddTwoInts::Service>("/add_two_ints_delayed", QosProfile::default())?;
let client = node.create_client::<AddTwoInts::Service>("/add_two_ints_delayed", QosProfile::default())?;
let mut service =
node.create_service::<AddTwoInts::Service>("/add_two_ints", QosProfile::default())?;
let service_delayed =
node.create_service::<AddTwoInts::Service>("/add_two_ints_delayed", QosProfile::default())?;
let client =
node.create_client::<AddTwoInts::Service>("/add_two_ints_delayed", QosProfile::default())?;
let mut timer = node.create_wall_timer(std::time::Duration::from_millis(250))?;
let mut timer2 = node.create_wall_timer(std::time::Duration::from_millis(2000))?;
// wait for service to be available

3
r2r/examples/tokio_client.rs
View File

@ -7,7 +7,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
let duration = std::time::Duration::from_millis(2500);
use r2r::example_interfaces::srv::AddTwoInts;
let client = node.create_client::<AddTwoInts::Service>("/add_two_ints", QosProfile::default())?;
let client =
node.create_client::<AddTwoInts::Service>("/add_two_ints", QosProfile::default())?;
let mut timer = node.create_wall_timer(duration)?;
let waiting = r2r::Node::is_available(&client)?;

3
r2r/examples/tokio_examples.rs
View File

@ -75,7 +75,8 @@ async fn client(arc_node: Arc<Mutex<r2r::Node>>) -> Result<(), r2r::Error> {
let (client, mut timer, service_available) = {
// Limiting the scope when locking the arc
let mut node = arc_node.lock().unwrap();
let client = node.create_client::<AddTwoInts::Service>("/add_two_ints", QosProfile::default())?;
let client =
node.create_client::<AddTwoInts::Service>("/add_two_ints", QosProfile::default())?;
let timer = node.create_wall_timer(std::time::Duration::from_secs(2))?;
let service_available = r2r::Node::is_available(&client)?;
(client, timer, service_available)

3
r2r/examples/tokio_service.rs
View File

@ -7,7 +7,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut node = r2r::Node::create(ctx, "testnode", "")?;
use r2r::example_interfaces::srv::AddTwoInts;
let mut service = node.create_service::<AddTwoInts::Service>("/add_two_ints", QosProfile::default())?;
let mut service =
node.create_service::<AddTwoInts::Service>("/add_two_ints", QosProfile::default())?;
let handle = tokio::task::spawn_blocking(move || loop {
node.spin_once(std::time::Duration::from_millis(100));

7
r2r/examples/untyped_client.rs
View File

@ -25,8 +25,11 @@ async fn requester_task(
fn main() -> Result<(), Box<dyn std::error::Error>> {
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", QosProfile::default())?;
let client = node.create_client_untyped(
"/add_two_ints",
"example_interfaces/srv/AddTwoInts",
QosProfile::default(),
)?;
let service_available = r2r::Node::is_available(&client)?;

3
r2r/src/clients.rs
View File

@ -319,7 +319,8 @@ impl Client_ for UntypedClient_ {
}
pub fn create_client_helper(
node: *mut rcl_node_t, service_name: &str, service_ts: *const rosidl_service_type_support_t, qos_profile: QosProfile,
node: *mut rcl_node_t, service_name: &str, service_ts: *const rosidl_service_type_support_t,
qos_profile: QosProfile,
) -> Result<rcl_client_t> {
let mut client_handle = unsafe { rcl_get_zero_initialized_client() };
let service_name_c_string =

57
r2r/src/nodes.rs
View File

@ -287,11 +287,10 @@ impl Node {
let node_name = self.name()?;
let set_params_request_stream = self
.create_service::<rcl_interfaces::srv::SetParameters::Service>(&format!(
"{}/set_parameters",
node_name
),
QosProfile::default())?;
.create_service::<rcl_interfaces::srv::SetParameters::Service>(
&format!("{}/set_parameters", node_name),
QosProfile::default(),
)?;
let params = self.params.clone();
let params_struct_clone = params_struct.clone();
@ -352,8 +351,9 @@ impl Node {
// rcl_interfaces/srv/GetParameters
let get_params_request_stream = self
.create_service::<rcl_interfaces::srv::GetParameters::Service>(
&format!("{}/get_parameters",node_name),
QosProfile::default())?;
&format!("{}/get_parameters", node_name),
QosProfile::default(),
)?;
let params = self.params.clone();
let params_struct_clone = params_struct.clone();
@ -391,8 +391,10 @@ impl Node {
// rcl_interfaces/srv/ListParameters
use rcl_interfaces::srv::ListParameters;
let list_params_request_stream = self
.create_service::<ListParameters::Service>(&format!("{}/list_parameters", node_name), QosProfile::default())?;
let list_params_request_stream = self.create_service::<ListParameters::Service>(
&format!("{}/list_parameters", node_name),
QosProfile::default(),
)?;
let params = self.params.clone();
let list_params_future = list_params_request_stream.for_each(
@ -406,7 +408,9 @@ impl Node {
// rcl_interfaces/srv/DescribeParameters
use rcl_interfaces::srv::DescribeParameters;
let desc_params_request_stream = self.create_service::<DescribeParameters::Service>(
&format!("{node_name}/describe_parameters"), QosProfile::default())?;
&format!("{node_name}/describe_parameters"),
QosProfile::default(),
)?;
let params = self.params.clone();
let desc_params_future = desc_params_request_stream.for_each(
@ -421,7 +425,8 @@ impl Node {
use rcl_interfaces::srv::GetParameterTypes;
let get_param_types_request_stream = self.create_service::<GetParameterTypes::Service>(
&format!("{node_name}/get_parameter_types"),
QosProfile::default())?;
QosProfile::default(),
)?;
let params = self.params.clone();
let get_param_types_future = get_param_types_request_stream.for_each(
@ -654,8 +659,12 @@ impl Node {
where
T: WrappedServiceTypeSupport,
{
let service_handle =
create_service_helper(self.node_handle.as_mut(), service_name, T::get_ts(), qos_profile)?;
let service_handle = create_service_helper(
self.node_handle.as_mut(),
service_name,
T::get_ts(),
qos_profile,
)?;
let (sender, receiver) = mpsc::channel::<ServiceRequest<T>>(10);
let ws = TypedService::<T> {
@ -672,12 +681,17 @@ impl Node {
///
/// A service client is used to make requests to a ROS service server.
pub fn create_client<T: 'static>(
&mut self, service_name: &str, qos_profile: QosProfile,) -> Result<Client<T>>
&mut self, service_name: &str, qos_profile: QosProfile,
) -> Result<Client<T>>
where
T: WrappedServiceTypeSupport,
{
let client_handle =
create_client_helper(self.node_handle.as_mut(), service_name, T::get_ts(), qos_profile)?;
let client_handle = create_client_helper(
self.node_handle.as_mut(),
service_name,
T::get_ts(),
qos_profile,
)?;
let ws = TypedClient::<T> {
rcl_handle: client_handle,
response_channels: Vec::new(),
@ -700,8 +714,12 @@ impl Node {
&mut self, service_name: &str, service_type: &str, qos_profile: QosProfile,
) -> Result<ClientUntyped> {
let service_type = UntypedServiceSupport::new_from(service_type)?;
let client_handle =
create_client_helper(self.node_handle.as_mut(), service_name, service_type.ts, qos_profile)?;
let client_handle = create_client_helper(
self.node_handle.as_mut(),
service_name,
service_type.ts,
qos_profile,
)?;
let client = UntypedClient_ {
service_type,
rcl_handle: client_handle,
@ -1490,6 +1508,9 @@ impl Drop for Node {
for s in &mut self.subscribers {
s.destroy(&mut self.node_handle);
}
for c in &mut self.clients {
c.lock().unwrap().destroy(&mut self.node_handle);
}
for s in &mut self.services {
s.lock().unwrap().destroy(&mut self.node_handle);
}

5
r2r/src/services.rs
View File

@ -113,7 +113,8 @@ where
}
pub fn create_service_helper(
node: &mut rcl_node_t, service_name: &str, service_ts: *const rosidl_service_type_support_t, qos_profile: QosProfile,
node: &mut rcl_node_t, service_name: &str, service_ts: *const rosidl_service_type_support_t,
qos_profile: QosProfile,
) -> Result<rcl_service_t> {
let mut service_handle = unsafe { rcl_get_zero_initialized_service() };
let service_name_c_string =
@ -121,7 +122,7 @@ pub fn create_service_helper(
let result = unsafe {
let mut service_options = rcl_service_get_default_options();
service_options.qos = qos_profile.into();
service_options.qos = qos_profile.into();
rcl_service_init(
&mut service_handle,
node,