cuckoo-cache 0.2.0

Cuckoo hash based cache storage engine with fixed-size item slots
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

//! Read-only view of a stored cache item.

use crate::CuckooCacheError;
use keyvalue::{TinyItem, Value};

/// A read-only view of an item stored in the cuckoo cache.
pub struct Item {
    raw: TinyItem,
}

impl Item {
    pub(crate) fn new(raw: TinyItem) -> Self {
        Self { raw }
    }

    /// Borrow the item's key.
    pub fn key(&self) -> &[u8] {
        self.raw.key()
    }

    /// Borrow the item's value.
    pub fn value(&self) -> Value<'_> {
        self.raw.value()
    }

    /// The item's expiration timestamp as seconds since cache creation.
    /// Returns `u32::MAX` for items with no expiry.
    pub fn expire(&self) -> u32 {
        self.raw.expire()
    }

    /// Perform a wrapping addition on the value.
    pub fn wrapping_add(&mut self, rhs: u64) -> Result<(), CuckooCacheError> {
        self.raw
            .wrapping_add(rhs)
            .map_err(|_| CuckooCacheError::NotNumeric)
    }

    /// Perform a saturating subtraction on the value.
    pub fn saturating_sub(&mut self, rhs: u64) -> Result<(), CuckooCacheError> {
        self.raw
            .saturating_sub(rhs)
            .map_err(|_| CuckooCacheError::NotNumeric)
    }
}

impl std::fmt::Debug for Item {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Item")
            .field("expire", &self.expire())
            .field("raw", &self.raw)
            .finish()
    }
}