Struct aktoro_context::Context

pub struct Context<A: Actor, R: Runtime> { /* fields omitted */ }

An actor context using the aktoro-channel crate.

Trait Implementations

impl<A, R> Drop for Context<A, R> where
    A: Actor,
    R: Runtime, 

fn drop(&mut self)

Executes the destructor for this type.

impl<A, RT> Context<A> for Context<A, RT> where
    A: Actor + 'static,
    RT: Runtime, 

type Config = ContextConfig

type Controller = Controller<A>

type Sender = Sender<A>

type Updater = Updater<A>

fn new(actor_id: u64, config: ContextConfig) -> Context<A, RT>

Creates a new context with the provided config and an identifier for the actor.

fn actor_id(&self) -> u64

Returns the actor's identifier.

fn emit<E>(&mut self, event: E) where
    A: EventHandler<E>,
    E: Send + 'static, 

Emits an event that will be handled by the actor.

fn status(&self) -> &A::Status

Gets the actor's current status.

fn set_status(&mut self, status: A::Status)

Sets the actor's current status, eventually making action to reflect the change (e.g. by stopping the actor).

fn update(&mut self) -> Result<(), TrySendError<Update<A>>>

Shares the actor's current status through the actor's update channel.

fn controller(&self) -> &Controller<A>

Gets the actor's action channel sender.

fn sender(&self) -> &Sender<A>

Gets the actor's message channel sender.

fn updated_ref(&mut self) -> Option<&mut Updated<A>>

Tries to get a mutable reference to the actor's update channel sender.

fn updated(&mut self) -> Option<Updated<A>>

Tries to get the actor's update channel sender.

fn controlled(&mut self) -> &mut Controlled<A>

Gets a mutable reference to the actor's action channel receiver.

fn receiver(&mut self) -> &mut Receiver<A>

Gets a mutable reference to the actor's message channel receiver.

fn updater(&mut self) -> &mut Updater<A>

Gets a mutable reference to the actors's update channel receiver.

fn actors(&self) -> Vec<u64>

Returns a list of the context's inner runtime's actors' identifier.

fn spawn<S, C>(&mut self, actor: S) -> Option<Spawned<S>> where
    S: Actor<Context = C> + 'static,
    C: Context<S, Config = ContextConfig>, 

Spawns a sub-actor on the context's inner runtime.

fn wait<F, M, O, T>(&mut self, fut: Pin<Box<F>>, map: M) -> Cancellable<F> where
    F: Future<Output = O> + Unpin + Send + 'static,
    M: Fn(O) -> T + Unpin + Send + Sync + 'static,
    A: Handler<T, Output = ()>,
    O: Send + 'static,
    T: Send + 'static, 

Waits for a future to yield before mapping it to a message and passing it to the actor.

fn blocking_wait<F, M, O, T>(
    &mut self,
    fut: Pin<Box<F>>,
    map: M
) -> Cancellable<F> where
    F: Future<Output = O> + Unpin + Send + 'static,
    M: Fn(O) -> T + Unpin + Send + Sync + 'static,
    A: Handler<T, Output = ()>,
    O: Send + 'static,
    T: Send + 'static, 

Waits for a future to yield before mapping it to a message and passing it to the actor.

fn subscribe<S, M, I, T>(
    &mut self,
    stream: Pin<Box<S>>,
    map: M
) -> Cancellable<S> where
    S: Stream<Item = I> + Unpin + Send + 'static,
    M: Fn(I) -> T + Unpin + Send + Sync + 'static,
    A: Handler<T, Output = ()>,
    I: Send + 'static,
    T: Send + 'static, 

Forwards the items yielded by a stream to the actor after mapping them to a message.

fn read<R, M, N, T, E>(
    &mut self,
    read: Pin<Box<R>>,
    cap: usize,
    map: M,
    map_err: N
) -> Cancellable<R> where
    R: AsyncRead + Unpin + Send + 'static,
    M: Fn(Vec<u8>) -> T + Unpin + Send + Sync + 'static,
    N: Fn(Error) -> E + Unpin + Send + Sync + 'static,
    A: Handler<T, Output = ()> + Handler<E, Output = ()>,
    T: Send + 'static,
    E: Send + 'static, 

Forwards the received data to the actor after either mapping it or a returned error to a message.

fn write<W, M, N, T, E>(
    &mut self,
    write: Pin<Box<W>>,
    data: Vec<u8>,
    map: M,
    map_err: N
) -> Cancellable<W> where
    W: AsyncWrite + Unpin + Send + 'static,
    M: Fn((Vec<u8>, usize), Pin<Box<W>>) -> T + Unpin + Send + Sync + 'static,
    N: Fn(Error) -> E + Unpin + Send + Sync + 'static,
    A: Handler<T, Output = ()> + Handler<E, Output = ()>,
    T: Send + 'static,
    E: Send + 'static, 

Waits for data to be written over an asynchronous writer, then passing a message returned by either map or map_err (depending on whether an error was returned by the writer) to the actor.

fn blocking_write<W, M, N, T, E>(
    &mut self,
    write: Pin<Box<W>>,
    data: Vec<u8>,
    map: M,
    map_err: N
) -> Cancellable<W> where
    W: AsyncWrite + Unpin + Send + 'static,
    M: Fn((Vec<u8>, usize), Pin<Box<W>>) -> T + Unpin + Send + Sync + 'static,
    N: Fn(Error) -> E + Unpin + Send + Sync + 'static,
    A: Handler<T, Output = ()> + Handler<E, Output = ()>,
    T: Send + 'static,
    E: Send + 'static, 

Waits for data to be written over an asynchronous writer, then passing a message returned by either map or map_err (depending on whether an error was returned by the writer) to the actor.

impl<A, R> Stream for Context<A, R> where
    A: Actor,
    R: Runtime, 

type Item = Work<A>

Values yielded by the stream.

fn poll_next(self: Pin<&mut Self>, ctx: &mut Context) -> Poll<Option<Work<A>>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.