Struct Spec 

pub struct Spec<B> { /* private fields */ }

Implementations

impl<S: State<O, Br, E>, O, Br: BirthMode, E> Spec<Base<S, O, Br, E>>

pub fn new(state: S) -> Self

impl<A, S, M, P, E> Spec<Fsm<A, S, M, P, E>>

where A: Address, P: Copy + PartialEq,

pub fn machine( state: S, phase: P, on: fn(P, &mut S, &M) -> Result<Move<P>, E>, ) -> Self

impl<B: Behavior> Spec<B>

pub fn from_behavior(behavior: B) -> Self

pub fn build(self) -> B

pub fn behavior(&self) -> &B

pub fn stop_on_shutdown(self) -> Spec<StopOnShutdown<B>>

Stop normally when a typed shutdown request is folded.

pub fn finalize_on_shutdown( self, finalize: ShutdownReaction<B>, ) -> Spec<FinalizeOnShutdown<B>>

Apply one final pure fold, retain its sends and creations, and stop normally regardless of the fold’s become verdict.

pub fn watch( self, peer: B::Addr, on_stopped: LinkReaction<B>, ) -> Spec<Watching<B>>

Observe a peer and apply a pure reaction when it stops.

pub fn at(self, when: Option<Instant>, on_reached: AtReaction<B>) -> Spec<At<B>>

Apply a pure reaction when the given absolute time is reached.

Panics

Panics if one specification composes more than u64::MAX timer capabilities.

pub fn stash(self, route: fn(&B::Msg) -> StashRoute) -> Spec<Stashing<B>>

where B: Behavior<Ph = Never>,

Hold messages selected by route and replay them on Release.

pub fn children<C>( self, fleet: (usize, fn(usize) -> C), ) -> Spec<Supervising<B, C>>

where B: Behavior<Birth = Births<C>>, C: Behavior<Ph = Never, Addr = B::Addr>, <B::Addr as Address>::Nonce: From<u64>,

Create a supervised child topology. Concrete proxy and monitor types remain hidden in the returned typestate.

pub fn children_with_nonces<C>( self, nonces: fn(usize) -> <B::Addr as Address>::Nonce, count: usize, build: fn(usize) -> C, ) -> Spec<Supervising<B, C>>

where B: Behavior<Birth = Births<C>>, C: Behavior<Ph = Never, Addr = B::Addr>,

impl<B, C> Spec<Supervising<B, C>>

where B: Behavior<Birth = Births<C>>, C: Behavior<Ph = Never, Addr = B::Addr>,

pub fn restart(self, strategy: Strategy) -> Self

pub fn when(self, policy: RestartPolicy) -> Self

pub fn within(self, maximum: u32, window: Duration) -> Self

Trait Implementations

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

where A: Address + Send, Sends: SendAlgebra, Br: BirthMode, B: Behavior<Addr = A, Ph = Ph, Sends = Sends, Birth = Br, Effect = Actions<A, Ph, Sends, Br>, Done = Exit<A>> + Send, A::Nonce: Send, B::Msg: Send, B::Event: Send,

type Addr = A

type Msg = <B as Behavior>::Msg

type Event = <B as Behavior>::Event

type Sends = Sends

type Ph = Ph

type Error = <B as Behavior>::Error

type Birth = Br

type Effect = <B as Behavior>::Effect

type Done = <B as Behavior>::Done

async fn init(&mut self) -> Result<Self::Effect, B::Error>

async fn step(&mut self, event: B::Event) -> Result<Self::Effect, B::Error>