Struct Origin 

#[non_exhaustive]
pub struct Origin { /* private fields */ }

Represents the origin of a URI, consisting of the scheme and authority components.

This struct is useful for scenarios where you need to work with the base parts of a URI without the path, query, or fragment components.

Implementations

impl Origin

pub fn new( scheme: impl TryInto<Scheme, Error: Into<Error>>, authority: impl TryInto<Authority, Error: Into<Error>>, ) -> Result<Self, ValidationError>

Creates a new Origin from the given scheme and authority.

Arguments

• scheme: The URI scheme (must be either HTTP or HTTPS).
• authority: The authority component (hostname and optional port).

Errors

Returns a validation error if:

• The scheme is not HTTP or HTTPS.
• The scheme or authority conversion fails.

pub const fn scheme(&self) -> &Scheme

Returns a reference to the scheme.

pub const fn authority(&self) -> &Authority

Returns a reference to the authority.

pub fn into_parts(self) -> (Scheme, Authority)

Consumes the origin and returns the scheme and authority.

pub fn port(&self) -> u16

Returns the port of this origin.

This method determines the port based on the same rules as BaseUri::port.

pub fn with_port(self, port: u16) -> Self

Set port for this Origin instance.

Examples

let origin = Origin::new("https", "example.com").unwrap();
let origin_with_port = origin.with_port(8443);
assert_eq!(origin_with_port.port(), 8443);
assert_eq!(format!("{}", origin_with_port), "https://example.com:8443");

pub fn is_https(&self) -> bool

Checks if this origin uses the HTTPS scheme.

This method returns true if the scheme is HTTPS, false otherwise. For more details, see BaseUri::is_https.

Trait Implementations

impl Clone for Origin

fn clone(&self) -> Origin

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Origin

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Origin

Available on crate feature serde only.

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for Origin

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

Formats the Origin as a string in the form scheme://authority.

Default ports (80 for HTTP, 443 for HTTPS) are omitted from the display string. Custom ports are included when present.

Examples

let origin = Origin::new(Scheme::HTTPS, "example.com:443").unwrap();
assert_eq!(format!("{}", origin), "https://example.com");

let custom_port = Origin::new(Scheme::HTTPS, "example.com:8443").unwrap();
assert_eq!(format!("{}", custom_port), "https://example.com:8443");

impl From<Origin> for BaseUri

fn from(origin: Origin) -> Self

Converts an Origin into a BaseUri with a root path (“/”).

This conversion adds a minimal path component to ensure the resulting URI is valid.

impl FromStr for Origin

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

Parses an Origin from a string in the form scheme://authority.

Errors

Returns a ValidationError if the string is not a valid origin (missing scheme, unsupported scheme, or invalid authority).

type Err = ValidationError

The associated error which can be returned from parsing.

impl Hash for Origin

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 PartialEq for Origin

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

Available on crate feature serde only.

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for Origin

impl StructuralPartialEq for Origin