Enum kvarn::comprash::UriKey

pub enum UriKey {
    Path(CompactString),
    PathQuery(PathQuery),
}

A key for an Uri used in ResponseCache.

This is, for now, an opaque type in it’s API. Though, you can extract the path and query through matching.

Variants

Path(CompactString)

Uri with only a path component.

Searching the cache with this should be avoided. See Self::call_all.

PathQuery(PathQuery)

Uri with a path and optional query.

See PathQuery.

Implementations

impl UriKey

pub fn path_and_query(uri: &Uri) -> Self

Constructs a new UriKey from uri.

This variant will math both Self::PathQuery and Self::Path if Self::call_all is called on it.

pub fn call_all<T>( self, callback: impl FnMut(&Self) -> Option<T> ) -> (Self, Option<T>)

Tries to get type T from callback using current variant and other variants with fewer data. Returns Self which got a result from callback or, if none, truncated to Self::Path.

Examples

use kvarn::prelude::*;
let key = UriKey::path_and_query(&Uri::from_static("https://icelk.dev/status?format=json"));

// First gets called once with key as UriKey::PathQuery("/status?format=json")
// then, the query gets truncated and we get a key as UriKey::Path("/status").
let (_key, found) = key.call_all(|key| {
    match key {
        UriKey::Path(path) if *path == "/status" => Some(true),
        _ => None
    }
});

assert_eq!(found, Some(true));

Trait Implementations

impl Clone for UriKey

fn clone(&self) -> UriKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UriKey

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

Formats the value using the given formatter.

impl Hash for UriKey

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 UriKey

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for UriKey

impl StructuralPartialEq for UriKey