Type alias

rclrust-msg/src/_core/mod.rs

@@ -10,3 +10,6 @@ pub mod traits;
 pub use sequence::{FFISeq, OwnedFFISeq, RefFFISeq};
 pub use string::{FFIString, FFIWString, OwnedFFIString, OwnedFFIWString};
 pub use traits::{ActionT, FFIFromRust, FFIToRust, InternalDefault, MessageT, ServiceT};
+
+pub type ServiceRequestRaw<Srv> = <<Srv as ServiceT>::Request as MessageT>::Raw;
+pub type ServiceResponseRaw<Srv> = <<Srv as ServiceT>::Response as MessageT>::Raw;

rclrust/src/client.rs

@@ -11,7 +11,7 @@ use std::{
 
 use anyhow::{Context as _, Result};
 use futures::channel::{mpsc, oneshot};
-use rclrust_msg::_core::{FFIToRust, MessageT, ServiceT};
+use rclrust_msg::_core::{FFIToRust, MessageT, ServiceResponseRaw, ServiceT};
 
 use crate::{
     error::{RclRustError, ToRclRustResult},
@@ -89,14 +89,12 @@ impl RclClient {
         Ok(sequence_number)
     }
 
-    fn take_response<Srv>(
-        &self,
-    ) -> Result<(rcl_sys::rmw_request_id_t, <Srv::Response as MessageT>::Raw)>
+    fn take_response<Srv>(&self) -> Result<(rcl_sys::rmw_request_id_t, ServiceResponseRaw<Srv>)>
     where
         Srv: ServiceT,
     {
         let mut request_header = MaybeUninit::uninit();
-        let mut response = <Srv::Response as MessageT>::Raw::default();
+        let mut response = Default::default();
         unsafe {
             rcl_sys::rcl_take_response(
                 self.raw(),
@@ -153,10 +151,7 @@ impl Drop for RclClient {
     }
 }
 
-type ChannelMessage<Srv> = (
-    rcl_sys::rmw_request_id_t,
-    <<Srv as ServiceT>::Response as MessageT>::Raw,
-);
+type ChannelMessage<Srv> = (rcl_sys::rmw_request_id_t, ServiceResponseRaw<Srv>);
 
 pub struct Client<Srv>
 where
@@ -185,10 +180,7 @@ where
         let callback = {
             let pendings = Arc::clone(&pendings);
 
-            move |(req_header, res): (
-                rcl_sys::rmw_request_id_t,
-                <Srv::Response as MessageT>::Raw,
-            )| {
+            move |(req_header, res): (rcl_sys::rmw_request_id_t, ServiceResponseRaw<Srv>)| {
                 pendings
                     .lock()
                     .unwrap()

rclrust/src/service.rs

@@ -7,7 +7,7 @@ use std::{
 
 use anyhow::{Context, Result};
 use futures::channel::mpsc;
-use rclrust_msg::_core::{MessageT, ServiceT};
+use rclrust_msg::_core::{MessageT, ServiceRequestRaw, ServiceT};
 
 use crate::{
     error::{RclRustError, ToRclRustResult},
@@ -62,14 +62,12 @@ impl RclService {
         &self.r#impl
     }
 
-    fn take_request<Srv>(
-        &self,
-    ) -> Result<(rcl_sys::rmw_request_id_t, <Srv::Request as MessageT>::Raw)>
+    fn take_request<Srv>(&self) -> Result<(rcl_sys::rmw_request_id_t, ServiceRequestRaw<Srv>)>
     where
         Srv: ServiceT,
     {
         let mut request_header = MaybeUninit::uninit();
-        let mut request = <Srv::Request as MessageT>::Raw::default();
+        let mut request = Default::default();
         unsafe {
             rcl_sys::rcl_take_request(
                 self.raw(),

rclrust/src/subscription.rs

@@ -64,11 +64,11 @@ impl RclSubscription {
         &self.r#impl
     }
 
-    fn take<T>(&self) -> Result<Arc<T::Raw>>
+    fn take<T>(&self) -> Result<T::Raw>
     where
         T: MessageT,
     {
-        let mut message = T::Raw::default();
+        let mut message = Default::default();
         unsafe {
             rcl_sys::rcl_take(
                 self.raw(),
@@ -80,7 +80,7 @@ impl RclSubscription {
             .with_context(|| "rcl_sys::rcl_take in RclSubscription::take")?;
         }
 
-        Ok(Arc::new(message))
+        Ok(message)
     }
 
     fn topic_name(&self) -> String {
@@ -226,7 +226,7 @@ where
 
     fn invoke(&mut self) -> Result<()> {
         if let Some(ref mut tx) = self.tx {
-            match tx.try_send(WorkerMessage::Message(self.handle.take::<T>()?)) {
+            match tx.try_send(WorkerMessage::Message(Arc::new(self.handle.take::<T>()?))) {
                 Ok(_) => (),
                 Err(e) if e.is_disconnected() => self.stop(),
                 Err(_) => {