Struct Address 

#[non_exhaustive]
pub struct Address {
    pub host: Host,
    pub scheme: Scheme,
    pub port: Option<u16>,
}

HTTP Address

Describes the access address of an HTTP server, including host, scheme, and port.

let host = Host::parse("example.com").expect("valid host");
let address = Address::builder(|addr|{
    addr.scheme(Scheme::Https)
        .host(host)
        .port(8080);
});

assert_eq!(address.host.to_string(), "example.com");
assert_eq!(address.scheme, Scheme::Https);
assert_eq!(address.port, Some(8080));
assert_eq!(address.build_url().as_str(), "https://example.com:8080/");

---

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

host: Host

scheme: Scheme

port: Option<u16>

Implementations

impl Address

pub fn parse(url: &str) -> Result<Self, Error>

Parse from URL

let address = Address::parse("https://example.com:8080")?;
assert_eq!(address.host.to_string(), "example.com");
assert_eq!(address.scheme, Scheme::Https);
assert_eq!(address.port, Some(8080));

---

pub fn build_url(&self) -> Url

Build URL

let host = Host::parse("example.com").expect("valid host");
let address = Address::builder(|addr|{
    addr.scheme(Scheme::Https)
        .host(host)
        .port(8080);
});

assert_eq!(address.build_url().as_str(), "https://example.com:8080/");

---

pub fn from_url(url: &Url) -> Self

From URL

let url = "https://example.com:8080".parse::<url::Url>().expect("valid URL");
let address = Address::from_url(&url);

assert_eq!(address.host.to_string(), "example.com");
assert_eq!(address.scheme, Scheme::Https);
assert_eq!(address.port, Some(8080));

---

pub fn builder<F>(builder_fn: F) -> Self

where F: FnOnce(&mut AddressBuilder<'_>),

Build Address

let host = Host::parse("127.0.0.1").expect("valid host");
let address = Address::builder(|addr|{
    addr.scheme(Scheme::Https)
        .host(host)
        .port(8080);
});

assert_eq!(address.host.to_string(), "127.0.0.1");
assert_eq!(address.scheme, Scheme::Https);
assert_eq!(address.port, Some(8080));

---

Trait Implementations

impl Clone for Address

fn clone(&self) -> Address

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Address

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

Formats the value using the given formatter.

impl Default for Address

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Address

fn eq(&self, other: &Address) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Address

impl StructuralPartialEq for Address