Struct SubsumptionNode 

pub struct SubsumptionNode {
    pub layers: Vec<SubsumptionLayer>,
}

Subsumption node for priority-based layered control.

This implements the subsumption architecture where behaviors are organized in layers with different priorities. Higher priority layers can override lower priority ones.

Behavior

• Layers are executed in order of priority (highest first)
• If a layer returns Success or Running, execution stops and that status is returned
• If a layer returns Failure, the next lower priority layer is tried
• If all layers fail, the node returns Failure

Use Cases

• Safety-critical systems: Safety behaviors override task behaviors
• Reactive control: Obstacle avoidance overrides navigation
• Hierarchical control: High-level planning with low-level reactive layers

Example

use mecha10_behavior_patterns::prelude::*;


let subsumption = SubsumptionNode::new()
    .add_layer(10, Box::new(EmergencyStopBehavior))    // Highest priority
    .add_layer(5, Box::new(AvoidObstacleBehavior))     // Medium priority
    .add_layer(1, Box::new(NavigateBehavior));         // Lowest priority

Fields

layers: Vec<SubsumptionLayer>

Implementations

impl SubsumptionNode

pub fn new() -> Self

Create a new empty subsumption node.

pub fn add_layer(self, priority: u8, behavior: BoxedBehavior) -> Self

Add a layer with the given priority and behavior.

Layers are automatically sorted by priority (highest first).

Trait Implementations

impl BehaviorNode for SubsumptionNode

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

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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<'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

Formats the value using the given formatter.

impl Default for SubsumptionNode

fn default() -> Self

Returns the “default value” for a type.