Struct EstablishedActor 

pub struct EstablishedActor<B>
where
    B: Behavior,
    <B::Protocol as Protocol>::Addr: EndpointAddress,
{ /* private fields */ }

Inert capability for one exact installed concrete behavior.

An established recipient proves the public protocol endpoint. This value additionally preserves which concrete behavior was installed, allowing lifecycle effects to require static evidence about that behavior’s event algebra. It remains inert: no direct send, shutdown, endpoint accessor, or other ambient effect is exposed.

A protocol recipient cannot issue installed-actor authority:

#[derive(Clone, Copy, Eq, PartialEq)]
struct RuntimeAddr;
impl behavior::Address for RuntimeAddr { type Nonce = u8; }
#[derive(Clone)]
struct Endpoint;
struct Installed<B: behavior::Behavior>(Endpoint, std::sync::mpsc::Sender<B::Event>);
impl<B: behavior::Behavior> Clone for Installed<B> {
    fn clone(&self) -> Self { Self(self.0.clone(), self.1.clone()) }
}
impl behavior::EndpointAddress for RuntimeAddr {
    type Established<P> = Endpoint where P: behavior::Protocol<Addr = Self>;
    type Installed<B> = Installed<B>
        where B: behavior::Behavior<Protocol: behavior::Protocol<Addr = Self>>;
    fn recipient<B>(installed: &Self::Installed<B>) -> Endpoint
    where B: behavior::Behavior<Protocol: behavior::Protocol<Addr = Self>> {
        installed.0.clone()
    }
}
struct Worker;
impl behavior::Protocol for Worker { type Addr = RuntimeAddr; type Msg = (); }
impl behavior::Behavior for Worker {
    type Protocol = Self;
    type Event = behavior::User<RuntimeAddr, ()>;
    type Sends = behavior::NoSends;
    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 recipient = behavior::EstablishedRecipient::<Worker>::issued(Endpoint);
let _: behavior::EstablishedActor<Worker> = behavior::EstablishedActor::issued(recipient);

Two behaviors sharing one protocol retain distinct installed authority:

#[derive(Clone, Copy, Eq, PartialEq)]
struct RuntimeAddr;
impl behavior::Address for RuntimeAddr { type Nonce = u8; }
#[derive(Clone)]
struct Endpoint;
struct Installed<B: behavior::Behavior>(Endpoint, std::sync::mpsc::Sender<B::Event>);
impl<B: behavior::Behavior> Clone for Installed<B> {
    fn clone(&self) -> Self { Self(self.0.clone(), self.1.clone()) }
}
impl behavior::EndpointAddress for RuntimeAddr {
    type Established<P> = Endpoint where P: behavior::Protocol<Addr = Self>;
    type Installed<B> = Installed<B>
        where B: behavior::Behavior<Protocol: behavior::Protocol<Addr = Self>>;
    fn recipient<B>(installed: &Self::Installed<B>) -> Endpoint
    where B: behavior::Behavior<Protocol: behavior::Protocol<Addr = Self>> {
        installed.0.clone()
    }
}
struct Shared;
impl behavior::Protocol for Shared { type Addr = RuntimeAddr; type Msg = (); }
struct First;
struct Second;
impl behavior::Behavior for First {
    type Protocol = Shared;
    type Event = behavior::User<RuntimeAddr, ()>;
    type Sends = behavior::NoSends;
    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()) }
}
impl behavior::Behavior for Second {
    type Protocol = Shared;
    type Event = behavior::EventLayer<u8, behavior::User<RuntimeAddr, ()>>;
    type Sends = behavior::NoSends;
    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 (control, _inbox) = std::sync::mpsc::channel::<<First as behavior::Behavior>::Event>();
let first = behavior::EstablishedActor::<First>::issued(Installed(Endpoint, control));
let _: behavior::EstablishedActor<Second> = first;

Implementations

impl<B> EstablishedActor<B>

where B: Behavior, <B::Protocol as Protocol>::Addr: EndpointAddress,

pub const fn issued( installed: <<B::Protocol as Protocol>::Addr as EndpointAddress>::Installed<B>, ) -> Self

Issue an exact actor capability after successful installation.

This power-user boundary accepts one runtime-owned installed value. Only successful fresh installation and binding commit may issue it. It performs no allocation or validation itself.

pub fn recipient(&self) -> EstablishedRecipient<B::Protocol>

Project the exact public-protocol recipient for this incarnation.

pub fn into_recipient(self) -> EstablishedRecipient<B::Protocol>

Consume the concrete-actor proof and retain its exact protocol recipient.

pub fn interpret_actor<I>(self, interpreter: &mut I) -> I::Output

where I: InterpretInstalledActor<B>,

Transfer the complete installed value with its exact B index.

Trait Implementations

impl<B> Clone for EstablishedActor<B>

where B: Behavior, <B::Protocol as Protocol>::Addr: EndpointAddress,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B> Debug for EstablishedActor<B>

where B: Behavior, <B::Protocol as Protocol>::Addr: EndpointAddress, <<B::Protocol as Protocol>::Addr as EndpointAddress>::Installed<B>: Debug,

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

Formats the value using the given formatter.

impl<B> PartialEq for EstablishedActor<B>

where B: Behavior, <B::Protocol as Protocol>::Addr: EndpointAddress, <<B::Protocol as Protocol>::Addr as EndpointAddress>::Installed<B>: PartialEq,

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<B> Eq for EstablishedActor<B>

where B: Behavior, <B::Protocol as Protocol>::Addr: EndpointAddress, <<B::Protocol as Protocol>::Addr as EndpointAddress>::Installed<B>: Eq,