Struct Supervisor 

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

Implementations

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

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

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

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) -> Supervisor<B, C>

pub fn with_policy(self, policy: RestartPolicy) -> Supervisor<B, C>

pub fn with_budget(self, max: u32, window: Duration) -> Supervisor<B, C>

pub fn with_failure_reaction( self, reaction: fn(&mut B, &SupervisionFailure<<B as Behavior>::Addr>) -> Result<Step<Never, Exit<<B as Behavior>::Addr>>, <B as Behavior>::Error>, ) -> Supervisor<B, C>

Replace the pure reaction used for typed supervision failures.

pub fn is_alive(&self, nonce: <<B as Behavior>::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 Sends: SendAlgebra, B: Behavior<Addr = A, Ph = Ph, Sends = Sends, Birth = Births<C>>, <B as Behavior>::Event: ChildEvent + CreationEvent + WorkerCreationEvent, <A as Address>::Nonce: From<u64>, C: Behavior<Ph = Never, Addr = <B as Behavior>::Addr>, A: Address,

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<Actions<<B as Behavior>::Addr, <B as Behavior>::Ph, SupervisorSends<<B as Behavior>::Addr, <B as Behavior>::Sends, C>, Births<Proxy<C>>>, <B as Behavior>::Error>

Produce initialization actions before the first event is accepted.

fn transition( &mut self, event: <Supervisor<B, C> as Behavior>::Event, ) -> Result<Actions<<B as Behavior>::Addr, <B as Behavior>::Ph, SupervisorSends<<B as Behavior>::Addr, <B as Behavior>::Sends, C>, Births<Proxy<C>>>, <B as Behavior>::Error>

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

fn receive( &mut self, from: Self::Addr, message: Self::Msg, ) -> Result<Actions<Self::Addr, Self::Ph, Self::Sends, Self::Birth>, Self::Error>

where Self: Sized,

Fold one user communication through the composed protocol.

fn on<Input>( &mut self, input: Input, ) -> Result<Actions<Self::Addr, Self::Ph, Self::Sends, Self::Birth>, Self::Error>

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

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