Struct SubsumptionNode 

pub struct SubsumptionNode {
    pub layers: Vec<SubsumptionLayer>,
    /* private fields */
}

Priority-based preemption (subsumption architecture): on each tick, tries each layer highest-priority first. The first layer whose tick() returns Running/Success “wins” and its status is returned for that tick - lower-priority layers aren’t ticked at all that cycle, so their own internal progress (e.g. a SequenceNode’s current child index) is naturally preserved rather than reset, which is what gives a preempted lower layer “resume where it left off” semantics for free.

Fields

layers: Vec<SubsumptionLayer>

Implementations

impl SubsumptionNode

pub fn new() -> SubsumptionNode

Create a new empty subsumption node.

pub fn add_layer( self, priority: u8, behavior: Box<dyn BehaviorNode>, ) -> SubsumptionNode

Add a layer with the given priority and behavior.

Layers are automatically sorted by priority (highest first).

Trait Implementations

impl BehaviorNode for SubsumptionNode

fn active_capability(&self) -> Option<&str>

Forwards the winning layer’s capability (the highest-priority layer whose tick() returned Running/Success this call) - None if every layer failed. Needs its own tracked state (last_winning_layer, set inside tick()) since, unlike SequenceNode’s current_index, “which layer won” isn’t otherwise recoverable after tick() returns.

fn tick<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 Context, ) -> Pin<Box<dyn Future<Output = Result<NodeStatus, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, SubsumptionNode: 'async_trait,

Execute one tick of the behavior.

fn name(&self) -> &str

Get the name of this behavior node.

fn children_mut(&mut self) -> Vec<&mut dyn BehaviorNode>

Return mutable references to this node’s child behaviors, in the order they should receive lifecycle events.

fn reset_self(&mut self)

Reset this node’s own local state, ignoring children.

fn reset<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Reset the behavior to its initial state.

fn on_init<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 Context, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Called when the behavior is first initialized.

fn on_terminate<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 Context, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Called when the behavior is being terminated.

impl Debug for SubsumptionNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for SubsumptionNode

fn default() -> SubsumptionNode

Returns the “default value” for a type.