Enum ActorPath 

#[repr(u8)]
pub enum ActorPath {
    Unique(UniquePath),
    Named(NamedPath),
}

An actor path is a serialisable, possibly remote reference to an actor

Any message sent via an actor path might go over the network, and must be treated as fallible. It must also be serialisable.

Variants

Unique(UniquePath)

A unique actor path identifies a concrete instance of an actor

Unique actor paths use the component’s unique id internally.

Unique actor paths become invalid when a component is replaced with a new instance of the same type.

A unique path may look something like "tcp://127.0.0.1:8080#1e555f40-de1d-4aee-8202-64fdc27edfa8", for example.

Named(NamedPath)

A named actor path identifies a service, rather than a concrete actor instance

Named paths must be registered to a particular actor, and their registration can be changed over time, as actors fail and are replaced, for example.

Named paths may be described hierarchically, similar to URLs.

A named path may look something like "tcp://127.0.0.1:8080/my-actor-group/my-actor", for example.

Implementations

impl ActorPath

pub fn set_protocol(&mut self, proto: Transport)

Change the transport protocol for this actor path

pub fn via_udp(&mut self)

Sets the transport protocol for this actor path to UDP

pub fn via_tcp(&mut self)

Sets the transport protocol for this actor path to TCP

pub fn via_local(&mut self)

Sets the transport protocol for this actor path to LOCAL

pub fn named(self) -> Option<NamedPath>

If this path is a named path, return the underlying named path

Otherwise return None.

pub fn unwrap_named(self) -> NamedPath

Return the underlying named path

Panics if this is not actually a named path variant.

pub fn unique(self) -> Option<UniquePath>

If this path is a unique path, return the underlying unique path

Otherwise return None.

pub fn unwrap_unique(self) -> UniquePath

Return the underlying unique path

Panics if this is not actually a uniqe path variant.

impl ActorPath

pub fn tell<S, B>(&self, m: B, from: &S)

where S: ActorPathFactory + Dispatching, B: Into<Box<dyn Serialisable>>,

Send message m to the actor designated by this path.

The from field is used as a source, and the ActorPath it resolved to will be supplied at the destination.

pub fn tell_with_sender<B, D>(&self, m: B, dispatch: &D, from: ActorPath)

where B: Into<Box<dyn Serialisable>>, D: Dispatching,

Send message m to the actor designated by this path with an explicit sender.

pub fn tell_serialised<CD, B>(&self, m: B, from: &CD) -> Result<(), SerError>

where CD: ComponentTraits + ComponentLifecycle + ActorPathFactory, B: Serialisable + 'static,

Send message m to the actor designated by this path with eager serialisation.

pub fn tell_serialised_with_sender<CD, B>( &self, m: B, dispatch: &CD, from: ActorPath, ) -> Result<(), SerError>

where CD: ComponentTraits + ComponentLifecycle, B: Serialisable + 'static,

Send message m to the actor designated by this path with eager serialisation and an explicit sender.

pub fn tell_preserialised<CD>( &self, content: ChunkRef, from: &CD, ) -> Result<(), SerError>

where CD: ComponentTraits + ComponentLifecycle + ActorPathFactory,

Send prepared message content to the actor designated by this path.

pub fn tell_preserialised_with_sender<CD>( &self, content: ChunkRef, dispatch: &CD, from: ActorPath, ) -> Result<(), SerError>

where CD: ComponentTraits + ComponentLifecycle,

Send preserialised message content to the actor designated by this path with an explicit sender.

pub fn forward_with_original_sender<D>( &self, serialised_message: NetMessage, dispatcher: &D, )

where D: Dispatching,

Forwards the still serialised message to this path without changing the sender.

pub fn forward_with_sender<D>( &self, serialised_message: NetMessage, dispatch: &D, from: ActorPath, )

where D: Dispatching,

Forwards the still serialised message to this path replacing the sender with the given one.

pub fn using_dispatcher<'a, 'b>( &'a self, disp: &'b dyn Dispatching, ) -> DispatchingPath<'a, 'b>

Returns a temporary combination of an ActorPath and something that can dispatch stuff.

Trait Implementations

impl Clone for ActorPath

fn clone(&self) -> ActorPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ActorPath

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

Formats the value using the given formatter.

impl Deserialiser<ActorPath> for ActorPath

const SER_ID: u64 = serialisation_ids::ACTOR_PATH

The serialisation id for which this deserialiser is to be invoked

fn deserialise(buf: &mut dyn Buf) -> Result<ActorPath, SerError>

Try to deserialise a T from the given buf

impl Display for ActorPath

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

Formats the value using the given formatter.

impl From<(SystemPath, Uuid)> for ActorPath

fn from(t: (SystemPath, Uuid)) -> ActorPath

Converts to this type from the input type.

impl From<ActorPath> for PathResolvable

fn from(path: ActorPath) -> PathResolvable

Converts to this type from the input type.

impl From<NamedPath> for ActorPath

fn from(p: NamedPath) -> ActorPath

Converts to this type from the input type.

impl From<UniquePath> for ActorPath

fn from(p: UniquePath) -> ActorPath

Converts to this type from the input type.

impl FromStr for ActorPath

type Err = PathParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<ActorPath, <ActorPath as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for ActorPath

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

where __H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for ActorPath

fn cmp(&self, other: &ActorPath) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ActorPath

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for ActorPath

fn partial_cmp(&self, other: &ActorPath) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialisable for ActorPath

fn serialise(&self, buf: &mut dyn BufMut) -> Result<(), SerError>

Serializes a Unique or Named actor path.

fn ser_id(&self) -> u64

The serialisation id for this serialisable

fn size_hint(&self) -> Option<usize>

An indicator how many bytes must be reserved in a buffer for a value to be serialsed into it with this serialiser

fn local( self: Box<ActorPath>, ) -> Result<Box<dyn Any + Send>, Box<dyn Serialisable>>

Try move this object onto the heap for reflection, instead of serialising

fn serialised(&self) -> Result<Serialised, SerError>

Serialise with a one-off buffer

fn cloned(&self) -> Option<Box<dyn Serialisable>>

Try to produce a cheap in-memory copy of this

impl SystemField for ActorPath

fn system(&self) -> &SystemPath

Returns a reference to the system path

fn protocol(&self) -> Transport

Returns the transport protocol used in the system path

fn address(&self) -> &IpAddr

Returns the address used in the system path

fn port(&self) -> u16

Returns the port used in the system path

impl TryFrom<String> for ActorPath

type Error = PathParseError

The type returned in the event of a conversion error.

fn try_from( s: String, ) -> Result<ActorPath, <ActorPath as TryFrom<String>>::Error>

Performs the conversion.

impl Eq for ActorPath

impl StructuralPartialEq for ActorPath