Enum tor_linkspec::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, _derive_more_display_formatter: &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(original: Ed25519Identity) -> RelayId

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(original: RsaIdentity) -> RelayId

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,

Feeds a slice of this type into the given Hasher.

impl PartialEq<Ed25519Identity> for RelayId

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

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

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

impl StructuralPartialEq for RelayId