Struct Stash 

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

FIFO message holding for an infallible inner fold.

Releasing one command may replay several retained mailbox inputs in one transition. Because behavior::Actions has no rollback effect, a fallible inner fold could reject after earlier replayed inputs had already produced unreturnable actions. Such an inner behavior is therefore not a valid Stash composition:

struct Fallible;
impl behavior::Protocol for Fallible { type Addr = behavior::MailAddr; type Msg = (); }
impl behavior::Behavior for Fallible {
    type Protocol = Self;
    type Event = behavior::User<behavior::MailAddr, ()>;
    type Sends = Vec<behavior::Never>;
    type Ph = behavior::Never;
    type Error = u8;
    type Birth = behavior::NoBirths;
    fn transition(&mut self, _: behavior::ActiveTurn, _: Self::Event) -> behavior::BehaviorActed<Self> {
        Err(1)
    }
}
fn route(_: &()) -> behavior_actors::StashRoute { behavior_actors::StashRoute::Release }
fn requires_behavior<B: behavior::Behavior>(_: &B) {}
requires_behavior(&behavior_actors::Stash::new(Fallible, |_, message| route(message)));

Implementations

impl<B: Behavior<Ph = Never>> Stash<B>

pub fn new(inner: B, route: fn(&B, &BehaviorMessage<B>) -> StashRoute) -> Self

Wrap inner with route, a pure decision over the actual inner state and message.

Stashed messages retain FIFO order and ownership until a later StashRoute::Release. Each replay borrows the state returned by the preceding inner transition; the route must perform no effect. Construction performs no transition or runtime operation.

pub fn held(&self) -> usize

Trait Implementations

impl<B, A, Sends, Br> Behavior for Stash<B>

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

type Protocol = <B as Behavior>::Protocol

Stable public communication identity owned by this actor template.

type Event = <B as Behavior>::Event

type Sends = Sends

type Ph = Never

type Error = <B as Behavior>::Error

type Birth = Br

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

Produce initialization actions before the first event is accepted.

fn transition( &mut self, _: ActiveTurn, event: B::Event, ) -> Result<Actions<A, Never, Sends, Br>, Self::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> BehaviorBase for Stash<B>

where B: Behavior<Ph = Never> + BehaviorBase,

type Base = <B as BehaviorBase>::Base

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

impl<B: Behavior<Ph = Never>> StashStatus for Stash<B>

fn stashed_messages(&self) -> usize