Struct quix::process::Process

pub struct Process<A: Actor<Context = Self>> { /* fields omitted */ }

A special execution context. In this context the actor has a stable identity, whuch should not change. It can also receive messages from remote nodes.

Implementations

impl<A: Actor<Context = Self>> Process<A> where
    A: ProcessDispatch, 

pub fn start(a: A) -> Pid<A>

Start a new process

pub fn start_with(f: impl FnOnce(&mut Self) -> A) -> Pid<A>

Start a new process, with the ability to manipiulate its context before actual startup

pub fn pid(&self) -> Pid<A>

Get Pid of current process

Trait Implementations

impl<A: Actor<Context = Self>> ActorContext for Process<A>

fn stop(&mut self)

Immediately stop processing incoming messages and switch to a stopping state. This only affects actors that are currently running. Future attempts to queue messages will fail.

fn terminate(&mut self)

Terminate actor execution unconditionally. This sets the actor into the stopped state. This causes future attempts to queue messages to fail.

fn state(&self) -> ActorState

Retrieve the current Actor execution state.

impl<A: Actor<Context = Self>> AsyncContext<A> for Process<A>

fn address(&self) -> Addr<A>

Returns the address of the context.

fn spawn<F>(&mut self, fut: F) -> SpawnHandle where
    F: ActorFuture<Output = (), Actor = A> + 'static, 

Spawns a future into the context.

fn wait<F>(&mut self, fut: F) where
    F: ActorFuture<Output = (), Actor = A> + 'static, 

Spawns a future into the context, waiting for it to resolve.

fn waiting(&self) -> bool

Checks if the context is paused (waiting for future completion or stopping).

fn cancel_future(&mut self, handle: SpawnHandle) -> bool

Cancels a spawned future.

fn add_stream<S>(&mut self, fut: S) -> SpawnHandle where
    A: StreamHandler<<S as Stream>::Item>,
    S: Stream + 'static, 

Registers a stream with the context.

fn add_message_stream<S>(&mut self, fut: S) where
    A: Handler<<S as Stream>::Item>,
    S: Stream + 'static,
    <S as Stream>::Item: Message, 

Registers a stream with the context, ignoring errors.

fn notify<M>(&mut self, msg: M) where
    A: Handler<M>,
    M: Message + 'static, 

Sends the message msg to self. This bypasses the mailbox capacity, and will always queue the message. If the actor is in the stopped state, an error will be raised.

fn notify_later<M>(&mut self, msg: M, after: Duration) -> SpawnHandle where
    A: Handler<M>,
    M: Message + 'static, 

Sends the message msg to self after a specified period of time.

fn run_later<F>(&mut self, dur: Duration, f: F) -> SpawnHandle where
    F: FnOnce(&mut A, &mut <A as Actor>::Context) + 'static, 

Executes a closure after a specified period of time.

fn run_interval<F>(&mut self, dur: Duration, f: F) -> SpawnHandle where
    F: FnMut(&mut A, &mut <A as Actor>::Context) + 'static, 

Spawns a job to execute the given closure periodically, at a specified fixed interval.

impl<A: Actor<Context = Self>> AsyncContextParts<A> for Process<A>

fn parts(&mut self) -> &mut ContextParts<A>

impl<A: Actor<Context = Self>, M: Message> ToEnvelope<A, M> for Process<A> where
    A: Handler<M>,
    M: Send + 'static,
    M::Result: Send, 

fn pack(msg: M, tx: Option<Sender<<M as Message>::Result>>) -> Envelope<A>

Pack message into suitable envelope