Enum url::Origin

pub enum Origin {
    Opaque(OpaqueOrigin),
    Tuple(String, Host<String>, u16),
}

The origin of an URL

Two URLs with the same origin are considered to originate from the same entity and can therefore trust each other.

The origin is determined based on the scheme as follows:

• If the scheme is "blob" the origin is the origin of the URL contained in the path component. If parsing fails, it is an opaque origin.
• If the scheme is "ftp", "gopher", "http", "https", "ws", or "wss", then the origin is a tuple of the scheme, host, and port.
• If the scheme is anything else, the origin is opaque, meaning the URL does not have the same origin as any other URL.

For more information see https://url.spec.whatwg.org/#origin

Variants

Opaque(OpaqueOrigin)

A globally unique identifier

Tuple(String, Host<String>, u16)

Consists of the URL's scheme, host and port

Implementations

impl Origin

pub fn new_opaque() -> Origin

Creates a new opaque origin that is only equal to itself.

pub fn is_tuple(&self) -> bool

Return whether this origin is a (scheme, host, port) tuple (as opposed to an opaque origin).

pub fn ascii_serialization(&self) -> String

https://html.spec.whatwg.org/multipage/#ascii-serialisation-of-an-origin

pub fn unicode_serialization(&self) -> String

https://html.spec.whatwg.org/multipage/#unicode-serialisation-of-an-origin

Trait Implementations

impl Clone for Origin

fn clone(&self) -> Origin

Returns a copy 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 Eq for Origin

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, 

Feeds a slice of this type into the given [Hasher].

impl PartialEq<Origin> for Origin

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralEq for Origin

impl StructuralPartialEq for Origin