Use the appropriate Waitable sub-trait everywhere

Author: nnmm

rclrs/src/lib.rs

@@ -54,21 +54,15 @@ pub fn spin_once(node: &Node, timeout: Option<Duration>) -> Result<(), RclrsErro
     )?;
 
     for live_subscription in live_subscriptions {
-        // SAFETY: The implementation of this trait function guarantees that the subscription
-        // is not part of any other wait set. (TODO: issue #207)
-        unsafe { live_subscription.add_to_wait_set(&mut wait_set)? };
+        wait_set.add_subscription(live_subscription)?;
     }
 
     for live_client in live_clients {
-        // SAFETY: The implementation of this trait function guarantees that the client
-        // is not part of any other wait set. (TODO: issue #207)
-        unsafe { live_client.add_to_wait_set(&mut wait_set)? };
+        wait_set.add_client(live_client)?;
     }
 
     for live_service in live_services {
-        // SAFETY: The implementation of this trait function guarantees that the client
-        // is not part of any other wait set. (TODO: issue #207)
-        unsafe { live_service.add_to_wait_set(&mut wait_set)? };
+        wait_set.add_service(live_service)?;
     }
 
     let ready_entities = wait_set.wait(timeout)?;

rclrs/src/node/client.rs

@@ -86,7 +86,7 @@ where
 }
 
 /// A marker trait to distinguish `Client` waitables from other [`Waitable`]s.
-pub(crate) trait ClientWaitable: Waitable {}
+pub trait ClientWaitable: Waitable {}
 
 impl<T> ClientWaitable for Client<T> where T: rosidl_runtime_rs::Service {}
 

rclrs/src/node/service.rs

@@ -57,7 +57,7 @@ where
             std::ptr::null_mut(),
         )
         .ok()?;
-        wait_set.clients.push(self);
+        wait_set.services.push(self);
         Ok(())
     }
 
@@ -90,7 +90,7 @@ where
 }
 
 /// A marker trait to distinguish `Service` waitables from other [`Waitable`]s.
-pub(crate) trait ServiceWaitable: Waitable {}
+pub trait ServiceWaitable: Waitable {}
 
 impl<T> ServiceWaitable for Service<T> where T: rosidl_runtime_rs::Service {}
 

rclrs/src/node/subscription.rs

@@ -86,7 +86,7 @@ where
 }
 
 /// A marker trait to distinguish `Subscription` waitables from other [`Waitable`]s.
-pub(crate) trait SubscriptionWaitable: Waitable {}
+pub trait SubscriptionWaitable: Waitable {}
 
 impl<T> SubscriptionWaitable for Subscription<T> where T: Message {}
 

rclrs/src/wait.rs

@@ -17,7 +17,7 @@
 
 use crate::error::{to_rclrs_result, RclReturnCode, RclrsError, ToResult};
 use crate::rcl_bindings::*;
-use crate::{Client, Context, Service, Subscription};
+use crate::{ClientWaitable, Context, ServiceWaitable, SubscriptionWaitable};
 
 use std::sync::Arc;
 use std::time::Duration;
@@ -59,19 +59,19 @@ pub struct WaitSet {
     // The subscriptions that are currently registered in the wait set.
     // This correspondence is an invariant that must be maintained by all functions,
     // even in the error case.
-    pub(crate) subscriptions: Vec<Arc<dyn Waitable>>,
-    pub(crate) clients: Vec<Arc<dyn Waitable>>,
-    pub(crate) services: Vec<Arc<dyn Waitable>>,
+    pub(crate) subscriptions: Vec<Arc<dyn SubscriptionWaitable>>,
+    pub(crate) clients: Vec<Arc<dyn ClientWaitable>>,
+    pub(crate) services: Vec<Arc<dyn ServiceWaitable>>,
 }
 
 /// A list of entities that are ready, returned by [`WaitSet::wait`].
 pub struct ReadyEntities {
     /// A list of subscriptions that have potentially received messages.
-    pub subscriptions: Vec<Arc<dyn Waitable>>,
+    pub subscriptions: Vec<Arc<dyn SubscriptionWaitable>>,
     /// A list of clients that have potentially received responses.
-    pub clients: Vec<Arc<dyn Waitable>>,
+    pub clients: Vec<Arc<dyn ClientWaitable>>,
     /// A list of services that have potentially received requests.
-    pub services: Vec<Arc<dyn Waitable>>,
+    pub services: Vec<Arc<dyn ServiceWaitable>>,
 }
 
 impl Drop for rcl_wait_set_t {
@@ -135,10 +135,7 @@ impl WaitSet {
     ///
     /// The same client must not be added to multiple wait sets, because that would make it
     /// unsafe to simultaneously wait on those wait sets.
-    pub fn add_client<T: rosidl_runtime_rs::Service>(
-        &mut self,
-        client: Arc<Client<T>>,
-    ) -> Result<(), RclrsError> {
+    pub fn add_client(&mut self, client: Arc<dyn ClientWaitable>) -> Result<(), RclrsError> {
         // SAFETY: The implementation of this trait for clients checks that the client
         // has not already been added to a different wait set.
         unsafe { client.add_to_wait_set(self) }
@@ -153,10 +150,7 @@ impl WaitSet {
     ///
     /// The same service must not be added to multiple wait sets, because that would make it
     /// unsafe to simultaneously wait on those wait sets.
-    pub fn add_service<T: rosidl_runtime_rs::Service>(
-        &mut self,
-        service: Arc<Service<T>>,
-    ) -> Result<(), RclrsError> {
+    pub fn add_service(&mut self, service: Arc<dyn ServiceWaitable>) -> Result<(), RclrsError> {
         // SAFETY: The implementation of this trait for services checks that the service
         // has not already been added to a different wait set.
         unsafe { service.add_to_wait_set(self) }
@@ -171,9 +165,9 @@ impl WaitSet {
     ///
     /// The same subscription must not be added to multiple wait sets, because that would make it
     /// unsafe to simultaneously wait on those wait sets.
-    pub fn add_subscription<T: rosidl_runtime_rs::Message>(
+    pub fn add_subscription(
         &mut self,
-        subscription: Arc<Subscription<T>>,
+        subscription: Arc<dyn SubscriptionWaitable>,
     ) -> Result<(), RclrsError> {
         // SAFETY: The implementation of this trait for subscriptions checks that the subscription
         // has not already been added to a different wait set.