Struct CuJointPlannerTask 

pub struct CuJointPlannerTask<P, const N: usize, const M: usize = N> { /* private fields */ }

Anytime planning task (CuAnytimeTask) over any CuJointPlanner.

base() starts a job from the request and runs base_budget work units; each refine() runs refine_budget more. The output only changes when the path cost strictly improves, so the published quality is monotone. Failures (invalid start or goal, invalid request, exhausted search, capacity) are published as a CuJointPlanPath without waypoints whose status names the reason, and the job aborts.

Node config: CuJointPlannerParams. The job seed comes from the task’s rng resource; deterministic planners ignore it. Each planner has a task alias (CuJointRrtConnectTask<N, M = N>, …), so RON names it directly.

Implementations

impl<P: CuJointPlanner<N, M>, const N: usize, const M: usize> CuJointPlannerTask<P, N, M>

pub fn from_planner( planner: P, base_budget: u32, refine_budget: u32, base_seed: u64, ) -> CuResult<Self>

Wraps planner with explicit positive work budgets and a base seed.

pub fn from_params( params: CuJointPlannerParams<P::Params, N, M>, base_seed: u64, ) -> CuResult<Self>

Builds the planner from params (robot models, planner parameters, budgets with per-planner defaults) and wraps it with base_seed.

pub const fn planner(&self) -> &P

The wrapped planner.

pub const fn status(&self) -> CuPlanStatus

Status of the current job.

pub fn debug_state(&self) -> CuJointPlannerDebugState

Compact snapshot of the current job’s progress.

Trait Implementations

impl<P, const N: usize, const M: usize> CuAnytimeTask for CuJointPlannerTask<P, N, M>

where P: CuJointPlanner<N, M> + Send + Sync + 'static,

type Input<'m> = CuStampedData<CuJointPlanRequest<N>, CuMsgMetadata>

type Output<'m> = CuStampedData<CuJointPlanPath<N>, CuMsgMetadata>

type Resources<'r> = Resources

Resources required by the task.

type Quality = Ratio

Measure reported through [AnytimeStatus]: [Quality] for tasks that can score their result, () for tasks that cannot. A quality target can only be configured for tasks whose Quality is comparable to it, so a target on a () task is rejected at compile time.

fn register_debug_state_types(registry: &mut TypeRegistry)

Registers the reflected type used as this task’s debug-state contract.

fn debug_state_type_path() -> &'static str

Returns the reflected type path used as this task’s debug-state schema.

fn with_debug_state<R>(&self, f: impl FnOnce(&dyn Reflect) -> R) -> R

Borrows this task’s current debug-state view.

fn new( config: Option<&ComponentConfig>, resources: Self::Resources<'_>, ) -> CuResult<Self>

Here you need to initialize everything your task will need for the duration of its lifetime. The config allows you to access the configuration of the task.

fn base<'i, 'o>( &mut self, _ctx: &CuContext, input: &Self::Input<'i>, output: &mut Self::Output<'o>, ) -> CuResult<AnytimeStatus<Quality>>

Starts a new job and writes its minimum valid result into output.

fn refine<'o>( &mut self, _ctx: &CuContext, output: &mut Self::Output<'o>, ) -> CuResult<AnytimeStatus<Quality>>

Performs exactly one bounded refinement quantum.

fn start(&mut self, _ctx: &CuContext) -> Result<(), CuError>

Start is called between the creation of the task and the first call to pre/base.

fn preprocess(&mut self, _ctx: &CuContext) -> Result<(), CuError>

This is a method called by the runtime before “base”. This is a kind of best effort, as soon as possible call to give a chance for the task to do some work before to prepare to make “base” as short as possible.

fn postprocess(&mut self, _ctx: &CuContext) -> Result<(), CuError>

This is a method called by the runtime after the job’s refinement window has closed. It is best effort a chance for the task to update some state out of the critical path, for example to release scratch memory or maintain statistics that are not time-critical for the robot.

fn stop(&mut self, _ctx: &CuContext) -> Result<(), CuError>

Called to stop the task. It signals that base/refine won’t be called until start is called again.

impl<P, const N: usize, const M: usize> Freezable for CuJointPlannerTask<P, N, M>

fn freeze<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError>

This method is called by the framework when it wants to save the task state. The default implementation is to encode nothing (stateless). If you have a state, you need to implement this method.

fn thaw<D: Decoder>(&mut self, decoder: &mut D) -> Result<(), DecodeError>

This method is called by the framework when it wants to restore the task to a specific state. Here it is similar to Decode but the framework will give you a new instance of the task (the new method will be called)

impl<P, const N: usize, const M: usize> TypePath for CuJointPlannerTask<P, N, M>

fn type_path() -> &'static str

fn short_type_path() -> &'static str

fn type_ident() -> Option<&'static str>

fn crate_name() -> Option<&'static str>

fn module_path() -> Option<&'static str>