Struct AsyncActionServer

pub struct AsyncActionServer<A>
where
    A: ActionTypes,
    A::GoalType: Message + Clone,
    A::ResultType: Message + Clone,
    A::FeedbackType: Message,
{ /* private fields */ }

ROS 2 Action Server - Asynchronous version.

Implementations

impl<A> AsyncActionServer<A>

where A: ActionTypes, A::GoalType: Message + Clone, A::ResultType: Message + Clone, A::FeedbackType: Message,

pub fn new(actionserver: ActionServer<A>) -> Self

pub fn get_new_goal( &self, handle: NewGoalHandle<A::GoalType>, ) -> Option<A::GoalType>

pub async fn receive_new_goal(&self) -> ReadResult<NewGoalHandle<A::GoalType>>

where <A as ActionTypes>::GoalType: 'static,

Receive a new goal from an action client. Server should immediately either accept or reject the goal.

pub async fn accept_goal( &self, handle: NewGoalHandle<A::GoalType>, ) -> Result<AcceptedGoalHandle<A::GoalType>, GoalError<()>>

where A::GoalType: 'static,

Convert a newly received goal into a accepted goal, i.e. accept it for execution later. Client will be notified of acceptance. Note: Once the goal is accepted, the server must eventually call .send_result_response() even if the goal is canceled or aborted.

pub async fn reject_goal( &self, handle: NewGoalHandle<A::GoalType>, ) -> Result<(), GoalError<()>>

where A::GoalType: 'static,

Reject a received goal. Client will be notified of rejection. Server should not process the goal further.

pub async fn start_executing_goal( &self, handle: AcceptedGoalHandle<A::GoalType>, ) -> Result<ExecutingGoalHandle<A::GoalType>, GoalError<()>>

Convert an accepted goal into a expecting goal, i.e. start the execution. Executing goal can publish feedback.

pub async fn publish_feedback( &self, handle: ExecutingGoalHandle<A::GoalType>, feedback: A::FeedbackType, ) -> Result<(), GoalError<FeedbackMessage<A::FeedbackType>>>

Publish feedback on how the execution is proceeding.

pub async fn send_result_response( &self, handle: ExecutingGoalHandle<A::GoalType>, result_status: GoalEndStatus, result: A::ResultType, ) -> Result<(), GoalError<()>>

where A::ResultType: 'static,

Notify Client that a goal end state was reached and what was the result of the action. This async will not resolve until the action client has requested for the result, but the client should request the result as soon as server accepts the goal.

pub async fn abort_executing_goal( &self, handle: ExecutingGoalHandle<A::GoalType>, ) -> Result<(), GoalError<()>>

Abort goal execution, because action server has determined it cannot continue execution.

pub async fn abort_accepted_goal( &self, handle: AcceptedGoalHandle<A::GoalType>, ) -> Result<(), GoalError<()>>

pub async fn receive_cancel_request(&self) -> ReadResult<CancelHandle>

Receive a set of cancel requests from the action client. The server should now respond either by accepting (some of) the cancel requests or rejecting all of them. The GoalIds that are requested to be cancelled can be currently at either accepted or executing state.

pub async fn respond_to_cancel_requests( &self, cancel_handle: &CancelHandle, goals_to_cancel: impl Iterator<Item = GoalId>, ) -> WriteResult<(), ()>

Respond to action client’s cancel requests. The iterator of goals should list those GoalIds that will start canceling. For the other GoalIds, the cancel is not accepted and they do not change their state.