mod address
srcIP address and socket address types.
Both IpAddr and SocketAddr are copyable value types — they hold
no OS resources, so copying is safe and cheap.
IP address parsing uses the OS inet_pton(3) function for correctness
on both IPv4 and IPv6; formatting uses inet_ntop(3).
Structs
| struct IpAddr | An IP address: either IPv4 or IPv6. |
| struct SocketAddr | A socket address: an IP address combined with a port number. |
Structs
struct IpAddr §
struct IpAddr
An IP address: either IPv4 or IPv6.
The address is stored as a validated string produced by inet_ntop
after successful inet_pton parsing. This guarantees all instances
hold a canonical, valid representation.
Fields:
_addr: Canonical string form (e.g. "127.0.0.1" or "::1").
_is_v6: True for IPv6, False for IPv4.
Example:
var lo = IpAddr.parse("127.0.0.1")
print(lo) # 127.0.0.1
print(lo.is_loopback()) # True
Methods
| fn __init__ | Construct an ``IpAddr`` directly from a pre-validated string. |
| fn __eq__ | Return ``True`` if both addresses have the same family and string. |
| fn __ne__ | Return ``True`` if the addresses differ. |
| fn parse | Parse and validate an IP address string. |
| fn localhost | Return the IPv4 loopback address ``127.0.0.1``. |
| fn localhost_v6 | Return the IPv6 loopback address ``::1``. |
| fn unspecified | Return the IPv4 wildcard address ``0.0.0.0`` (all interfaces). |
| fn unspecified_v6 | Return the IPv6 wildcard address ``::`` (all interfaces). |
| fn is_v4 | Return ``True`` if this is an IPv4 address. |
| fn is_v6 | Return ``True`` if this is an IPv6 address. |
| fn is_loopback | Return ``True`` if this is a loopback address. |
| fn is_unspecified | Return ``True`` if this is the wildcard/unspecified address. |
| fn is_private | Return ``True`` if this is an RFC 1918 private address. |
| fn is_multicast | Return ``True`` if this is a multicast address. |
| fn write_to | Write the canonical address string to ``writer``. |
fn parse static §
parse(s: String) -> Self
Parse and validate an IP address string.
Accepts dotted-decimal IPv4 ("192.168.1.1") and colon-separated
IPv6 ("::1", "2001:db8::1"). Uses inet_pton for
correctness, then inet_ntop to obtain the canonical form.
Example:
var v4 = IpAddr.parse("192.168.0.1")
var v6 = IpAddr.parse("::1")
Args
| s | String |
The address string to parse. |
Returns
| Self | A validated |
Raises
AddressParseError: If s is not a valid IPv4 or IPv6 address.
fn localhost static §
localhost() -> Self
Return the IPv4 loopback address ``127.0.0.1``.
Returns
| Self |
|
fn localhost_v6 static §
localhost_v6() -> Self
Return the IPv6 loopback address ``::1``.
Returns
| Self |
|
fn unspecified static §
unspecified() -> Self
Return the IPv4 wildcard address ``0.0.0.0`` (all interfaces).
Returns
| Self |
|
fn unspecified_v6 static §
unspecified_v6() -> Self
Return the IPv6 wildcard address ``::`` (all interfaces).
Returns
| Self |
|
struct SocketAddr §
struct SocketAddr
A socket address: an IP address combined with a port number.
Fields: ip: The IP address component. port: The port number (0–65535).
Example:
var addr = SocketAddr(IpAddr.localhost(), 8080)
print(addr) # 127.0.0.1:8080
var v6 = SocketAddr(IpAddr.localhost_v6(), 443)
print(v6) # [::1]:443
Methods
| fn __init__ | Initialise a ``SocketAddr``. |
| fn __eq__ | Return ``True`` if IP and port both match. |
| fn __ne__ | Return ``True`` if IP or port differ. |
| fn localhost | Return ``SocketAddr("127.0.0.1", port)``. |
| fn unspecified | Return ``SocketAddr("0.0.0.0", port)`` — bind on all interfaces. |
| fn parse | Parse a ``"host:port"`` or ``"[ipv6]:port"`` string. |
| fn write_to | Write ``"ip:port"`` or ``"[ip]:port"`` to ``writer``. |
fn parse static §
parse(s: String) -> Self
Parse a ``"host:port"`` or ``"[ipv6]:port"`` string.
Example:
var a = SocketAddr.parse("127.0.0.1:9000")
var b = SocketAddr.parse("[::1]:9000")
Args
| s | String |
Address string in one of these forms:
|
Returns
| Self | A |
Raises
AddressParseError: If the string cannot be parsed.