Struct magic_wormhole::transit::RelayHint

pub struct RelayHint {
    pub name: Option<String>,
    pub tcp: HashSet<DirectHint>,
    pub ws: HashSet<Url>,
}

Hint describing a relay server

A server may be reachable at multiple locations. Any two must be relayable over that server, therefore a client may pick only one of these per hint.

All locations are URLs, but here they are already deconstructed and grouped by schema out of convenience.

Fields

name: Option<String>

Human readable name. The expectation is that when a server has multiple endpoints, the expectation is that the domain name is used as name

tcp: HashSet<DirectHint>

TCP endpoints of that relay

ws: HashSet<Url>

WebSockets endpoints of that relay

Implementations

impl RelayHint

pub fn new( name: Option<String>, tcp: impl IntoIterator<Item = DirectHint>, ws: impl IntoIterator<Item = Url> ) -> Self

pub fn from_urls( name: Option<String>, urls: impl IntoIterator<Item = Url> ) -> Result<Self, RelayHintParseError>

Construct a relay hint from a list of multiple endpoints, and optionally a name.

Not all URLs are acceptable, therefore this method is fallible. Especially, TCP endpoints must be encoded as tcp://hostname:port. All URLs must be absolute, i.e. start with a /.

Basic usage (default server):

use magic_wormhole::transit;
let hint =
    transit::RelayHint::from_urls(None, [transit::DEFAULT_RELAY_SERVER.parse().unwrap()])
        .unwrap();

Custom relay server from url with name:

use magic_wormhole::transit;
let hint = transit::RelayHint::from_urls(url.host_str().map(str::to_owned), [url]).unwrap();

pub fn can_merge(&self, other: &Self) -> bool

pub fn merge(self, other: Self) -> Self

pub fn merge_mut(&mut self, other: Self)

pub fn merge_into(self, collection: &mut Vec<RelayHint>)

Trait Implementations

impl Clone for RelayHint

fn clone(&self) -> RelayHint

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RelayHint

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

Formats the value using the given formatter.

impl Default for RelayHint

fn default() -> RelayHint

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RelayHint

fn deserialize<D>(de: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RelayHint

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for RelayHint

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RelayHint

impl StructuralEq for RelayHint

impl StructuralPartialEq for RelayHint