Enum Component 

#[non_exhaustive]
pub enum Component {
    Method,
    TargetUri,
    Authority,
    Scheme,
    Path,
    Query,
    RequestTarget,
    Header(String),
}

A single component in an RFC 9421 signature base.

The Component::lexical representation is the quoted string that appears in the signature base and in the Signature-Input: header inner list.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Method

HTTP method (upper-case).

TargetUri

Full request target URI.

Authority

Authority (host equivalent).

Scheme

Request scheme (http / https).

Path

URI path component.

Query

URI query component including the leading ?. When the request URI has no query, the canonical value is the single character ? per RFC 9421 §2.2.7.

RequestTarget

@request-target derived component: path and query of the request target, without the method, per RFC 9421 §2.2.5. This is semantically distinct from Cavage’s (request-target) pseudo-header which does include the method; the Cavage signer / verifier handles that shape in [crate::cavage] independently.

Header(String)

An ordinary lower-cased HTTP header name.

Implementations

impl Component

pub fn lexical(&self) -> String

Returns the quoted lexical form that appears in a Signature-Input: inner list and in the signature base.

pub fn identifier(&self) -> &str

Returns the raw identifier without quotes.

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

Parses an identifier back into a Component.

Errors

Returns Error::UnsupportedAlgorithm for any @-prefixed identifier that is not one of the seven supported derived components (@method, @target-uri, @authority, @scheme, @path, @query, @request-target). Header names are accepted verbatim and lower-cased.

Trait Implementations

impl Clone for Component

fn clone(&self) -> Component

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Component

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

Formats the value using the given formatter.

impl Eq for Component

impl Hash for Component

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 Component

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