Trait CacheKey 

pub trait CacheKey
where
    Self: Sized + Debug,
{
    type Hasher: Hasher;

    // Required methods
    fn hasher(&mut self) -> &mut Self::Hasher;
    fn add_cache_key<P, O>(&mut self, msg: &Message<P, O>)
       where P: Array<Item = u8> + AppendCopy<u8>,
             O: OptionMap;

    // Provided method
    fn cache_key<P, O>(&mut self, msg: &Message<P, O>) -> u64
       where P: Array<Item = u8> + AppendCopy<u8>,
             O: OptionMap { ... }
}

The cache key can be used to compare messages for representing the same action against the same resource; for example requests with different IDs but the same method and cache-key affecting options (ex. path, query parameters) will yield the same cache-key.

Extends core::hash::Hash with the ability to build a cache-key of a message in the hasher’s state.

DefaultCacheKey Provides a default implementation.

Required Associated Types

type Hasher: Hasher

Type used to generate hashes

Required Methods

fn hasher(&mut self) -> &mut Self::Hasher

fn add_cache_key<P, O>(&mut self, msg: &Message<P, O>)

where P: Array<Item = u8> + AppendCopy<u8>, O: OptionMap,

Add this message’s cache key to the hasher’s internal state.

After invoking this, to get the u64 hash use Hasher::finish.

Alternately, use CacheKey::cache_key to go directly to the u64 hash.

Provided Methods

fn cache_key<P, O>(&mut self, msg: &Message<P, O>) -> u64

where P: Array<Item = u8> + AppendCopy<u8>, O: OptionMap,

Add this message’s cache key to the hasher’s internal state and yield the u64 hash.

use core::hash::Hasher;

use toad_msg::alloc::Message;
use toad_msg::Type::Con;
use toad_msg::{CacheKey, Code, ContentFormat, DefaultCacheKey, Id, MessageOptions, Token};

let mut msg_a = Message::new(Con, Code::GET, Id(1), Token(Default::default()));
msg_a.set_path("foo/bar");
msg_a.set_accept(ContentFormat::Text);
let mut ha = DefaultCacheKey::new();
ha.cache_key(&msg_a);

let mut msg_b = Message::new(Con, Code::GET, Id(2), Token(Default::default()));
msg_b.set_accept(ContentFormat::Text);
msg_b.set_path("foo/bar");
let mut hb = DefaultCacheKey::new();
hb.cache_key(&msg_b);

assert_eq!(ha.hasher().finish(), hb.hasher().finish());

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T> CacheKey for &mut T

where T: CacheKey,

type Hasher = <T as CacheKey>::Hasher

fn hasher(&mut self) -> &mut Self::Hasher

fn add_cache_key<P, O>(&mut self, msg: &Message<P, O>)

where P: Array<Item = u8> + AppendCopy<u8>, O: OptionMap,

Implementors

impl CacheKey for DefaultCacheKey

type Hasher = Blake2Hasher