Struct FinalizeOnShutdown 

pub struct FinalizeOnShutdown<B: Behavior> { /* private fields */ }

Run one explicit final fold and then stop normally.

The finalization reaction is infallible because it receives mutable access to B: a fallible reaction could change B and then reject the same shutdown fact, violating transition atomicity. Ordinary delegated B transitions retain B::Error.

fn fallible(_: &mut App, _: behavior_actors::ShutdownRequested) -> behavior::BehaviorActed<App> {
    Ok(behavior::Actions::cont())
}
let _ = behavior_actors::FinalizeOnShutdown::new(App, fallible);

Implementations

impl<B: Behavior> FinalizeOnShutdown<B>

pub const fn new(inner: B, finalize: ShutdownReaction<B>) -> Self

Wrap inner with one pure finalization fold on typed shutdown.

The final fold’s sends and creations are preserved and the wrapper then stops normally regardless of the fold’s continuation verdict. Like StopOnShutdown, this wrapper owns the lane it adds; an outer shutdown wrapper therefore takes precedence over this reaction.

Trait Implementations

impl<B, A, Ph, Sends, Br> Behavior for FinalizeOnShutdown<B>

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

type Protocol = <B as Behavior>::Protocol

Stable public communication identity owned by this actor template.

type Event = EventLayer<ShutdownRequested, <B as Behavior>::Event>

type Sends = SendLayer<NoSends, Sends>

type Ph = Ph

type Error = <B as Behavior>::Error

type Birth = Br

fn init( &mut self, _: InitializationTurn, ) -> Result<Actions<A, Ph, Self::Sends, Br>, B::Error>

Produce initialization actions before the first event is accepted.

fn transition( &mut self, _: ActiveTurn, event: Self::Event, ) -> Result<Actions<A, Ph, Self::Sends, Br>, B::Error>

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: Behavior + BehaviorBase> BehaviorBase for FinalizeOnShutdown<B>

type Base = <B as BehaviorBase>::Base

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

impl<B> StashStatus for FinalizeOnShutdown<B>

where B: Behavior + StashStatus,

fn stashed_messages(&self) -> usize