Struct HeterogeneousShutdownCoordinator 

pub struct HeterogeneousShutdownCoordinator<B: Behavior, T>
where
    T: Selection<Addr = BehaviorAddr<B>>,
{ /* private fields */ }

Pure phased shutdown over an arbitrary closed child-protocol sum.

Each choice is interpreted in plan order through its exact concrete ShutdownChild<C, Occurrence> request. Phase completion consumes the shared creator-local creation ID because the child namespace is globally unique. This phased ordering is Bombay policy, not an actor-model guarantee.

Implementations

impl<B: Behavior, T> HeterogeneousShutdownCoordinator<B, T>

where T: Selection<Addr = BehaviorAddr<B>> + Copy,

pub const fn new(inner: B, plan: HeterogeneousShutdownPlan<T>) -> Self

pub const fn awaiting_plan(inner: B) -> Self

Start the wrapper before committed heterogeneous children supply a plan.

pub fn state(&self) -> &ShutdownState<HeterogeneousShutdownPlan<T>, CreationId>

Trait Implementations

impl<B, T, A, Ph, Sends, Br> Behavior for HeterogeneousShutdownCoordinator<B, T>

where A: Address, Sends: SendEffects + SendsFor<B::Event>, Br: BirthMode, B: Behavior<Ph = Ph, Sends = Sends, Birth = Br>, B::Protocol: Protocol<Addr = A>, T: Selection<Addr = A> + Copy,

type Protocol = <B as Behavior>::Protocol

Stable public communication identity owned by this actor template.

type Event = ShutdownCoordinatorEvent<<B as Behavior>::Event, HeterogeneousShutdownPlan<T>>

type Sends = SendLayer<HeterogeneousShutdownSends<T>, Sends>

type Ph = Ph

type Error = ShutdownCoordinatorError<<B as Behavior>::Error, A, HeterogeneousShutdownPlan<T>>

type Birth = Br

fn init(&mut self, _: InitializationTurn) -> BehaviorActed<Self>

Produce initialization actions before the first event is accepted.

fn transition( &mut self, _: ActiveTurn, event: Self::Event, ) -> BehaviorActed<Self>

Fold exactly one event into explicit actions and the next behavior.

fn layer<L>(self, layer: L) -> <L as BehaviorLayer<Self>>::Output

where Self: Sized, L: BehaviorLayer<Self>,

Apply one statically dispatched construction layer.

impl<B, T> BehaviorBase for HeterogeneousShutdownCoordinator<B, T>

where B: Behavior + BehaviorBase, T: Selection<Addr = BehaviorAddr<B>>,

type Base = <B as BehaviorBase>::Base

fn base(&self) -> &Self::Base

impl<B, T> StashStatus for HeterogeneousShutdownCoordinator<B, T>

where B: Behavior + StashStatus, T: Selection<Addr = BehaviorAddr<B>>,

fn stashed_messages(&self) -> usize