Struct libp2p::Multiaddr

pub struct Multiaddr { /* fields omitted */ }

Representation of a Multiaddr.

Methods

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, Error>

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>(&self, input: T) -> Result<Multiaddr, Error> where     T: ToMultiaddr,

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>(&self, input: T) -> Result<Multiaddr, Error> where     T: ToMultiaddr,

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 Serialize for Multiaddr

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<'de> Deserialize<'de> for Multiaddr

fn deserialize<D>(     deserializer: D ) -> Result<Multiaddr, <D as Deserializer<'de>>::Error> where     D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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: &Multiaddr) -> bool

This method tests for !=.

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 Eq for Multiaddr

impl Debug for Multiaddr

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

Formats the value using the given formatter.

impl FromStr for Multiaddr

type Err = Error

The associated error which can be returned from parsing.

fn from_str(input: &str) -> Result<Multiaddr, Error>

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

impl ToMultiaddr for Multiaddr

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

Converts this object to a Multiaddr

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

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

Performs the conversion.

impl Hash for Multiaddr

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,

Feeds a slice of this type into the given [Hasher].

impl Display for Multiaddr

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

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 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<'a> FromIterator<Protocol<'a>> for Multiaddr

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

Creates a value from an iterator.