Implement timers for Workers

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

Author: mxgrey

rclrs/src/node.rs

@@ -241,15 +241,15 @@ impl NodeState {
     //
     // TODO(@mxgrey): Write some usage examples.
     pub fn create_worker<'a, Payload>(
-        &self,
+        self: &Arc<Self>,
         options: impl IntoWorkerOptions<Payload>,
     ) -> Worker<Payload>
     where
         Payload: 'static + Send + Sync,
     {
         let options = options.into_worker_options();
         let commands = self.commands.create_worker_commands(Box::new(options.payload));
-        WorkerState::create(Arc::clone(&self.handle), commands)
+        WorkerState::create(Arc::clone(self), commands)
     }
 
     /// Creates a [`Client`][1].
@@ -571,7 +571,7 @@ impl NodeState {
 
     /// Create a [`Timer`] whose callback will be triggered once after the period
     /// of the timer has elapsed. After that you will need to use
-    /// [`Timer::set_callback`] or a related method or else nothing will happen
+    /// [`Timer::set_repeating`] or [`Timer::set_oneshot`] or else nothing will happen
     /// the following times that the `Timer` elapses.
     ///
     /// See also:

rclrs/src/timer.rs

@@ -359,7 +359,7 @@ impl<Payload: 'static + Send + Sync> TimerState<Worker<Payload>> {
         &self,
         f: impl IntoWorkerTimerRepeatingCallback<Worker<Payload>, Args>,
     ) -> Option<AnyTimerCallback<Worker<Payload>>> {
-        self.set_callback(f.into_timer_repeating_callback())
+        self.set_callback(f.into_worker_timer_repeating_callback())
     }
 
     /// Set a one-shot callback for the worker timer.
@@ -376,7 +376,7 @@ impl<Payload: 'static + Send + Sync> TimerState<Worker<Payload>> {
         &self,
         f: impl IntoWorkerTimerOneshotCallback<Worker<Payload>, Args>,
     ) -> Option<AnyTimerCallback<Worker<Payload>>> {
-        self.set_callback(f.into_timer_oneshot_callback())
+        self.set_callback(f.into_worker_timer_oneshot_callback())
     }
 }
 

rclrs/src/timer/into_worker_timer_callback.rs

@@ -4,14 +4,14 @@ use std::sync::Arc;
 /// This trait is used to create timer callbacks for repeating timers in a Worker.
 pub trait IntoWorkerTimerRepeatingCallback<Scope: WorkScope, Args>: 'static + Send {
     /// Convert a suitable object into a repeating timer callback for a worker scope
