Struct Url

pub struct Url {
    pub scheme: Option<String>,
    pub user_pass: (Option<String>, Option<String>),
    pub subdomain: Option<String>,
    pub domain: Option<String>,
    pub top_level_domain: Option<String>,
    pub port: Option<u32>,
    pub path: Option<Vec<String>>,
    pub query: Option<String>,
    pub anchor: Option<String>,
}

Fields

scheme: Option<String>

user_pass: (Option<String>, Option<String>)

subdomain: Option<String>

domain: Option<String>

top_level_domain: Option<String>

port: Option<u32>

path: Option<Vec<String>>

query: Option<String>

anchor: Option<String>

Implementations

impl Url

pub fn host_str(&self) -> Option<String>

Extract the representation of the host for this URL.

Example

use url_parse::core::Parser;
use url_parse::core::global::Domain;
let input = "https://user:pass@www.example.com:443/blog/article/search?docid=720&hl=en#dayone";
let expected = "example.com";
let parsed = Parser::new(None).parse(input).unwrap();
let result = parsed.host_str().unwrap();
assert_eq!(result, expected);

pub fn port_or_known_default(&self) -> Option<u32>

Extract the username from the url.

Example

use url_parse::core::Parser;
use url_parse::core::global::Domain;
let input = "https://user:pass@www.example.com:443/blog/article/search?docid=720&hl=en#dayone";
let expected = 443;
let parsed = Parser::new(None).parse(input).unwrap();
let result = parsed.port_or_known_default().unwrap();
assert_eq!(result, expected);

pub fn username(&self) -> Option<String>

Extract the username from the url.

Example

use url_parse::core::Parser;
use url_parse::core::global::Domain;
let input = "https://user:pass@www.example.com:443/blog/article/search?docid=720&hl=en#dayone";
let expected = "user";
let parsed = Parser::new(None).parse(input).unwrap();
let result = parsed.username().unwrap();
assert_eq!(result, expected);

pub fn password(&self) -> Option<String>

Extract the password from the url.

Example

use url_parse::core::Parser;
use url_parse::core::global::Domain;
let input = "https://user:pass@www.example.com:443/blog/article/search?docid=720&hl=en#dayone";
let expected = "pass";
let parsed = Parser::new(None).parse(input).unwrap();
let result = parsed.password().unwrap();
assert_eq!(result, expected);

pub fn path_segments(&self) -> Option<Vec<String>>

Extract the path segments from the path.

Example

use url_parse::core::Parser;
use url_parse::core::global::Domain;
let input = "https://www.example.co.uk:443/blog/article/search?docid=720&hl=en#dayone";
let result = Parser::new(None).path(input).unwrap();
let expected = vec!["blog", "article", "search"];
assert_eq!(result, expected);

pub fn serialize(&self) -> String

Serialize an URL struct to a String.

Example

use url_parse::core::Parser;
use url_parse::core::global::Domain;
use url_parse::url::Url;

let input = Url {
   scheme: Some("https".to_string()),
   user_pass: (Some("user".to_string()), Some("pass".to_string())),
   subdomain: Some("www".to_string()),
   domain: Some("example.co".to_string()),
   top_level_domain: Some("uk".to_string()),
   port: Some(443),
   path: Some(vec![
       "blog".to_string(),
       "article".to_string(),
       "search".to_string(),
   ]),
   query: Some("docid=720&hl=en".to_string()),
   anchor: Some("dayone".to_string()),
};
let expected =
   "https://user:pass@www.example.co.uk:443/blog/article/search?docid=720&hl=en#dayone";

let result = input.serialize();
assert_eq!(result, expected);

pub fn empty() -> Self

Create a new empty instance with all fields set to none.

Trait Implementations

impl Debug for Url

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

Formats the value using the given formatter.

impl Display for Url

Display the serialization of this URL.

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

Formats the value using the given formatter.

impl PartialEq for Url

Compare two objects of this type.

fn eq(&self, other: &Self) -> 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.