std:🥅:ToSocketAddrs - Rust (original) (raw)

Trait std::net::ToSocketAddrs1.0.0 [−] [src]

pub trait ToSocketAddrs { type Iter: Iterator<Item = SocketAddr>; fn to_socket_addrs(&self) -> Result<Self::Iter>; }

A trait for objects which can be converted or resolved to one or moreSocketAddr values.

This trait is used for generic address resolution when constructing network objects. By default it is implemented for the following types:

This trait allows constructing network objects like TcpStream orUdpSocket easily with values of various types for the bind/connection address. It is needed because sometimes one type is more appropriate than the other: for simple uses a string like "localhost:12345" is much nicer than manual construction of the corresponding SocketAddr, but sometimesSocketAddr value is the main source of the address, and converting it to some other type (e.g. a string) just for it to be converted back toSocketAddr in constructor methods is pointless.

Addresses returned by the operating system that are not IP addresses are silently ignored.

Creating a SocketAddr iterator that yields one item:

use std:🥅:{ToSocketAddrs, SocketAddr};

let addr = SocketAddr::from(([127, 0, 0, 1], 443)); let mut addrs_iter = addr.to_socket_addrs().unwrap();

assert_eq!(Some(addr), addrs_iter.next()); assert!(addrs_iter.next().is_none());Run

Creating a SocketAddr iterator from a hostname:

use std:🥅:{SocketAddr, ToSocketAddrs};

let mut addrs_iter = "localhost:443".to_socket_addrs().unwrap(); assert_eq!(addrs_iter.next(), Some(SocketAddr::from(([127, 0, 0, 1], 443)))); assert!(addrs_iter.next().is_none());

assert!("foo:443".to_socket_addrs().is_err());Run

Creating a SocketAddr iterator that yields multiple items:

use std:🥅:{SocketAddr, ToSocketAddrs};

let addr1 = SocketAddr::from(([0, 0, 0, 0], 80)); let addr2 = SocketAddr::from(([127, 0, 0, 1], 443)); let addrs = vec![addr1, addr2];

let mut addrs_iter = (&addrs[..]).to_socket_addrs().unwrap();

assert_eq!(Some(addr1), addrs_iter.next()); assert_eq!(Some(addr2), addrs_iter.next()); assert!(addrs_iter.next().is_none());Run

Attempting to create a SocketAddr iterator from an improperly formatted socket address &str (missing the port):

use std::io; use std:🥅:ToSocketAddrs;

let err = "127.0.0.1".to_socket_addrs().unwrap_err(); assert_eq!(err.kind(), io::ErrorKind::InvalidInput);Run

TcpStream::connect is an example of an function that utilizesToSocketAddrs as a trait bound on its parameter in order to accept different types:

use std:🥅:{TcpStream, Ipv4Addr};

let stream = TcpStream::connect(("127.0.0.1", 443));

let stream = TcpStream::connect("127.0.0.1:443");

let stream = TcpStream::connect((Ipv4Addr::new(127, 0, 0, 1), 443));Run

type [Iter](#associatedtype.Iter): [Iterator](../../std/iter/trait.Iterator.html "trait std::iter::Iterator")<Item = [SocketAddr](../../std/net/enum.SocketAddr.html "enum std:🥅:SocketAddr")>

Returned iterator over socket addresses which this type may correspond to.

fn [to_socket_addrs](#tymethod.to%5Fsocket%5Faddrs)(&self) -> [Result](../../std/io/type.Result.html "type std::io::Result")<Self::[Iter](../../std/net/trait.ToSocketAddrs.html#associatedtype.Iter "type std:🥅:ToSocketAddrs::Iter")>

Converts this object to an iterator of resolved SocketAddrs.

The returned iterator may not actually yield any values depending on the outcome of any resolution performed.

Note that this function may block the current thread while resolution is performed.