Struct meio::Address

pub struct Address<A: Actor> { /* fields omitted */ }

Address to send messages to Actor.

Can be compared each other to identify senders to the same Actor.

Implementations

impl<A: Actor> Address<A>

pub fn id(&self) -> IdOf<A>

Returns a typed id of the Actor.

pub async fn act<I>(&mut self, input: I) -> Result<(), Error> where
    I: Action,
    A: ActionHandler<I>, 

Just sends an Action to the Actor.

pub fn instant<I>(&self, input: I) -> Result<(), Error> where
    I: InstantAction,
    A: InstantActionHandler<I>, 

Just sends an Action to the Actor.

pub fn schedule<I>(&self, input: I, deadline: Instant) -> Result<(), Error> where
    I: Send + 'static,
    A: Scheduled<I>, 

Just sends an Action to the Actor.

pub fn unpack_parcel(&self, parcel: Parcel<A>) -> Result<(), Error>

Send a Parcel to unpacking.

pub fn interact<I>(&self, request: I) -> InteractionTask<I> where
    I: Interaction,
    A: ActionHandler<Interact<I>>, 

Interacts with an Actor and waits for the result of the Interaction.

ActionHandler required instead of InteractionHandler to make it possible to work with both types of handler, because ActionHandler can be used for long running interaction and prevent blocking of the actor’s routine.

To avoid blocking you shouldn’t await the result of this Interaction, but create a Future and await in a separate coroutine of in a LiteTask.

pub async fn join(self)

Waits when the Actor will be terminated.

It consumes address, because it useless after termination. Also it prevents blocking queue if Actor uses it to detect the right time for termination.

pub fn attach<S, M>(&mut self, stream: S, tag: M) -> Result<(), Error> where
    A: Consumer<S::Item> + StreamAcceptor<S::Item>,
    S: Stream + Send + Unpin + 'static,
    S::Item: Send + 'static,
    M: Tag, 

Attaches a Stream of event to an Actor. Optimized for intensive streams. For moderate flow you still can use ordinary Actions and act method calls.

It spawns a routine that groups multiple items into a single chunk to reduce amount as async calls of a handler.

pub fn link<T>(&self) -> T where
    T: From<Self>, 

Returns a Link to an Actor. Link is a convenient concept for creating wrappers for Address that provides methods instead of using message types directly. It allows also to use private message types opaquely.

pub fn action_recipient<T>(&self) -> Box<dyn ActionRecipient<T>> where
    T: Action,
    A: ActionHandler<T>, 

Returns an ActionRecipient instance.

pub fn interaction_recipient<T>(&self) -> Box<dyn InteractionRecipient<T>> where
    T: Interaction,
    A: InteractionHandler<T>, 

Returns an InteractionRecipient instance.

Trait Implementations

impl<T, A> ActionRecipient<T> for Address<A> where
    T: Action,
    A: Actor + ActionHandler<T>, 

fn act<'life0, 'async_trait>(
    &'life0 mut self,
    msg: T
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Send an Action to an Actor.

fn id_ref(&self) -> &Id

fn dyn_clone(&self) -> Box<dyn ActionRecipient<T>>

fn dyn_hash(&self, state: &mut dyn Hasher)

impl<A: Actor> Clone for Address<A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Actor> Debug for Address<A>

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

Formats the value using the given formatter.

impl<A: Actor> Hash for Address<A>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T, A> InteractionRecipient<T> for Address<A> where
    T: Interaction,
    A: Actor + ActionHandler<Interact<T>>, 

fn interact(&mut self, msg: T) -> InteractionTask<T>

Interact with an Actor.

fn id_ref(&self) -> &Id

fn dyn_clone(&self) -> Box<dyn InteractionRecipient<T>>

fn dyn_hash(&self, state: &mut dyn Hasher)

impl<A: Actor> PartialEq<Address<A>> for Address<A>

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl<A: Actor> Eq for Address<A>