Struct parity_multiaddr::Multiaddr

pub struct Multiaddr { /* private fields */ }

Representation of a Multiaddr.

Implementations

impl Multiaddr

pub fn empty() -> Multiaddr

Create a new, empty multiaddress.

pub fn into_bytes(self) -> Vec<u8>

Returns the raw bytes representation of the multiaddr.

pub fn to_bytes(&self) -> Vec<u8>

Return a copy to disallow changing the bytes directly

pub fn from_bytes(bytes: Vec<u8>) -> Result<Multiaddr>

Produces a Multiaddr from its bytes representation.

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

Extracts a slice containing the entire underlying vector.

pub fn encapsulate<T: ToMultiaddr>(&self, input: T) -> Result<Multiaddr>

Wrap a given Multiaddr and return the combination.

Examples

use parity_multiaddr::Multiaddr;

let address: Multiaddr = "/ip4/127.0.0.1".parse().unwrap();
let nested = address.encapsulate("/udt").unwrap();
assert_eq!(nested, "/ip4/127.0.0.1/udt".parse().unwrap());

pub fn append(&mut self, p: Protocol<'_>)

Adds an already-parsed address component to the end of this multiaddr.

Examples

use parity_multiaddr::{Multiaddr, Protocol};

let mut address: Multiaddr = "/ip4/127.0.0.1".parse().unwrap();
address.append(Protocol::Tcp(10000));
assert_eq!(address, "/ip4/127.0.0.1/tcp/10000".parse().unwrap());

pub fn decapsulate<T: ToMultiaddr>(&self, input: T) -> Result<Multiaddr>

Remove the outermost address.

Examples

use parity_multiaddr::{Multiaddr, ToMultiaddr};

let address: Multiaddr = "/ip4/127.0.0.1/udt/sctp/5678".parse().unwrap();
let unwrapped = address.decapsulate("/udt").unwrap();
assert_eq!(unwrapped, "/ip4/127.0.0.1".parse().unwrap());

assert_eq!(
    address.decapsulate("/udt").unwrap(),
    "/ip4/127.0.0.1".to_multiaddr().unwrap()
);

Returns the original if the passed in address is not found

use parity_multiaddr::ToMultiaddr;

let address = "/ip4/127.0.0.1/udt/sctp/5678".to_multiaddr().unwrap();
let unwrapped = address.decapsulate("/ip4/127.0.1.1").unwrap();
assert_eq!(unwrapped, address);

pub fn iter(&self) -> Iter<'_>

Returns the components of this multiaddress.

use std::net::Ipv4Addr;
use parity_multiaddr::{Multiaddr, Protocol};

let address: Multiaddr = "/ip4/127.0.0.1/udt/sctp/5678".parse().unwrap();

let components = address.iter().collect::<Vec<_>>();
assert_eq!(components[0], Protocol::Ip4(Ipv4Addr::new(127, 0, 0, 1)));
assert_eq!(components[1], Protocol::Udt);
assert_eq!(components[2], Protocol::Sctp(5678));

pub fn pop<'a>(&mut self) -> Option<Protocol<'a>>

Pops the last Protocol of this multiaddr, or None if the multiaddr is empty.

use parity_multiaddr::{Multiaddr, Protocol};

let mut address: Multiaddr = "/ip4/127.0.0.1/udt/sctp/5678".parse().unwrap();

assert_eq!(address.pop().unwrap(), Protocol::Sctp(5678));
assert_eq!(address.pop().unwrap(), Protocol::Udt);

Trait Implementations

impl Clone for Multiaddr

fn clone(&self) -> Multiaddr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Multiaddr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Multiaddr

fn deserialize<D>(deserializer: D) -> StdResult<Self, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Multiaddr

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

Convert a Multiaddr to a string

Examples

use parity_multiaddr::Multiaddr;

let address: Multiaddr = "/ip4/127.0.0.1/udt".parse().unwrap();
assert_eq!(address.to_string(), "/ip4/127.0.0.1/udt");

impl<'a> From<Protocol<'a>> for Multiaddr

fn from(p: Protocol<'a>) -> Multiaddr

Converts to this type from the input type.

impl<'a> FromIterator<Protocol<'a>> for Multiaddr

fn from_iter<T>(iter: T) -> Selfwhere
    T: IntoIterator<Item = Protocol<'a>>,

Creates a value from an iterator.

impl FromStr for Multiaddr

type Err = Error

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl Hash for Multiaddr

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<'a> IntoIterator for &'a Multiaddr

type Item = Protocol<'a>

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a>

Creates an iterator from a value.

impl PartialEq<Multiaddr> for Multiaddr

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

fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl ToMultiaddr for Multiaddr

fn to_multiaddr(&self) -> Result<Multiaddr>

Converts this object to a Multiaddr

impl Eq for Multiaddr

impl StructuralEq for Multiaddr

impl StructuralPartialEq for Multiaddr