Enum MaybeResolvedAddress 

pub enum MaybeResolvedAddress<A, R> {
    Resolved(R),
    Unresolved(A),
}

MaybeResolvedAddress is used to represent an address that may or may not be resolved.

Variants

Resolved(R)

The resolved address, which means that can be directly used to communicate with the remote node.

Unresolved(A)

The unresolved address, which means that need to be resolved before using it to communicate with the remote node.

Implementations

impl<A, R> MaybeResolvedAddress<A, R>

pub fn try_unwrap_resolved( self, ) -> Result<R, TryUnwrapError<MaybeResolvedAddress<A, R>>>

Attempts to unwrap this value to the MaybeResolvedAddress::Resolved variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_resolved_ref( &self, ) -> Result<&R, TryUnwrapError<&MaybeResolvedAddress<A, R>>>

Attempts to unwrap this reference to the MaybeResolvedAddress::Resolved variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_resolved_mut( &mut self, ) -> Result<&mut R, TryUnwrapError<&mut MaybeResolvedAddress<A, R>>>

Attempts to unwrap this mutable reference to the MaybeResolvedAddress::Resolved variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_unresolved( self, ) -> Result<A, TryUnwrapError<MaybeResolvedAddress<A, R>>>

Attempts to unwrap this value to the MaybeResolvedAddress::Unresolved variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_unresolved_ref( &self, ) -> Result<&A, TryUnwrapError<&MaybeResolvedAddress<A, R>>>

Attempts to unwrap this reference to the MaybeResolvedAddress::Unresolved variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_unresolved_mut( &mut self, ) -> Result<&mut A, TryUnwrapError<&mut MaybeResolvedAddress<A, R>>>

Attempts to unwrap this mutable reference to the MaybeResolvedAddress::Unresolved variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

impl<A, R> MaybeResolvedAddress<A, R>

pub fn unwrap_resolved(self) -> R

Unwraps this value to the MaybeResolvedAddress::Resolved variant. Panics if this value is of any other type.

pub fn unwrap_resolved_ref(&self) -> &R

Unwraps this reference to the MaybeResolvedAddress::Resolved variant. Panics if this value is of any other type.

pub fn unwrap_resolved_mut(&mut self) -> &mut R

Unwraps this mutable reference to the MaybeResolvedAddress::Resolved variant. Panics if this value is of any other type.

pub fn unwrap_unresolved(self) -> A

Unwraps this value to the MaybeResolvedAddress::Unresolved variant. Panics if this value is of any other type.

pub fn unwrap_unresolved_ref(&self) -> &A

Unwraps this reference to the MaybeResolvedAddress::Unresolved variant. Panics if this value is of any other type.

pub fn unwrap_unresolved_mut(&mut self) -> &mut A

Unwraps this mutable reference to the MaybeResolvedAddress::Unresolved variant. Panics if this value is of any other type.

impl<A, R> MaybeResolvedAddress<A, R>

pub const fn is_resolved(&self) -> bool

Returns true if this value is of type Resolved. Returns false otherwise

pub const fn is_unresolved(&self) -> bool

Returns true if this value is of type Unresolved. Returns false otherwise

impl<A, R> MaybeResolvedAddress<A, R>

pub const fn resolved(addr: R) -> MaybeResolvedAddress<A, R>

Creates a resolved address.

pub const fn unresolved(addr: A) -> MaybeResolvedAddress<A, R>

Creates an unresolved address.

pub const fn as_ref(&self) -> MaybeResolvedAddress<&A, &R>

Converts from &MaybeResolvedAddress<A, R> to MaybeResolvedAddress<&A, &R>.

pub const fn as_mut(&mut self) -> MaybeResolvedAddress<&mut A, &mut R>

Converts from &mut MaybeResolvedAddress<A, R> to MaybeResolvedAddress<&mut A, &mut R>.

Trait Implementations

impl<A, R> Arbitrary for MaybeResolvedAddress<A, R>

where A: Arbitrary, R: Arbitrary,

fn arbitrary(g: &mut Gen) -> MaybeResolvedAddress<A, R>

Return an arbitrary value.

fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

Return an iterator of values that are smaller than itself.

impl<'arbitrary, A, R> Arbitrary<'arbitrary> for MaybeResolvedAddress<A, R>

