Struct CacheControl 

#[non_exhaustive]
pub struct CacheControl {

    pub public: bool,
    pub private: bool,
    pub no_cache: bool,
    pub no_store: bool,
    pub no_transform: bool,
    pub must_revalidate: bool,
    pub proxy_revalidate: bool,
    pub immutable: bool,
    pub max_age: Option<u64>,
    pub s_maxage: Option<u64>,
    pub stale_while_revalidate: Option<u64>,
    pub stale_if_error: Option<u64>,
    pub only_if_cached: bool,
    pub max_stale: Option<u64>,
    pub min_fresh: Option<u64>,
}

Structured Cache-Control header (RFC 7234 §5.2).

All boolean directives default to false; numeric directives default to None (absent). Use the builder methods to set them.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

public: bool

public — response may be stored by any cache.

private: bool

private — response is intended for a single user; must not be stored by a shared cache.

no_cache: bool

no-cache — cache must revalidate with the origin before serving.

no_store: bool

no-store — must not store any part of the request or response.

no_transform: bool

no-transform — no transformations or conversions should be made.

must_revalidate: bool

must-revalidate — stale responses must not be used without revalidation.

proxy_revalidate: bool

proxy-revalidate — like must-revalidate but only for shared caches.

immutable: bool

immutable — response body will not change over its lifetime.

max_age: Option<u64>

max-age=<seconds> — maximum time the response is considered fresh.

s_maxage: Option<u64>

s-maxage=<seconds> — overrides max-age for shared caches.

stale_while_revalidate: Option<u64>

stale-while-revalidate=<seconds> — serve stale while revalidating.

stale_if_error: Option<u64>

stale-if-error=<seconds> — use stale response on error.

only_if_cached: bool

only-if-cached — do not use the network; only return a cached response.

max_stale: Option<u64>

max-stale[=<seconds>] — accept a response up to this many seconds stale. Some(0) means any staleness is acceptable; None means the directive is absent.

min_fresh: Option<u64>

min-fresh=<seconds> — require at least this much remaining freshness.

Implementations

impl CacheControl

pub fn new() -> Self

Create an empty CacheControl with all directives absent.

pub fn public(self) -> Self

Set the public directive.

pub fn private(self) -> Self

Set the private directive.

pub fn no_cache(self) -> Self

Set the no-cache directive.

pub fn no_store(self) -> Self

Set the no-store directive.

pub fn no_transform(self) -> Self

Set the no-transform directive.

pub fn must_revalidate(self) -> Self

Set the must-revalidate directive.

pub fn proxy_revalidate(self) -> Self

Set the proxy-revalidate directive.

pub fn immutable(self) -> Self

Set the immutable directive.

pub fn max_age(self, seconds: u64) -> Self

Set max-age=<seconds>.

pub fn s_maxage(self, seconds: u64) -> Self

Set s-maxage=<seconds>.

pub fn stale_while_revalidate(self, seconds: u64) -> Self

Set stale-while-revalidate=<seconds>.

pub fn stale_if_error(self, seconds: u64) -> Self

Set stale-if-error=<seconds>.

pub fn only_if_cached(self) -> Self

Set the only-if-cached directive.

pub fn max_stale(self, seconds: u64) -> Self

Set max-stale[=<seconds>]. Pass 0 to accept any staleness.

pub fn min_fresh(self, seconds: u64) -> Self

Set min-fresh=<seconds>.

pub fn no_caching() -> Self

Convenience: no-store (disable all caching).

use api_bones::cache::CacheControl;

let cc = CacheControl::no_caching();
assert!(cc.no_store);
assert_eq!(cc.to_string(), "no-store");

pub fn private_no_cache() -> Self

Convenience: private, no-cache, no-store.

use api_bones::cache::CacheControl;

let cc = CacheControl::private_no_cache();
assert!(cc.private && cc.no_cache && cc.no_store);

Trait Implementations

impl Clone for CacheControl

fn clone(&self) -> CacheControl

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheControl

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

Formats the value using the given formatter.

impl Default for CacheControl

fn default() -> CacheControl

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CacheControl

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for CacheControl

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

Formats the value using the given formatter.

impl FromStr for CacheControl

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

Parse a Cache-Control header value.

Unknown directives are silently ignored, matching real-world HTTP caching behaviour.

use api_bones::cache::CacheControl;

let cc: CacheControl = "public, max-age=3600, must-revalidate".parse().unwrap();
assert!(cc.public);
assert_eq!(cc.max_age, Some(3600));
assert!(cc.must_revalidate);

type Err = ParseCacheControlError

The associated error which can be returned from parsing.

impl PartialEq for CacheControl

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CacheControl

impl StructuralPartialEq for CacheControl