Struct ros2_client::action::AsyncActionServer

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

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( &mut 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( &mut 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( &mut 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( &mut 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( &mut 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( &mut 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( &mut 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( &mut 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( &mut 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.