Struct ShutdownChild 

pub struct ShutdownChild<C: Behavior, Occurrence> {
    pub child: CreationId,
    pub ingress: Ingress<ShutdownRequested, Here>,
    /* private fields */
}

Ask the local interpreter to begin orderly shutdown of one established child of protocol C in the emitting actor’s namespace.

Acceptance is not completion. A successfully accepted request is completed only by the corresponding ChildStopped fact. If the interpreter cannot select an established C child, it must return ChildShutdownRejected rather than fabricate termination or fail the whole action application. Protocol identity is retained in the type even when two child protocols use the same address and nonce types:

struct Queue;
struct Worker;
macro_rules! inert {
    ($actor:ty) => {
        impl behavior::Protocol for $actor {
            type Addr = behavior::MailAddr;
            type Msg = u8;
        }
        impl behavior::Behavior for $actor {
            type Protocol = Self;
            type Event = behavior::User<behavior::MailAddr, u8>;
            type Sends = Vec<behavior::Never>;
            type Ph = behavior::Never;
            type Error = behavior::Never;
            type Birth = behavior::NoBirths;
            fn init(&mut self, _: behavior::InitializationTurn) -> behavior::BehaviorActed<Self> {
                Ok(behavior::Actions::cont())
            }
            fn transition(&mut self, _: behavior::ActiveTurn, _: Self::Event) -> behavior::BehaviorActed<Self> {
                Ok(behavior::Actions::cont())
            }
        }
    };
}
inert!(Queue);
inert!(Worker);

let child = behavior::CreationSequence::new()
    .issue()
    .expect("the first creation ID exists");
let queue = behavior_actors::ShutdownChild::<Queue, behavior::ChildHead>::new(child);
let _: behavior_actors::ShutdownChild<Worker, behavior::ChildHead> = queue;

Repeated occurrences of the same behavior are also incompatible:

struct Worker;
impl behavior::Protocol for Worker {
    type Addr = behavior::MailAddr;
    type Msg = ();
}
impl behavior::Behavior for Worker {
    type Protocol = Self;
    type Event = behavior::User<behavior::MailAddr, ()>;
    type Sends = Vec<behavior::Never>;
    type Ph = behavior::Never;
    type Error = behavior::Never;
    type Birth = behavior::NoBirths;
    fn transition(
        &mut self,
        _: behavior::ActiveTurn,
        _: Self::Event,
    ) -> behavior::BehaviorActed<Self> {
        Ok(behavior::Actions::cont())
    }
}
let child = behavior::CreationSequence::new()
    .issue()
    .expect("the first creation ID exists");
let first = behavior_actors::ShutdownChild::<Worker, behavior::ChildHead>::new(child);
let _: behavior_actors::ShutdownChild<Worker, behavior::ChildTail<behavior::ChildHead>> = first;

Fields

child: CreationId

ingress: Ingress<ShutdownRequested, Here>

Exact shutdown owner in the selected child behavior.

Implementations

impl<C: Behavior, Occurrence> ShutdownChild<C, Occurrence>

pub const fn new(child: CreationId) -> Self

Trait Implementations

impl<C, Occurrence> ActionItem for ShutdownChild<C, Occurrence>

where C: Behavior, <BehaviorAddr<C> as Address>::Nonce: Send,

type Custody = (Option<ShutdownChild<C, Occurrence>>, Option<<ShutdownChild<C, Occurrence> as ActionItem>::Reply>)

type Input<'a> = &'a mut Option<ShutdownChild<C, Occurrence>> where Self: 'a

type Reply = ItemSettlement<ShutdownChild<C, Occurrence>, <ShutdownChild<C, Occurrence> as ActionItem>::Accepted, <ShutdownChild<C, Occurrence> as ActionItem>::Rejection, <ShutdownChild<C, Occurrence> as ActionItem>::Prerequisite>

type Accepted = ()

type Rejection = ChildShutdownRejection

type Prerequisite = CreationCorrelation<<C as Behavior>::Protocol, Occurrence>

fn prepare_interpretation( progress: &mut Option<InterpretationProgress<Self, Self::Custody, Self::Reply>>, )

fn interpretation_input<'a>( custody: &'a mut Self::Custody, ) -> Option<(Self::Input<'a>, &'a mut Option<Self::Reply>)>

where Self: 'a,

fn finish_interpretation( progress: &mut Option<InterpretationProgress<Self, Self::Custody, Self::Reply>>, )

fn retain_accepted(_: Self::Accepted) -> Option<Self::Accepted>

Keep an accepted value only while it still carries terminal custody.

impl<C: Behavior, Occurrence> Clone for ShutdownChild<C, Occurrence>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Behavior, Occurrence> Debug for ShutdownChild<C, Occurrence>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C: Behavior, Occurrence> InterpreterRequest for ShutdownChild<C, Occurrence>

type ReturnToEmitter = ReturnsToEmitter<ChildShutdownRejected, Here>

type LogicalProtocols = NoBirthProtocols

impl<C: Behavior, Occurrence> PartialEq for ShutdownChild<C, Occurrence>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<C: Behavior, Occurrence> Copy for ShutdownChild<C, Occurrence>

impl<C: Behavior, Occurrence> Eq for ShutdownChild<C, Occurrence>