Struct Url 

pub struct Url(/* private fields */);

Available on crate feature net only.

A URL.

This type provides type-safe URLs with RFC 3986 validation. It uses the newtype pattern with #[repr(transparent)] for zero-cost abstraction.

Invariants

• Total length is 1-2048 characters
• Scheme is required and case-insensitive (stored in lowercase)
• Authority (host:port) is optional
• Path, query, and fragment are optional
• Scheme must be followed by :
• Authority must be preceded by //

Examples

use bare_types::net::Url;

// Create a URL
let url = Url::new("https://example.com")?;

// Access the string representation
assert_eq!(url.as_str(), "https://example.com");

// Get the scheme
assert_eq!(url.scheme(), "https");

// Get the host
assert_eq!(url.host(), Some("example.com"));

// Parse from string
let url: Url = "https://example.com/path".parse()?;

Implementations

impl Url

pub fn new(s: &str) -> Result<Self, UrlError>

Creates a new URL from a string.

Errors

Returns UrlError if the string does not comply with RFC 3986.

Examples

use bare_types::net::Url;

let url = Url::new("https://example.com")?;
assert_eq!(url.as_str(), "https://example.com");

pub fn as_str(&self) -> &str

Returns the URL as a string slice.

Examples

use bare_types::net::Url;

let url = Url::new("https://example.com").unwrap();
assert_eq!(url.as_str(), "https://example.com");

pub const fn as_inner(&self) -> &String<2048>

Returns a reference to the underlying heapless::String.

Examples

use bare_types::net::Url;

let url = Url::new("https://example.com").unwrap();
let inner: &heapless::String<2048> = url.as_inner();
assert_eq!(inner.as_str(), "https://example.com");

pub fn into_inner(self) -> String<2048>

Consumes this URL and returns the underlying string.

Examples

use bare_types::net::Url;

let url = Url::new("https://example.com").unwrap();
let inner = url.into_inner();
assert_eq!(inner.as_str(), "https://example.com");

pub fn scheme(&self) -> &str

Returns the scheme of the URL.

Examples

use bare_types::net::Url;

let url = Url::new("https://example.com").unwrap();
assert_eq!(url.scheme(), "https");

pub fn host(&self) -> Option<&str>

Returns the host of the URL, if present.

Examples

use bare_types::net::Url;

let url = Url::new("https://example.com").unwrap();
assert_eq!(url.host(), Some("example.com"));

pub fn port(&self) -> Option<&str>

Returns the port of the URL, if present.

Examples

use bare_types::net::Url;

let url = Url::new("https://example.com:8080").unwrap();
assert_eq!(url.port(), Some("8080"));

pub fn path(&self) -> Option<&str>

Returns the path of the URL, if present.

Examples

use bare_types::net::Url;

let url = Url::new("https://example.com/path").unwrap();
assert_eq!(url.path(), Some("/path"));

pub fn query(&self) -> Option<&str>

Returns the query string of the URL, if present.

Examples

use bare_types::net::Url;

let url = Url::new("https://example.com?query=value").unwrap();
assert_eq!(url.query(), Some("query=value"));

pub fn fragment(&self) -> Option<&str>

Returns the fragment of the URL, if present.

Examples

use bare_types::net::Url;

let url = Url::new("https://example.com#fragment").unwrap();
assert_eq!(url.fragment(), Some("fragment"));

Trait Implementations

impl<'a> Arbitrary<'a> for Url

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for Url

fn clone(&self) -> Url

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Url

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Url

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Url

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

Formats the value using the given formatter.

impl From<Url> for String<2048>

fn from(url: Url) -> Self

Converts to this type from the input type.

impl FromStr for Url

type Err = UrlError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Url

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Url

fn cmp(&self, other: &Url) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Url

fn eq(&self, other: &Url) -> 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 PartialOrd for Url

fn partial_cmp(&self, other: &Url) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Url

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for Url

type Error = UrlError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl Zeroize for Url

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Eq for Url

impl StructuralPartialEq for Url