where A: Arbitrary<'arbitrary>, R: Arbitrary<'arbitrary>,

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<MaybeResolvedAddress<A, R>, Error>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<MaybeResolvedAddress<A, R>, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<A, R> CheapClone for MaybeResolvedAddress<A, R>

where A: CheapClone, R: CheapClone,

fn cheap_clone(&self) -> MaybeResolvedAddress<A, R>

Returns a copy of the value.

impl<A, R> Clone for MaybeResolvedAddress<A, R>

where A: Clone, R: Clone,

fn clone(&self) -> MaybeResolvedAddress<A, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, R> Copy for MaybeResolvedAddress<A, R>

where A: Copy, R: Copy,

impl<A, R> Data for MaybeResolvedAddress<A, R>

where A: Data, R: Data,

type Ref<'a> = MaybeResolvedAddress<<A as Data>::Ref<'a>, <R as Data>::Ref<'a>>

The reference type of the data.

fn from_ref( val: <MaybeResolvedAddress<A, R> as Data>::Ref<'_>, ) -> Result<MaybeResolvedAddress<A, R>, DecodeError>

where MaybeResolvedAddress<A, R>: Sized,

Converts the reference type to the owned type.

fn encoded_len(&self) -> usize

Returns the encoded length of the data only considering the data itself, (e.g. no length prefix, no wire type).

fn encode(&self, buf: &mut [u8]) -> Result<usize, EncodeError>

Encodes the message to a buffer.

const WIRE_TYPE: WireType = WireType::LengthDelimited

The wire type of the data.

fn encoded_len_with_length_delimited(&self) -> usize

Returns the encoded length of the data including the length delimited.

fn encode_to_vec(&self) -> Result<Vec<u8>, EncodeError>

Available on crate features alloc or std only.

Encodes the message into a vec.

fn encode_to_bytes(&self) -> Result<Bytes, EncodeError>

Available on crate features alloc or std only.

Encodes the message into a Bytes.

fn encode_length_delimited(&self, buf: &mut [u8]) -> Result<usize, EncodeError>

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Result<Vec<u8>, EncodeError>

Available on crate features alloc or std only.

Encodes the message with a length-delimiter into a vec.

fn encode_length_delimited_to_bytes(&self) -> Result<Bytes, EncodeError>

Available on crate features alloc or std only.

Encodes the message with a length-delimiter into a Bytes.

fn decode(src: &[u8]) -> Result<(usize, Self), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: &[u8]) -> Result<(usize, Self), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from the buffer.

impl<'a, A, R> DataRef<'a, MaybeResolvedAddress<A, R>> for MaybeResolvedAddress<<A as Data>::Ref<'a>, <R as Data>::Ref<'a>>

where A: Data, R: Data,

fn decode( buf: &'a [u8], ) -> Result<(usize, MaybeResolvedAddress<<A as Data>::Ref<'a>, <R as Data>::Ref<'a>>), DecodeError>

where MaybeResolvedAddress<<A as Data>::Ref<'a>, <R as Data>::Ref<'a>>: Sized,

Decodes the reference type from a buffer.

fn decode_length_delimited(src: &'a [u8]) -> Result<(usize, Self), DecodeError>

where Self: Sized,

Decodes a length-delimited reference instance of the message from the buffer.

impl<A, R> Debug for MaybeResolvedAddress<A, R>

where A: Debug, R: Debug,

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

Formats the value using the given formatter.

impl<'de, A, R> Deserialize<'de> for MaybeResolvedAddress<A, R>

where A: Deserialize<'de>, R: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<MaybeResolvedAddress<A, R>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A, R> Display for MaybeResolvedAddress<A, R>

where R: Display, A: Display,

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

Formats the value using the given formatter.

impl<A, R> Eq for MaybeResolvedAddress<A, R>

where A: Eq, R: Eq,

impl<A, R> Hash for MaybeResolvedAddress<A, R>

where A: Hash, R: Hash,

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<A, R> PartialEq for MaybeResolvedAddress<A, R>

where A: PartialEq, R: PartialEq,

fn eq(&self, other: &MaybeResolvedAddress<A, R>) -> 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<A, R> Serialize for MaybeResolvedAddress<A, R>

where A: Serialize, R: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A, R> StructuralPartialEq for MaybeResolvedAddress<A, R>

where A: PartialEq, R: PartialEq,