Enum DirectiveKey 

pub enum DirectiveKey {
    MaxAge,
    SMaxAge,
    NoCache,
    NoStore,
    Private,
    Public,
    MustRevalidate,
    ProxyRevalidate,
    MustUnderstand,
    NoTransform,
    Immutable,
    StaleWhileRevalidate,
    StaleIfError,
    OnlyIfCached,
    Unknown(String),
}

Cache-Control directive key.

Known RFC 9111 (and common extension) directives are represented as enum variants, avoiding a heap allocation for every parsed directive. Unknown or extension directives are preserved via the Unknown variant.

Directive keys are always stored in lowercase, matching the case-insensitive comparison required by the HTTP specification.

Variants

MaxAge

max-age

SMaxAge

s-maxage

NoCache

no-cache

NoStore

no-store

Private

private

Public

public

MustRevalidate

must-revalidate

ProxyRevalidate

proxy-revalidate

MustUnderstand

must-understand

NoTransform

no-transform

Immutable

immutable

StaleWhileRevalidate

stale-while-revalidate

StaleIfError

stale-if-error

OnlyIfCached

only-if-cached

Unknown(String)

An unknown or extension directive, stored as the original (lowercased) name.

Implementations

impl DirectiveKey

pub fn as_str(&self) -> &str

Return the wire-format name of this directive as a &str.

Known variants return a &'static str; Unknown returns a borrow of the inner String.

pub fn from_lowercase(s: &str) -> Self

Construct a DirectiveKey from a lowercase &str.

Known directive names are mapped to their enum variant (zero allocation). Anything else produces Unknown with an owned copy of the string.

The caller is responsible for lowercasing the input first; this function does not perform case folding.

See also from_lowercase_owned to avoid a re-allocation when the caller already has an owned String.

pub fn from_lowercase_owned(s: String) -> Self

Construct a DirectiveKey from a lowercase owned String.

Behaves identically to from_lowercase but takes ownership of the String, avoiding a re-allocation when the input maps to Unknown.

Trait Implementations

impl Clone for DirectiveKey

fn clone(&self) -> DirectiveKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DirectiveKey

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

Formats the value using the given formatter.

impl Display for DirectiveKey

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

Formats the value using the given formatter.

impl Eq for DirectiveKey

impl Hash for DirectiveKey

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 DirectiveKey

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

Equality operator ==.

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

Inequality operator !=.

impl PartialEq<&str> for DirectiveKey

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

Equality operator ==.

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

Inequality operator !=.

impl PartialEq<str> for DirectiveKey

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for DirectiveKey