Struct Address

pub struct Address {
    pub node: NodeId,
    pub process: ProcessId,
}

Fields

node: NodeId

process: ProcessId

Implementations

impl Address

Address is defined in hyperware.wit, but constructors and methods here. An Address is a combination of a node ID (string) and a ProcessId. It is used in the Request/crate::Response pattern to indicate which process on a given node in the network to direct the message to. The formatting structure for an Address is node@process_name:package_name:publisher_node

pub fn new<T, U>(node: T, process: U) -> Address

where T: Into<String>, U: Into<ProcessId>,

Create a new Address. Takes a node ID and a process ID.

pub fn node(&self) -> &str

Read the node ID from an Address.

pub fn process(&self) -> &str

Read the process name from an Address.

pub fn package(&self) -> &str

Read the package name from an Address.

pub fn publisher(&self) -> &str

Read the publisher node ID from an Address. Note that Address segments are not parsed for validity, and a node ID stored here is not guaranteed to be a valid ID in the name system, or be connected to an identity at all.

pub fn package_id(&self) -> PackageId

Read the package_id (package + publisher) from an Address.

pub fn send_request(&self) -> Request

Send a Request to Address.

Trait Implementations

impl Clone for Address

fn clone(&self) -> Address

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Address

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

Formats the value using the given formatter.

impl<'a> Deserialize<'a> for Address

fn deserialize<D>(deserializer: D) -> Result<Address, D::Error>

where D: Deserializer<'a>,

Deserialize this value from the given Serde deserializer.

impl Display for Address

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

Formats the value using the given formatter.

impl From<&Address> for Address

fn from(input: &Address) -> Self

Converts to this type from the input type.

impl<T, U> From<(T, U)> for Address

where T: Into<String>, U: Into<ProcessId>,

fn from(input: (T, U)) -> Self

Converts to this type from the input type.

impl<T, U, V, W> From<(T, U, V, W)> for Address

where T: Into<String>, U: Into<&'static str>, V: Into<&'static str>, W: Into<&'static str>,

fn from(input: (T, U, V, W)) -> Self

Converts to this type from the input type.

impl FromStr for Address

fn from_str(input: &str) -> Result<Self, AddressParseError>

Attempt to parse an Address from a string. The formatting structure for an Address is node@process_name:package_name:publisher_node.

The string being parsed must contain exactly one @ and three : characters. The @ character separates the node ID from the rest of the address, and the : characters separate the process name, package name, and publisher node ID.

type Err = AddressParseError

The associated error which can be returned from parsing.

impl Hash for Address

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Address

fn eq(&self, other: &Self) -> 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 Serialize for Address

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Address