Struct SocketAddr

Source

pub struct SocketAddr { /* private fields */ }

Available on crate feature net only.

Expand description

A socket address combining a host and a port.

This type provides a type-safe socket address that can represent:

IP addresses with ports (e.g., “192.168.1.1:8080”)
Domain names with ports (e.g., “example.com:443”)
Hostnames with ports (e.g., “localhost:3000”)

§Invariants

The host is always valid (IP address, domain name, or hostname)
The port is always in the valid range (1-65535)

§Examples

use bare_types::net::{SocketAddr, Host, Port};

// Create from components
let host = Host::parse_str("192.168.1.1")?;
let port = Port::new(8080)?;
let addr = SocketAddr::new(host, port);

// Parse from string
let addr: SocketAddr = "example.com:443".parse()?;

// Access components
assert_eq!(addr.as_port().as_u16(), 443);

Implementations§

Source §

impl SocketAddr

Source

pub const fn new(host: Host, port: Port) -> Self

Creates a new socket address from a host and port.

§Examples

use bare_types::net::{SocketAddr, Host, Port};

let host = Host::parse_str("192.168.1.1")?;
let port = Port::new(8080)?;
let addr = SocketAddr::new(host, port);

Source

pub const fn as_host(&self) -> &Host

Returns a reference to the host part of this socket address.

§Examples

use bare_types::net::{SocketAddr, Host};

let addr: SocketAddr = "192.168.1.1:8080".parse()?;
assert!(addr.as_host().is_ipaddr());

Source

pub const fn as_port(&self) -> &Port

Returns a reference to the port part of this socket address.

§Examples

use bare_types::net::SocketAddr;

let addr: SocketAddr = "192.168.1.1:8080".parse()?;
assert_eq!(addr.as_port().as_u16(), 8080);

Source

pub fn set_host(&mut self, host: Host)

Sets the host part of this socket address.

§Examples

use bare_types::net::{SocketAddr, Host};

let mut addr: SocketAddr = "192.168.1.1:8080".parse()?;
let new_host = Host::parse_str("10.0.0.1")?;
addr.set_host(new_host);

Source

pub const fn set_port(&mut self, port: Port)

Sets the port part of this socket address.

§Examples

use bare_types::net::{SocketAddr, Port};

let mut addr: SocketAddr = "192.168.1.1:8080".parse()?;
let new_port = Port::new(9090)?;
addr.set_port(new_port);

Source

pub fn into_parts(self) -> (Host, Port)

Consumes this socket address and returns the host and port components as a tuple.

§Examples

use bare_types::net::{SocketAddr, Host, Port};

let host = Host::parse_str("192.168.1.1")?;
let port = Port::new(8080)?;
let addr = SocketAddr::new(host, port);

let (host, port) = addr.into_parts();
assert!(host.is_ipaddr());
assert_eq!(port.as_u16(), 8080);

Source

pub fn parse_str(s: &str) -> Result<Self, SocketAddrError>

Parses a string into a socket address.

The string must be in the format <host>:<port>, where:

<host> is a valid IP address, domain name, or hostname
<port> is a valid port number (1-65535)

§Errors

Returns SocketAddrError if:

The input is empty
The port separator ‘:’ is missing
The host part is invalid
The port part is invalid

§Examples

   use bare_types::net::SocketAddr;

// Parse IP address with port
let addr = SocketAddr::parse_str("192.168.1.1:8080")?;
assert!(addr.as_host().is_ipaddr());

// Parse domain name with port
let addr = SocketAddr::parse_str("example.com:443")?;
assert!(addr.as_host().is_domainname());

Source

pub const fn is_ip(&self) -> bool

Returns true if the host is an IP address.

§Examples

use bare_types::net::SocketAddr;

let addr: SocketAddr = "192.168.1.1:8080".parse()?;
assert!(addr.is_ip());

Source

pub const fn is_domain_name(&self) -> bool

Returns true if the host is a domain name.

§Examples

use bare_types::net::SocketAddr;

let addr: SocketAddr = "example.com:443".parse()?;
assert!(addr.is_domain_name());

Source

pub const fn is_hostname(&self) -> bool

Returns true if the host is a hostname.

§Examples

use bare_types::net::{SocketAddr, Host, Hostname, Port};

let hostname = Hostname::new("localhost")?;
let host = Host::from_hostname(hostname);
let port = Port::new(3000)?;
let addr = SocketAddr::new(host, port);
assert!(addr.is_hostname());