-    fn into_timer_repeating_callback(self) -> AnyTimerCallback<Scope>;
+    fn into_worker_timer_repeating_callback(self) -> AnyTimerCallback<Scope>;
 }
 
 impl<Scope: WorkScope, Func> IntoWorkerTimerRepeatingCallback<Scope, ()> for Func
 where
     Func: FnMut() + 'static + Send,
 {
-    fn into_timer_repeating_callback(mut self) -> AnyTimerCallback<Scope> {
+    fn into_worker_timer_repeating_callback(mut self) -> AnyTimerCallback<Scope> {
         AnyTimerCallback::Repeating(Box::new(move |_, _| self())).into()
     }
 }
@@ -20,7 +20,7 @@ impl<Scope: WorkScope, Func> IntoWorkerTimerRepeatingCallback<Scope, (Scope::Pay
 where
     Func: FnMut(&mut Scope::Payload) + 'static + Send,
 {
-    fn into_timer_repeating_callback(mut self) -> AnyTimerCallback<Scope> {
+    fn into_worker_timer_repeating_callback(mut self) -> AnyTimerCallback<Scope> {
         AnyTimerCallback::Repeating(Box::new(move |payload, _| self(payload))).into()
     }
 }
@@ -29,7 +29,7 @@ impl<Scope: WorkScope, Func> IntoWorkerTimerRepeatingCallback<Scope, (Scope::Pay
 where
     Func: FnMut(&mut Scope::Payload, &Arc<TimerState<Scope>>) + 'static + Send,
 {
-    fn into_timer_repeating_callback(self) -> AnyTimerCallback<Scope> {
+    fn into_worker_timer_repeating_callback(self) -> AnyTimerCallback<Scope> {
         AnyTimerCallback::Repeating(Box::new(self)).into()
     }
 }
@@ -38,22 +38,22 @@ impl<Scope: WorkScope, Func> IntoWorkerTimerRepeatingCallback<Scope, (Scope::Pay
 where
     Func: FnMut(&mut Scope::Payload, Time) + 'static + Send,
 {
-    fn into_timer_repeating_callback(mut self) -> AnyTimerCallback<Scope> {
+    fn into_worker_timer_repeating_callback(mut self) -> AnyTimerCallback<Scope> {
         AnyTimerCallback::Repeating(Box::new(move |payload, t| self(payload, t.handle.clock.now()))).into()
     }
 }
 
 /// This trait is used to create timer callbacks for one-shot timers in a Worker.
 pub trait IntoWorkerTimerOneshotCallback<Scope: WorkScope, Args>: 'static + Send {
     /// Convert a suitable object into a one-shot timer callback for a worker scope
-    fn into_timer_oneshot_callback(self) -> AnyTimerCallback<Scope>;
+    fn into_worker_timer_oneshot_callback(self) -> AnyTimerCallback<Scope>;
 }
 
 impl<Scope: WorkScope, Func> IntoWorkerTimerOneshotCallback<Scope, ()> for Func
 where
     Func: FnOnce() + 'static + Send,
 {
-    fn into_timer_oneshot_callback(self) -> AnyTimerCallback<Scope> {
+    fn into_worker_timer_oneshot_callback(self) -> AnyTimerCallback<Scope> {
         AnyTimerCallback::OneShot(Box::new(move |_, _| self())).into()
     }
 }
@@ -62,7 +62,7 @@ impl<Scope: WorkScope, Func> IntoWorkerTimerOneshotCallback<Scope, (Scope::Paylo
 where
     Func: FnOnce(&mut Scope::Payload) + 'static + Send,
 {
-    fn into_timer_oneshot_callback(self) -> AnyTimerCallback<Scope> {
+    fn into_worker_timer_oneshot_callback(self) -> AnyTimerCallback<Scope> {
         AnyTimerCallback::OneShot(Box::new(move |payload, _| self(payload))).into()
     }
 }
@@ -71,7 +71,7 @@ impl<Scope: WorkScope, Func> IntoWorkerTimerOneshotCallback<Scope, (Scope::Paylo
 where
     Func: FnOnce(&mut Scope::Payload, &Arc<TimerState<Scope>>) + 'static + Send,
 {
-    fn into_timer_oneshot_callback(self) -> AnyTimerCallback<Scope> {
+    fn into_worker_timer_oneshot_callback(self) -> AnyTimerCallback<Scope> {
         AnyTimerCallback::OneShot(Box::new(self)).into()
     }
 }
@@ -80,7 +80,7 @@ impl<Scope: WorkScope, Func> IntoWorkerTimerOneshotCallback<Scope, (Scope::Paylo
 where
     Func: FnMut(&mut Scope::Payload, Time) + 'static + Send,
 {
-    fn into_timer_oneshot_callback(mut self) -> AnyTimerCallback<Scope> {
+    fn into_worker_timer_oneshot_callback(mut self) -> AnyTimerCallback<Scope> {
         AnyTimerCallback::OneShot(Box::new(move |payload, t| self(payload, t.handle.clock.now()))).into()
     }
 }

rclrs/src/worker.rs

@@ -2,10 +2,12 @@ use rosidl_runtime_rs::{Message, Service as IdlService};
 use std::{any::Any, sync::{Arc, Mutex, Weak}};
 use futures::channel::oneshot;
 use crate::{
-    WorkerCommands, NodeHandle, ToLogParams, Promise, log_fatal,
+    WorkerCommands, ToLogParams, Promise, log_fatal,
     IntoWorkerSubscriptionCallback, IntoWorkerServiceCallback,
     WorkerSubscription, SubscriptionState, WorkerService, ServiceState,
     SubscriptionOptions, ServiceOptions, RclrsError, Node,
+    IntoWorkerTimerRepeatingCallback, IntoWorkerTimerOneshotCallback,
+    IntoTimerOptions, AnyTimerCallback, WorkerTimer, TimerState,
 };
 
 /// A worker that carries a payload and synchronizes callbacks for subscriptions
@@ -33,7 +35,7 @@ pub type Worker<Payload> = Arc<WorkerState<Payload>>;
 /// [1]: std::sync::Weak
 pub struct WorkerState<Payload> {
     /// The node that this worker is associated with
-    node: Arc<NodeHandle>,
+    node: Node,
     /// The commands to communicate with the runtime of the worker
     commands: Arc<WorkerCommands>,
     _ignore: std::marker::PhantomData<Payload>,
@@ -159,7 +161,7 @@ impl<Payload: 'static + Send + Sync> WorkerState<Payload> {
         SubscriptionState::<T, Worker<Payload>>::create(
             options,
             callback.into_worker_subscription_callback(),
-            &self.node,
+            self.node.handle(),
             &self.commands,
         )
     }
@@ -176,16 +178,75 @@ impl<Payload: 'static + Send + Sync> WorkerState<Payload> {
         ServiceState::<T, Worker<Payload>>::create(
             options,
             callback.into_worker_service_callback(),
-            &self.node,
+            self.node.handle(),
             &self.commands,
         )
     }
 
+    /// Create a [`WorkerTimer`] with a repeating callback.
+    ///
+    /// See also:
+    /// * [`Self::create_timer_oneshot`]
+    /// * [`Self::create_timer_inert`]
+    pub fn create_timer_repeating<'a, Args>(
+        &self,
+        options: impl IntoTimerOptions<'a>,
+        callback: impl IntoWorkerTimerRepeatingCallback<Worker<Payload>, Args>,
+    ) -> Result<WorkerTimer<Payload>, RclrsError> {
+        self.create_timer(options, callback.into_worker_timer_repeating_callback())
+    }
+
+    /// Create a [`WorkerTimer`] whose callback will be triggered once after the
+    /// period of the timer has elapsed. After that you will need to use
+    /// [`WorkerTimer::set_worker_oneshot`] or [`WorkerTimer::set_worker_repeating`]
+    /// or else nothing will happen the following times that the `Timer` elapses.
+    ///
+    /// See also:
+    /// * [`Self::create_timer_repeating`]
+    /// * [`Self::create_time_inert`]
+    pub fn create_timer_oneshot<'a, Args>(
+        &self,
+        options: impl IntoTimerOptions<'a>,
+        callback: impl IntoWorkerTimerOneshotCallback<Worker<Payload>, Args>,
+    ) -> Result<WorkerTimer<Payload>, RclrsError> {
+        self.create_timer(options, callback.into_worker_timer_oneshot_callback())
+    }
+
+    /// Create a [`WorkerTimer`] without a callback. Nothing will happen when this
+    /// `WorkerTimer` elapses until you use [`WorkerTimer::set_worker_repeating`]
+    /// or [`WorkerTimer::set_worker_oneshot`].
+    ///
+    /// See also:
+    /// * [`Self::create_timer_repeating`]
+    /// * [`Self::create_timer_oneshot`]
+    pub fn create_timer_inert<'a>(
+        &self,
+        options: impl IntoTimerOptions<'a>,
+    ) -> Result<WorkerTimer<Payload>, RclrsError> {
+        self.create_timer(options, AnyTimerCallback::Inert)
+    }
+
+    fn create_timer<'a>(
+        &self,
+        options: impl IntoTimerOptions<'a>,
+        callback: AnyTimerCallback<Worker<Payload>>,
+    ) -> Result<WorkerTimer<Payload>, RclrsError> {
+        let options = options.into_timer_options();
+        let clock = options.clock.as_clock(&*self.node);
+        TimerState::create(
+            options.period,
+            clock,
+            callback,
+            &self.commands,
+            &self.node.handle().context_handle,
+        )
+    }
+
     /// Used by [`Node`][crate::Node] to create a `WorkerState`. Users should
     /// call [`Node::create_worker`][crate::NodeState::create_worker] instead of
     /// this.
     pub(crate) fn create(
-        node: Arc<NodeHandle>,
+        node: Node,
         commands: Arc<WorkerCommands>,
     ) -> Arc<Self> {
         Arc::new(Self { node, commands, _ignore: Default::default() })