Fix compilation errors

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

Author: mxgrey

rclrs/src/client.rs

@@ -78,6 +78,7 @@ where
     futures: Arc<Mutex<HashMap<RequestId, oneshot::Sender<T::Response>>>>,
     /// Ensure the parent node remains alive as long as the subscription is held.
     /// This implementation will change in the future.
+    #[allow(unused)]
     node: Arc<Node>,
 }
 
@@ -129,7 +130,7 @@ where
 
         let handle = Arc::new(ClientHandle {
             rcl_client: Mutex::new(rcl_client),
-            node_handle,
+            node_handle: Arc::clone(&node.handle),
             in_use_by_wait_set: Arc::new(AtomicBool::new(false)),
         });
 

rclrs/src/node.rs

@@ -225,11 +225,11 @@ impl Node {
     ///
     /// [1]: crate::Client
     // TODO: make client's lifetime depend on node's lifetime
-    pub fn create_client<T>(&self, topic: &str) -> Result<Arc<Client<T>>, RclrsError>
+    pub fn create_client<T>(self: &Arc<Self>, topic: &str) -> Result<Arc<Client<T>>, RclrsError>
     where
         T: rosidl_runtime_rs::Service,
     {
-        let client = Arc::new(Client::<T>::new(Arc::clone(&self.handle), topic)?);
+        let client = Arc::new(Client::<T>::new(self, topic)?);
         { self.clients_mtx.lock().unwrap() }.push(Arc::downgrade(&client) as Weak<dyn ClientBase>);
         Ok(client)
     }
@@ -292,19 +292,15 @@ impl Node {
     ///
     /// [1]: crate::Service
     pub fn create_service<T, F>(
-        &self,
+        self: &Arc<Self>,
         topic: &str,
         callback: F,
     ) -> Result<Arc<Service<T>>, RclrsError>
     where
         T: rosidl_runtime_rs::Service,
         F: Fn(&rmw_request_id_t, T::Request) -> T::Response + 'static + Send,
     {
-        let service = Arc::new(Service::<T>::new(
-            Arc::clone(&self.handle),
-            topic,
-            callback,
-        )?);
+        let service = Arc::new(Service::<T>::new(self, topic, callback)?);
         { self.services_mtx.lock().unwrap() }
             .push(Arc::downgrade(&service) as Weak<dyn ServiceBase>);
         Ok(service)
@@ -314,20 +310,15 @@ impl Node {
     ///
     /// [1]: crate::Subscription
     pub fn create_subscription<T, Args>(
-        &self,
+        self: &Arc<Self>,
         topic: &str,
         qos: QoSProfile,
         callback: impl SubscriptionCallback<T, Args>,
     ) -> Result<Arc<Subscription<T>>, RclrsError>
     where
         T: Message,
     {
-        let subscription = Arc::new(Subscription::<T>::new(
-            Arc::clone(&self.handle),
-            topic,
-            qos,
-            callback,
-        )?);
+        let subscription = Arc::new(Subscription::<T>::new(self, topic, qos, callback)?);
         { self.subscriptions_mtx.lock() }
             .unwrap()
             .push(Arc::downgrade(&subscription) as Weak<dyn SubscriptionBase>);

rclrs/src/parameter.rs

@@ -789,7 +789,7 @@ impl ParameterInterface {
         }
     }
 
-    pub(crate) fn create_services(&self, node: &Node) -> Result<(), RclrsError> {
+    pub(crate) fn create_services(&self, node: &Arc<Node>) -> Result<(), RclrsError> {
         *self.services.lock().unwrap() =
             Some(ParameterService::new(node, self.parameter_map.clone())?);
         Ok(())

rclrs/src/parameter/service.rs

@@ -239,7 +239,7 @@ fn set_parameters_atomically(
 
 impl ParameterService {
     pub(crate) fn new(
-        node: &Node,
+        node: &Arc<Node>,
         parameter_map: Arc<Mutex<ParameterMap>>,
     ) -> Result<Self, RclrsError> {
         let fqn = node.fully_qualified_name();

rclrs/src/service.rs

@@ -75,6 +75,7 @@ where
     pub callback: Mutex<ServiceCallback<T::Request, T::Response>>,
     /// Ensure the parent node remains alive as long as the subscription is held.
     /// This implementation will change in the future.
+    #[allow(unused)]
     node: Arc<Node>,
 }
 
@@ -126,7 +127,7 @@ where
 
         let handle = Arc::new(ServiceHandle {
             rcl_service: Mutex::new(rcl_service),
-            node_handle,
+            node_handle: Arc::clone(&node.handle),
             in_use_by_wait_set: Arc::new(AtomicBool::new(false)),
         });
 

rclrs/src/subscription.rs

@@ -31,7 +31,7 @@ unsafe impl Send for rcl_subscription_t {}
 /// [1]: <https://doc.rust-lang.org/reference/destructors.html>
 pub struct SubscriptionHandle {
     rcl_subscription: Mutex<rcl_subscription_t>,
-    node_handle: Arc<Node>,
+    node_handle: Arc<NodeHandle>,
     pub(crate) in_use_by_wait_set: Arc<AtomicBool>,
 }
 
@@ -86,6 +86,7 @@ where
     pub callback: Mutex<AnySubscriptionCallback<T>>,
     /// Ensure the parent node remains alive as long as the subscription is held.
     /// This implementation will change in the future.
+    #[allow(unused)]
     node: Arc<Node>,
     message: PhantomData<T>,
 }
@@ -142,7 +143,7 @@ where
 
         let handle = Arc::new(SubscriptionHandle {
             rcl_subscription: Mutex::new(rcl_subscription),
-            node_handle,
+            node_handle: Arc::clone(&node.handle),
             in_use_by_wait_set: Arc::new(AtomicBool::new(false)),
         });
 
@@ -403,24 +404,25 @@ mod tests {
 
     #[test]
     fn test_node_subscription_raii() {
-        use rclrs::*;
+        use crate::*;
         use std::sync::atomic::Ordering;
 
-        let executor = Context::default().create_basic_executor();
+        let mut executor = Context::default().create_basic_executor();
 
         let triggered = Arc::new(AtomicBool::new(false));
-        let callback = |_| {
-            triggered.store(true, Ordering::AcqRel);
+        let inner_triggered = Arc::clone(&triggered);
+        let callback = move |_: msg::Empty| {
+            inner_triggered.store(true, Ordering::Release);
         };
 
-        let (subscription, publisher) = {
+        let (_subscription, publisher) = {
             let node = executor
                 .create_node(&format!("test_node_subscription_raii_{}", line!()))
                 .unwrap();
 
             let qos = QoSProfile::default().keep_all().reliable();
             let subscription = node
-                .create_subscription::<msg::Empty>("test_topic", qos, callback)
+                .create_subscription::<msg::Empty, _>("test_topic", qos, callback)
                 .unwrap();
             let publisher = node
                 .create_publisher::<msg::Empty>("test_topic", qos)
@@ -429,9 +431,9 @@ mod tests {
             (subscription, publisher)
         };
 
-        publisher.publish(msg::Empty {});
+        publisher.publish(msg::Empty::default()).unwrap();
         let start_time = std::time::Instant::now();
-        while !triggered.load(Ordering::AcqRel) {
+        while !triggered.load(Ordering::Acquire) {
             assert!(executor.spin(SpinOptions::spin_once()).is_empty());
             assert!(start_time.elapsed() < std::time::Duration::from_secs(10));
         }