Struct Supervisor 

pub struct Supervisor<B: Behavior, C: Behavior<Ph = Never, Addr = B::Addr>> { /* private fields */ }

Implementations

impl<B, C> Supervisor<B, C>

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

pub fn new( inner: B, nonces: fn(usize) -> <B::Addr as Address>::Nonce, count: usize, build: fn(usize) -> C, strategy: Strategy, policy: RestartPolicy, max_restarts: u32, window: Duration, ) -> Self

Construct the concrete supervisor behavior hidden by Compose.

Panics

Panics when configured child nonces are not unique. Such a topology would violate creator-local child routing and creation freshness before the behavior could return an initialization result.

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

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

pub fn with_budget(self, max: u32, window: Duration) -> Self

pub fn with_failure_reaction( self, reaction: SupervisionFailureReaction<B>, ) -> Self

Replace the pure reaction used for typed supervision failures.

pub fn is_alive(&self, nonce: <B::Addr as Address>::Nonce) -> bool

Report whether a known supervised proxy is alive.

Panics

Panics when nonce is not part of this supervisor topology.

pub fn child_count(&self) -> usize

pub fn restarts_in_window(&self) -> usize

Trait Implementations

impl<B, C, A, Ph, Sends> Behavior for Supervisor<B, C>

where A: Address, Sends: SendAlgebra, B: Behavior<Addr = A, Ph = Ph, Sends = Sends, Birth = Births<C>>, B::Event: ChildEvent + CreationEvent + WorkerCreationEvent, A::Nonce: From<u64>, C: Behavior<Ph = Never, Addr = B::Addr>,

type Addr = A

type Msg = <B as Behavior>::Msg

type Event = SupervisionEvent<<B as Behavior>::Event>

type Sends = SupervisorSends<A, Sends, C>

type Ph = Ph

type Error = <B as Behavior>::Error

type Birth = Births<Proxy<C>>

fn init(&mut self) -> Result<SupervisorActions<B, C>, B::Error>

Produce initialization actions before the first event is accepted.

fn transition( &mut self, event: Self::Event, ) -> Result<SupervisorActions<B, C>, B::Error>

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

fn receive( &mut self, from: Self::Addr, message: Self::Msg, ) -> BehaviorActed<Self>

where Self: Sized,

Fold one user communication through the composed protocol.

fn on<Input>(&mut self, input: Input) -> BehaviorActed<Self>

where Self: Sized, Self::Event: EventInput<Input>,

Inject one supported semantic input and fold it through this behavior.