Struct multiaddr::Multiaddr

pub struct Multiaddr { /* fields omitted */ }

Representation of a Multiaddr.

Methods

impl Multiaddr

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 protocol(&self) -> Vec<Protocol>

Deprecated:

Use self.iter().map(|addr| addr.protocol_id()) instead

Return a list of protocols

Examples

A single protocol

use multiaddr::{Multiaddr, Protocol};

let address: Multiaddr = "/ip4/127.0.0.1".parse().unwrap();
assert_eq!(address.protocol(), vec![Protocol::IP4]);

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

Wrap a given Multiaddr and return the combination.

Examples

use 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, component: AddrComponent)

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

Examples

use multiaddr::{Multiaddr, AddrComponent};

let mut address: Multiaddr = "/ip4/127.0.0.1".parse().unwrap();
address.append(AddrComponent::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 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 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);

Important traits for Iter<'a>

impl<'a> Iterator for Iter<'a> type Item = AddrComponent;

pub fn iter(&self) -> Iter

Returns the components of this multiaddress.

use std::net::Ipv4Addr;
use multiaddr::AddrComponent;
use multiaddr::Multiaddr;

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

let components = address.iter().collect::<Vec<_>>();
assert_eq!(components[0], AddrComponent::IP4(Ipv4Addr::new(127, 0, 0, 1)));
assert_eq!(components[1], AddrComponent::UDT);
assert_eq!(components[2], AddrComponent::SCTP(5678));

pub fn pop(&mut self) -> Option<AddrComponent>

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

use multiaddr::AddrComponent;
use multiaddr::Multiaddr;

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

assert_eq!(address.pop().unwrap(), AddrComponent::SCTP(5678));
assert_eq!(address.pop().unwrap(), AddrComponent::UDT);

Trait Implementations

impl ToMultiaddr for Multiaddr

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

Converts this object to a Multiaddr

impl From<AddrComponent> for Multiaddr

fn from(addr: AddrComponent) -> Multiaddr

Performs the conversion.

impl<'a> IntoIterator for &'a Multiaddr

type Item = AddrComponent

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

Important traits for Iter<'a>

impl<'a> Iterator for Iter<'a> type Item = AddrComponent;

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

Creates an iterator from a value.

impl Eq for Multiaddr

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

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

Convert a Multiaddr to a string

Examples

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

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

impl FromIterator<AddrComponent> for Multiaddr

fn from_iter<T>(iter: T) -> Self where     T: IntoIterator<Item = AddrComponent>,

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.