Enum UniAddr

Source

#[non_exhaustive]pub enum UniAddr<'a> {
    Inet(SocketAddr),
    Unix(UnixAddr<'a>),
    Host(HostAddr<'a>),
}

Expand description

A unified address type that can represent:

Currently, the lifetime parameter 'a is not actually used. See UnixAddr or HostAddr for more details.

Variants (Non-exhaustive)§

This enum is marked as non-exhaustive

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

§

Implementations§

Source §

impl<'a> UniAddr<'a>

Source

pub fn from_str(string: &'a str) -> Result<UniAddr<'a>, ParseError>

Creates a new UniAddr from the given string representation.

use uaddr::UniAddr;

// An IPv4 address with a port
let _ = UniAddr::from_str("127.0.0.1:13168").unwrap();
// An IPv6 address with a port
let _ = UniAddr::from_str("[::1]:13168").unwrap();
// A host with a port
let _ = UniAddr::from_str("example.com:8080").unwrap();
// A UDS address (UNIX domain socket)
let _ = UniAddr::from_str("unix:/path/to/your/file.socket").unwrap();
// A URI-style UDS address (not recommended)
let _ = UniAddr::from_str("unix:///path/to/your/file.socket").unwrap();
// An abstract namespace UDS address.
let _ = UniAddr::from_str("unix:@abstract-socket").unwrap();
// A URI-style abstract namespace UDS address (not recommended).
let _ = UniAddr::from_str("unix://@abstract-socket").unwrap();

Source

pub const fn resolved(&self) -> Result<SocketAddr, InvalidUniAddr>

Returns the resolved socket address if this is an SocketAddr or a resolved HostAddr.

use uaddr::UniAddr;

// An already resolved IP address with a port can be resolved to a socket address.
let mut addr = UniAddr::from_str("1.1.1.1:443").unwrap();
assert!(addr
    .resolved()
    .is_ok_and(|addr| addr == "1.1.1.1:443".parse().unwrap()));
// An unresolved host address cannot be resolved to a socket address.
let mut addr = UniAddr::from_str("example.com:8080").unwrap();
assert!(addr.resolved().is_err());
// One UNIX domain socket address cannot be resolved to a socket address.
let mut addr = UniAddr::from_str("unix:/path/to/your/file.socket").unwrap();
assert!(addr.resolved().is_err());

Source

pub fn blocking_resolve_host_name(&mut self) -> Result<(), Error>

See HostAddr::blocking_resolve.

Source

pub fn blocking_resolve_host_name_with<F, E>(&mut self, f: F) -> Result<(), E>
where F: FnOnce(&str) -> Result<SocketAddr, E>,

See HostAddr::blocking_resolve_with.

Source

pub async fn resolve_host_name_with<'fut, F, Fut, E>( &'fut mut self, f: F, ) -> Result<(), E>
where F: FnOnce(&'fut str) -> Fut + Send, Fut: Future<Output = Result<SocketAddr, E>> + Send + 'fut,

See HostAddr::resolve_with.

Source

pub fn to_owned(self) -> UniAddr<'static>

Converts this UniAddr into an owned version.

This is a no-op for now since the inner bytes type is already owned, but it will be useful in the future when we change the inner bytes type to a more flexible one and accept borrowed bytes.