Struct Address

pub struct Address<T: ActorType = Dyn<dyn AcceptsNone>> { /* private fields */ }

Types

An Address can be of two basic types: Dynamic or static.

Static

A static address is typed the Protocol of the actor: Address<P>. Any messages the protocol accepts can be sent to this address.

Dynamic

A dynamic address is typed by the messages it accepts: DynAddress![u32, u64, ...]. Any messages that appear can be sent to this address.

For more information, please read the module documentation.

Implementations

impl<T: ActorType> Address<T>

pub fn close(&self) -> bool

Close the Channel.

pub fn halt_some(&self, n: u32)

Halt n processes of the actor.

pub fn halt(&self)

Halt the actor.

This also closes the Inbox.

pub fn process_count(&self) -> usize

Get the amount of processes.

pub fn msg_count(&self) -> usize

Get the amount of messages in the channel.

pub fn address_count(&self) -> usize

Get the amount of addresses of the actor.

pub fn is_closed(&self) -> bool

Whether the channel is closed.

pub fn capacity(&self) -> &Capacity

Get the capacity of the channel.

pub fn has_exited(&self) -> bool

Whether the actor has exited.

pub fn actor_id(&self) -> u64

Get the actor id.

pub fn is_bounded(&self) -> bool

Whether the channel is bounded.

pub fn try_send<M>(&self, msg: M) -> Result<ReturnPart<M>, TrySendError<M>>

where M: Message, T: Accepts<M>,

Attempts to send a message to an actor. If the mailbox is full or if a timeout is returned this method will fail.

pub fn send_now<M>(&self, msg: M) -> Result<ReturnPart<M>, TrySendError<M>>

where M: Message, T: Accepts<M>,

Attempts to send a message to an actor. If the mailbox is full this will fail, but if a timeout is returned then this will succeed.

pub fn send_blocking<M>(&self, msg: M) -> Result<ReturnPart<M>, SendError<M>>

where M: Message, T: Accepts<M>,

Same as send, but blocks the thread instead.

pub fn send<M>(&self, msg: M) -> SendFut<'_, M>

where M: Message, T: Accepts<M>,

Send a message to the actor. If the inbox is full or returns a timeout, wait for this and then send it.

impl<P> Address<P>

where P: ActorType<Channel = Channel<P>>,

pub fn into_dyn<T>(self) -> Address<T>

where P: Protocol + IntoDynamic<T>, T: ActorType<Channel = dyn BoxChannel>,

Convert the static actor into a dynamic one, checked at compile-time.

impl<D> Address<D>

where D: ActorType<Channel = dyn BoxChannel>,

pub fn try_send_unchecked<M>( &self, msg: M, ) -> Result<ReturnPart<M>, TrySendUncheckedError<M>>

where M: Message + Send + 'static, SendPart<M>: Send + 'static,

Send a message to an actor without checking whether this actor accepts the message.

If the actor does not accept the message, then nothing is sent and an error is returned.

pub fn send_now_unchecked<M>( &self, msg: M, ) -> Result<ReturnPart<M>, TrySendUncheckedError<M>>

where M: Message + Send + 'static, SendPart<M>: Send + 'static,

Send a message to an actor without checking whether this actor accepts the message.

If the actor does not accept the message, then nothing is sent and an error is returned.

pub fn send_blocking_unchecked<M>( &self, msg: M, ) -> Result<ReturnPart<M>, SendUncheckedError<M>>

where M: Message + Send + 'static, SendPart<M>: Send + 'static,

Send a message to an actor without checking whether this actor accepts the message.

If the actor does not accept the message, then nothing is sent and an error is returned.

pub async fn send_unchecked<M>( &self, msg: M, ) -> Result<ReturnPart<M>, SendUncheckedError<M>>

where M: Message + Send + 'static, SendPart<M>: Send + 'static,

Send a message to an actor without checking whether this actor accepts the message.

If the actor does not accept the message, then nothing is sent and an error is returned.

pub fn transform_unchecked<T>(self) -> Address<T>

where T: ActorType<Channel = dyn BoxChannel>,

Transform a dynamic-actor of one type into another type without checking if the actor accepts the messages.

In most cases it is recomended to use transform and try_transform instead.

pub fn transform<T>(self) -> Address<T>

where D: IntoDynamic<T>, T: ActorType<Channel = dyn BoxChannel>,

Transfor a dynamic actor of one type into another type, while checking at compile time if the actor accepts all messages.

pub fn try_transform<T>(self) -> Result<Address<T>, Self>

where T: IsDynamic + ActorType<Channel = dyn BoxChannel>,

Transfor a dynamic actor of one type into another type, while checking at runtime if the actor accepts all messages.

Wherever possible use transform instead.

pub fn accepts(&self, id: &TypeId) -> bool

Whether the actor accepts a message of the given type-id.

pub fn downcast<T>(self) -> Result<Address<T>, Self>

where T: Protocol,

Downcast the dynamic actor back into the static actor given a protocol T.

Trait Implementations

impl<T: ActorType> Clone for Address<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: ActorType> Debug for Address<T>

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

Formats the value using the given formatter.

impl<T: ActorType> Future for Address<T>

type Output = ()

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<R: ?Sized, T: ?Sized> IntoAddress<Dyn<T>> for Address<Dyn<R>>

where Dyn<R>: ActorType<Channel = dyn BoxChannel> + IntoDynamic<Dyn<T>>,

fn into_address(self) -> Address<Dyn<T>>

impl<P, T> IntoAddress<Dyn<T>> for Address<P>

where P: Protocol + IntoDynamic<Dyn<T>>, T: ?Sized,

fn into_address(self) -> Address<Dyn<T>>

impl<T: ActorType> Unpin for Address<T>