Enum RelayId

#[non_exhaustive]
pub enum RelayId {
    Ed25519(Ed25519Identity),
    Rsa(RsaIdentity),
}

A single relay identity.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Ed25519(Ed25519Identity)

An Ed25519 identity.

Rsa(RsaIdentity)

An RSA identity.

Implementations

impl RelayId

pub fn as_ref(&self) -> RelayIdRef<'_>

Return a RelayIdRef pointing to the contents of this identity.

pub fn from_type_and_bytes( id_type: RelayIdType, id: &[u8], ) -> Result<Self, RelayIdError>

Try to construct a RelayId of a provided id_type from a byte-slice.

Return RelayIdError::BadLength if the slice is not the correct length for the key.

pub fn id_type(&self) -> RelayIdType

Return the type of this relay identity.

pub fn as_bytes(&self) -> &[u8]

Return a byte-slice corresponding to the contents of this identity.

The return value discards the type of the identity, and so should be handled with care to make sure that it does not get confused with an identity of some other type.

Trait Implementations

impl Clone for RelayId

fn clone(&self) -> RelayId

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RelayId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RelayId

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for RelayId

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

Formats the value using the given formatter.

impl<'a> From<&'a RelayId> for RelayIdRef<'a>

fn from(ident: &'a RelayId) -> Self

Converts to this type from the input type.

impl From<Ed25519Identity> for RelayId

fn from(value: Ed25519Identity) -> Self

Converts to this type from the input type.

impl From<RelayId> for LinkSpec

fn from(id: RelayId) -> Self

Converts to this type from the input type.

impl From<RsaIdentity> for RelayId

fn from(value: RsaIdentity) -> Self

Converts to this type from the input type.

impl FromIterator<RelayId> for RelayIdSet

fn from_iter<T: IntoIterator<Item = RelayId>>(iter: T) -> Self

Creates a value from an iterator.

impl FromStr for RelayId

fn from_str(s: &str) -> Result<Self, Self::Err>

Try to parse s as a RelayId.

We use the following format, based on the one used by C tor.

• An optional $ followed by a 40 byte hex string is always an RSA key.
• A 43 character un-padded base-64 string is always an Ed25519 key.
• The name of an algorithm (“rsa” or “ed25519”), followed by a colon and and an un-padded base-64 string is a key of that type.

type Err = RelayIdError

The associated error which can be returned from parsing.

impl Hash for RelayId

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 Ord for RelayId

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

fn eq(&self, other: &Ed25519Identity) -> 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 PartialEq<RsaIdentity> for RelayId

fn eq(&self, other: &RsaIdentity) -> 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 PartialEq for RelayId

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

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

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

As Display::fmt, but produce a redacted representation.

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

As Debug::fmt, but produce a redacted representation.

fn redacted(&self) -> Redacted<&Self>

Return a smart pointer that will display or debug this object as its redacted form.

fn maybe_redacted(&self, redact: bool) -> MaybeRedacted<&Self>

Return a smart pointer that redacts this object if redact is true.

impl Serialize for RelayId

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for RelayId

impl Eq for RelayId

impl StructuralPartialEq for RelayId