Struct SystemPath 

pub struct SystemPath { /* private fields */ }

The part of an ActorPath that refers to the KompactSystem

As a URI, a SystemPath looks like "tcp://127.0.0.1:8080", for example.

Implementations

impl SystemPath

pub fn new(protocol: Transport, address: IpAddr, port: u16) -> SystemPath

Construct a new system path from individual parts

pub fn with_socket(protocol: Transport, socket: SocketAddr) -> SystemPath

Construct a new system path from individual parts using a SocketAddr

pub fn protocol(&self) -> Transport

Returns a reference to the Transport protocol associated with with this system path

pub fn address(&self) -> &IpAddr

Returns a reference to the IP address associated with with this system path

pub fn port(&self) -> u16

Returns the port associated with with this system path

pub fn into_named_with_string( self, path: &str, ) -> Result<NamedPath, PathParseError>

Create a named path starting with this system path and ending with the given string

Paths created with this function will be validated to be a valid lookup path, and an error will be returned if they are not.

pub fn socket_address(&self) -> SocketAddr

Returns the SocketAddr corresponding to the SystemPath

pub fn into_named_with_vec( self, path: Vec<String>, ) -> Result<NamedPath, PathParseError>

Create a named path starting with this system path and ending with the sequence of path segments

Paths created with this function will be validated to be a valid lookup path, and an error will be returned if they are not.

pub fn into_unique(self, id: Uuid) -> UniquePath

Create a unique path starting with this system path and ending with the given id

Trait Implementations

impl Clone for SystemPath

fn clone(&self) -> SystemPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SystemPath

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

Formats the value using the given formatter.

impl Deserialiser<SystemPath> for SystemPath

const SER_ID: u64 = serialisation_ids::SYSTEM_PATH

The serialisation id for which this deserialiser is to be invoked

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

Try to deserialise a T from the given buf

impl Display for SystemPath

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

Formats the value using the given formatter.

impl Hash for SystemPath

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 SystemPath

fn cmp(&self, other: &SystemPath) -> 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 SystemPath

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

fn partial_cmp(&self, other: &SystemPath) -> 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 SystemPath

Actor Path Serialization

An actor path is either Unique or Named and contains a SystemPath. The SystemPath’s header disambiguates the type (Path type).

Unique Actor Paths

+---------------------------+
| System path (*)         ...
+---------------+-----------+
|      UUID (16 bytes)      |
+---------------------------+

Named Actor Paths

+---------------------------+
| System path (*)         ...
+---------------+-----------+-------------------------------+
|      Named path (2 bytes prefix + variable length)      ...
+-----------------------------------------------------------+

System Paths

+-------------------+-------------------+-----------------------+
| Path type (1 bit) | Protocol (5 bits) | Address Type (2 bits) |
+-------------------+-------------------+-----------------------+----------------+
|                   Address (4/16/ * bytes)                  ...| Port (2 bytes) |
+---------------------------------------------------------------+----------------+

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 serialise(&self, buf: &mut dyn BufMut) -> Result<(), SerError>

Serialises this object (self) into buf

fn local( self: Box<SystemPath>, ) -> 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 SystemPath

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 Eq for SystemPath

impl StructuralPartialEq for SystemPath