Take goal, cancel, and accepted callbacks in ActionServer

I'm not sure that this is actually the signature that we'll want, but
we'll start from there.

Author: nwn

rclrs/src/action.rs

@@ -1,5 +1,5 @@
 mod client;
-mod server;
+pub(crate) mod server;
 mod server_goal_handle;
 
 use crate::rcl_bindings::RCL_ACTION_UUID_SIZE;

rclrs/src/action/server.rs

@@ -1,9 +1,8 @@
 use crate::{
-    error::ToResult, rcl_bindings::*, Clock, NodeHandle, RclrsError, ENTITY_LIFECYCLE_MUTEX,
+    action::{GoalResponse, GoalUuid, CancelResponse, ServerGoalHandle}, error::ToResult, rcl_bindings::*, Clock, NodeHandle, RclrsError, ENTITY_LIFECYCLE_MUTEX,
 };
 use std::{
     ffi::CString,
-    marker::PhantomData,
     sync::{atomic::AtomicBool, Arc, Mutex, MutexGuard},
 };
 
@@ -51,15 +50,18 @@ pub trait ActionServerBase: Send + Sync {
     // fn execute(&self) -> Result<(), RclrsError>;
 }
 
-pub struct ActionServer<T>
+pub type GoalCallback<ActionT> = dyn Fn(GoalUuid, <ActionT as rosidl_runtime_rs::Action>::Goal) -> GoalResponse + 'static + Send + Sync;
+pub type CancelCallback<ActionT> = dyn Fn(ServerGoalHandle<ActionT>) -> CancelResponse + 'static + Send + Sync;
+pub type AcceptedCallback<ActionT> = dyn Fn(ServerGoalHandle<ActionT>) + 'static + Send + Sync;
+
+pub struct ActionServer<ActionT>
 where
-    T: rosidl_runtime_rs::Action,
+    ActionT: rosidl_runtime_rs::Action,
 {
-    _marker: PhantomData<fn() -> T>,
     pub(crate) handle: Arc<ActionServerHandle>,
-    // goal_callback: (),
-    // cancel_callback: (),
-    // accepted_callback: (),
+    goal_callback: Box<GoalCallback<ActionT>>,
+    cancel_callback: Box<CancelCallback<ActionT>>,
+    accepted_callback: Box<AcceptedCallback<ActionT>>,
 }
 
 impl<T> ActionServer<T>
@@ -71,6 +73,9 @@ where
         node_handle: Arc<NodeHandle>,
         clock: Clock,
         topic: &str,
+        goal_callback: impl Fn(GoalUuid, T::Goal) -> GoalResponse + 'static + Send + Sync,
+        cancel_callback: impl Fn(ServerGoalHandle<T>) -> CancelResponse + 'static + Send + Sync,
+        accepted_callback: impl Fn(ServerGoalHandle<T>) + 'static + Send + Sync,
     ) -> Result<Self, RclrsError>
     where
         T: rosidl_runtime_rs::Action,
@@ -119,8 +124,10 @@ where
         });
 
         Ok(Self {
-            _marker: Default::default(),
             handle,
+            goal_callback: Box::new(goal_callback),
+            cancel_callback: Box::new(cancel_callback),
+            accepted_callback: Box::new(accepted_callback),
         })
     }
 }

rclrs/src/node.rs

@@ -220,32 +220,38 @@ impl Node {
         T: rosidl_runtime_rs::Action,
     {
         let action_client = Arc::new(ActionClient::<T>::new(Arc::clone(&self.handle), topic)?);
-        // self.clients
-        //     .push(Arc::downgrade(&client) as Weak<dyn ClientBase>);
+        // self.action_clients
+        //     .push(Arc::downgrade(&action_client) as Weak<dyn ActionClientBase>);
         Ok(action_client)
     }
 
     /// Creates an [`ActionServer`][1].
     ///
     /// [1]: crate::ActionServer
     // TODO: make action server's lifetime depend on node's lifetime
-    pub fn create_action_server<T>(
+    pub fn create_action_server<ActionT, GoalCallback, CancelCallback, AcceptedCallback>(
         &mut self,
         topic: &str,
-        handle_goal: fn(&crate::action::GoalUuid, Arc<T::Goal>) -> GoalResponse,
-        handle_cancel: fn(Arc<ServerGoalHandle<T>>) -> CancelResponse,
-        handle_accepted: fn(Arc<ServerGoalHandle<T>>),
-    ) -> Result<Arc<ActionServer<T>>, RclrsError>
+        handle_goal: GoalCallback,
+        handle_cancel: CancelCallback,
+        handle_accepted: AcceptedCallback,
+    ) -> Result<Arc<ActionServer<ActionT>>, RclrsError>
     where
-        T: rosidl_runtime_rs::Action,
+        ActionT: rosidl_runtime_rs::Action,
+        GoalCallback: Fn(GoalUuid, <ActionT as rosidl_runtime_rs::Action>::Goal) -> GoalResponse + 'static + Send + Sync,
+        CancelCallback: Fn(ServerGoalHandle<ActionT>) -> CancelResponse + 'static + Send + Sync,
+        AcceptedCallback: Fn(ServerGoalHandle<ActionT>) + 'static + Send + Sync,
     {
-        let action_server = Arc::new(ActionServer::<T>::new(
+        let action_server = Arc::new(ActionServer::<ActionT>::new(
             Arc::clone(&self.handle),
             self.get_clock(),
             topic,
+            handle_goal,
+            handle_cancel,
+            handle_accepted,
         )?);
-        // self.servers
-        //     .push(Arc::downgrade(&server) as Weak<dyn ClientBase>);
+        // self.action_servers
+        //     .push(Arc::downgrade(&action_server) as Weak<dyn ActionClientBase>);
         Ok(action_server)
     }