Use SubscriptionOptions

Signed-off-by: Luca Della Vedova <[email protected]>

Author: luca-della-vedova

rclrs/src/dynamic_message/dynamic_subscription.rs

@@ -12,9 +12,9 @@ use super::{
 };
 use crate::rcl_bindings::*;
 use crate::{
-    MessageInfo, NodeHandle, QoSProfile, RclPrimitive, RclPrimitiveHandle, RclPrimitiveKind,
+    MessageInfo, NodeHandle, RclPrimitive, RclPrimitiveHandle, RclPrimitiveKind,
     RclrsError, SubscriptionHandle, ToResult, Waitable, WaitableLifecycle, WorkScope,
-    WorkerCommands, ENTITY_LIFECYCLE_MUTEX,
+    WorkerCommands, ENTITY_LIFECYCLE_MUTEX, SubscriptionOptions,
 };
 
 struct DynamicSubscriptionExecutable<Payload> {
@@ -181,17 +181,17 @@ where
     /// Creates a new dynamic subscription.
     ///
     /// This is not a public function, by the same rationale as `Subscription::new()`.
-    pub(crate) fn new(
-        topic: &str,
+    pub(crate) fn new<'a>(
         topic_type: MessageTypeName,
-        qos: QoSProfile,
+        options: impl Into<SubscriptionOptions<'a>>,
         callback: impl Into<DynamicSubscriptionCallback<Scope::Payload>>,
         node_handle: &Arc<NodeHandle>,
         commands: &Arc<WorkerCommands>,
     ) -> Result<Arc<Self>, RclrsError> {
         // TODO(luca) a lot of duplication with nomral, refactor
         // This loads the introspection type support library.
         let metadata = DynamicMessageMetadata::new(topic_type)?;
+        let SubscriptionOptions { topic, qos } = options.into();
         // However, we also need the regular type support library –
         // the rosidl_typesupport_c one.
         let message_type = &metadata.message_type;

rclrs/src/node.rs

@@ -7,7 +7,6 @@ pub use primitive_options::*;
 mod graph;
 #[cfg(feature = "dyn_msg")]
 use crate::dynamic_message::{DynamicMessage, DynamicSubscription};
-use crate::QoSProfile;
 
 pub use graph::*;
 
@@ -793,23 +792,19 @@ impl NodeState {
         )
     }
 
-    // TODO(luca) introduce subscription options and perhaps an into callback
     #[cfg(feature = "dyn_msg")]
-    pub fn create_dynamic_subscription<F>(
+    pub fn create_dynamic_subscription<'a, F>(
         &self,
-        // options: impl Into<DynamicSubscriptionOptions<'a>>,
-        topic: &str,
         topic_type: MessageTypeName,
-        qos: QoSProfile,
+        options: impl Into<SubscriptionOptions<'a>>,
         callback: F,
     ) -> Result<Arc<DynamicSubscription<Node>>, RclrsError>
     where
         F: FnMut(DynamicMessage, MessageInfo) -> BoxFuture<'static, ()> + Send + 'static,
     {
         let subscription = DynamicSubscription::new(
-            topic,
             topic_type,
-            qos,
+            options,
             NodeDynamicSubscriptionCallback(Box::new(callback)),
             &self.handle,
             self.commands.async_worker_commands(),
@@ -818,32 +813,6 @@ impl NodeState {
         Ok(subscription)
     }
 
-    /// Creates a [`DynamicSubscription`][1].
-    ///
-    /// [1]: crate::dynamic_message::DynamicSubscription
-    // TODO: make subscription's lifetime depend on node's lifetime
-    // TODO(luca) convert to subscription options
-    /*
-    #[cfg(feature = "dyn_msg")]
-    pub fn create_dynamic_subscription<F>(
-        &mut self,
-        topic: &str,
-        topic_type: &str,
-        qos: QoSProfile,
-        callback: F,
-    ) -> Result<Arc<DynamicSubscription>, RclrsError>
-    where
-        F: FnMut(DynamicMessage) + 'static + Send,
-    {
-        let subscription = Arc::new(DynamicSubscription::new(
-            self, topic, topic_type, qos, callback,
-        )?);
-        self.subscriptions
-            .push(Arc::downgrade(&subscription) as Weak<dyn SubscriptionBase>);
-        Ok(subscription)
-    }
-    */
-
     /// Creates a [`Subscription`] with an async callback.
     ///
     /// # Behavior