Struct meio::Address [−][src]
Address
to send messages to Actor
.
Can be compared each other to identify senders to
the same Actor
.
Implementations
impl<A: Actor> Address<A>
[src]
pub fn id(&self) -> IdOf<A>
[src]
Returns a typed id of the Actor
.
pub async fn act<I>(&mut self, input: I) -> Result<(), Error> where
I: Action,
A: ActionHandler<I>,
[src]
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>,
[src]
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>,
[src]
I: Send + 'static,
A: Scheduled<I>,
Just sends an Action
to the Actor
.
pub fn unpack_parcel(&self, parcel: Parcel<A>) -> Result<(), Error>
[src]
Send a Parcel
to unpacking.
pub fn interact<I>(&self, request: I) -> InteractionTask<I> where
I: Interaction,
A: ActionHandler<Interact<I>>,
[src]
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)
[src]
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>(&mut self, stream: S) -> Result<(), Error> where
A: Consumer<S::Item> + StreamAcceptor<S::Item>,
S: Stream + Send + Unpin + 'static,
S::Item: Send + 'static,
[src]
A: Consumer<S::Item> + StreamAcceptor<S::Item>,
S: Stream + Send + Unpin + 'static,
S::Item: Send + 'static,
Attaches a Stream
of event to an Actor
.
Optimized for intensive streams. For moderate flow you still can
use ordinary Action
s 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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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,
[src]
&'life0 mut self,
msg: T
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn id_ref(&self) -> &Id
[src]
fn dyn_clone(&self) -> Box<dyn ActionRecipient<T>>
[src]
fn dyn_hash(&self, state: &mut dyn Hasher)
[src]
impl<A: Actor> Clone for Address<A>
[src]
fn clone(&self) -> Self
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<A: Actor> Debug for Address<A>
[src]
impl<A: Actor> Eq for Address<A>
[src]
impl<A: Actor> Hash for Address<A>
[src]
fn hash<H: Hasher>(&self, state: &mut H)
[src]
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<T, A> InteractionRecipient<T> for Address<A> where
T: Interaction,
A: Actor + ActionHandler<Interact<T>>,
[src]
T: Interaction,
A: Actor + ActionHandler<Interact<T>>,
fn interact(&mut self, msg: T) -> InteractionTask<T>
[src]
fn id_ref(&self) -> &Id
[src]
fn dyn_clone(&self) -> Box<dyn InteractionRecipient<T>>
[src]
fn dyn_hash(&self, state: &mut dyn Hasher)
[src]
impl<T, A> Into<Box<dyn ActionRecipient<T> + 'static, Global>> for Address<A> where
T: Action,
A: Actor + ActionHandler<T>,
[src]
T: Action,
A: Actor + ActionHandler<T>,
fn into(self) -> Box<dyn ActionRecipient<T>>
[src]
impl<T, A> Into<Box<dyn InteractionRecipient<T> + 'static, Global>> for Address<A> where
T: Interaction,
A: Actor + InteractionHandler<T>,
[src]
T: Interaction,
A: Actor + InteractionHandler<T>,
fn into(self) -> Box<dyn InteractionRecipient<T>>
[src]
impl<A: Actor> PartialEq<Address<A>> for Address<A>
[src]
Auto Trait Implementations
impl<A> !RefUnwindSafe for Address<A>
impl<A> Send for Address<A>
impl<A> Sync for Address<A>
impl<A> Unpin for Address<A>
impl<A> !UnwindSafe for Address<A>
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,