Struct axiom::actors::ActorId

pub struct ActorId { /* fields omitted */ }

Encapsulates an ID to an actor and is often referred to as an aid.

This is a unique reference to the actor within the entire cluster and can be used to send messages to the actor regardless of location. The ActorId does the heavy lifting of deciding where the actor is and sending the message. However it is important that the user at least has some notion of where the actor is for developing an efficient actor architecture. This id can also be serialized to a remote system transparently.

Methods

impl ActorId

pub fn send(&self, message: Message)

A helper to invoke ActorId::try_send and simply panic if an error occurs. Note that if there is an error that is possible in the send, the user should call try_send instead and handle the error. Panics in Axiom have the capability of taking down the whole actor system and process. The standard practices of Rust are different than Erlang or other actor systems. In Rust the user is expected to handle and manage potential errors. For this reason an intentional decision was made to allow panics to take out the process. Rust developers, suspecting an error, should design around this.

Examples

use axiom::actors::*;
use axiom::message::*;
use std::sync::Arc;

let system = ActorSystem::create(ActorSystemConfig::default());
system.init_current();

let aid = system.spawn(
    0 as usize,
    |_state: &mut usize, _aid: ActorId, _message: &Message| Status::Processed,
 );

aid.send(Message::new(11));

pub fn try_send(&self, message: Message) -> Result<(), ActorError>

Attempts to send a message to the actor with the given ActorId and returns [std::Result::Ok] when the send was successful or [std::Result::Err<ActorError>] error if something went wrong with the send.

This is useful when the user wants to send a message and feels that there is a possibility of an error and that possibility has to be handled gracefully. Note that as with send if a user just calls try_send(msg).unwrap(), a panic could take down the whole process. See the documentation on send for a longer explanation.

Examples

use axiom::actors::*;
use axiom::message::*;
use std::sync::Arc;

let system = ActorSystem::create(ActorSystemConfig::default());
system.init_current();

let aid = system.spawn(
    0 as usize,
    |_state: &mut usize, _aid: ActorId, message: &Message| Status::Processed,
 );

match aid.try_send(Message::new(11)) {
    Ok(_) => println!("OK Then!"),
    Err(e) => println!("Ooops {:?}", e),
}

pub fn uuid(&self) -> Uuid

The unique UUID for this actor within the entire cluster.

pub fn system_uuid(&self) -> Uuid

The unique UUID for the actor system that this actor lives on.

pub fn name(&self) -> Option<String>

The name of the actor as assigned by the user at spawn time if any. Note that this name is guaranteed to be unique only within the actor system in which the actor was started, no guarantees are made that the name will be unique within a cluster of actor systems.

pub fn is_local(&self) -> bool

Determines if this actor lives on actor system in the calling thread.

pub fn sent(&self) -> usize

Returns the total number of messages that have been sent to the actor regardless of whether or not they have been received or processed by the actor. FIXME Move these metrics to be retreived by via a system message because this won't work remote.

pub fn received(&self) -> usize

Returns the total number of messages that have been received by the actor. Note that this doesn't mean that the actor did anything with the message, just that it was received and handled. FIXME Move to be retreived by via a system message because this won't work remote.

pub fn receivable(&self) -> usize

Returns the number of messages that are currently receivable by the actor. This count will not include any messages that have been skipped until the skip is reset. FIXME Move to be retreived by via a system message because this won't work remote.

pub fn pending(&self) -> usize

Returns the total number of messages that are pending in the actor's channel. This should include messages that have been skipped by the actor as well as those that are receivable. FIXME Move to be retreived by via a system message because this won't work remote.

pub fn is_stopped(&self) -> bool

Checks to see if the actor referenced by this ActorId is stopped. FIXME Move to be retreived by via a system message because this won't work remote.

Trait Implementations

impl Clone for ActorId

fn clone(&self) -> ActorId

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq<ActorId> for ActorId

fn eq(&self, other: &ActorId) -> 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 Eq for ActorId

impl Debug for ActorId

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Hash for ActorId

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 Serialize for ActorId

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for ActorId

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.