Struct ActorContext 

pub struct ActorContext { /* private fields */ }

Trait Implementations

impl Bind<NetAddress> for ActorContext

async fn bind( &mut self, args: BindArgs<NetAddress>, ) -> Result<(), ErrorOf<BindErrorKind>>

impl Drop for ActorContext

fn drop(&mut self)

Executes the destructor for this type.

impl Fork for ActorContext

async fn fork(&mut self) -> Result<Self, ErrorOf<ForkErrorKind>>

async fn run<F, Fut>(self, fun: F)

where F: FnOnce(Self) -> Fut + Send + 'static, Fut: Future + Send + 'static,

impl InitDone for ActorContext

fn init_done(&mut self, address: Address) -> impl Future<Output = ()> + Send

impl Linking for ActorContext

fn link(&mut self, peer: Address) -> impl Future<Output = ()> + Send

fn unlink(&mut self, peer: Address) -> impl Future<Output = ()> + Send

fn set_trap_exit(&mut self, enable: bool) -> impl Future<Output = ()> + Send

impl Messaging for ActorContext

fn address(&self) -> Address

async fn recv(&mut self) -> Result<Envelope, ErrorOf<RecvErrorKind>>

async fn close(&mut self)

fn send( &mut self, envelope: Envelope, ) -> impl Future<Output = Result<(), ErrorOf<SendErrorKind>>> + Send

fn forward( &mut self, to: Address, envelope: Envelope, ) -> impl Future<Output = Result<(), ErrorOf<SendErrorKind>>> + Send

impl Now for ActorContext

type Instant = Instant

fn now(&self) -> Self::Instant

impl Quit for ActorContext

async fn quit_ok(&mut self) -> Never

async fn quit_err<E>(&mut self, reason: E) -> Never

where E: Error + Send + Sync + 'static,

fn quit<E>( &mut self, result: Result<(), E>, ) -> impl Future<Output = Infallible> + Send

where E: Error + Send + Sync + 'static,

impl Start<BoxedRunnable<ActorContext>> for ActorContext

fn spawn( &mut self, runnable: BoxedRunnable<Self>, link: bool, ) -> impl Future<Output = Result<Address, ErrorOf<SpawnErrorKind>>> + Send

fn start( &mut self, runnable: BoxedRunnable<Self>, link: bool, start_timeout: Duration, ) -> impl Future<Output = Result<Address, ErrorOf<StartErrorKind>>> + Send

impl Stop for ActorContext

fn exit(&mut self, peer: Address) -> impl Future<Output = bool> + Send

fn kill(&mut self, peer: Address) -> impl Future<Output = bool> + Send

fn shutdown( &mut self, peer: Address, stop_timeout: Duration, ) -> impl Future<Output = Result<(), ErrorOf<ShutdownErrorKind>>> + Send

where Self: Watching + Fork + Messaging,

impl Watching for ActorContext

fn watch(&mut self, peer: Address) -> impl Future<Output = WatchRef> + Send

fn unwatch(&mut self, watch_ref: WatchRef) -> impl Future<Output = ()> + Send