bincache 0.5.1

ZitaneLabs binary cache.
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use crate::{CacheCapacity, Result};
use crate::{CacheKey, CacheStrategy, CompressionStrategy};
use async_trait::async_trait;
use std::borrow::Cow;

/// A no-op object that implements both `CacheStrategy` and `CompressionStrategy`.
/// Can be used as a placeholder in testing, or as a default compression strategy (acts as an identity function).
#[derive(Default, Debug)]
pub struct Noop;

#[async_trait]
impl CacheStrategy for Noop {
    type CacheEntry = ();

    async fn put<'a, K, V>(&mut self, _key: &K, _value: V) -> Result<Self::CacheEntry>
    where
        K: CacheKey + Sync + Send,
        V: Into<Cow<'a, [u8]>> + Send,
    {
        Ok(())
    }

    async fn get<'a>(&self, _entry: &'a Self::CacheEntry) -> Result<Cow<'a, [u8]>> {
        Ok(Cow::Borrowed(&[]))
    }

    async fn take(&mut self, _entry: Self::CacheEntry) -> Result<Vec<u8>> {
        Ok(vec![])
    }

    async fn delete(&mut self, _entry: Self::CacheEntry) -> Result<()> {
        Ok(())
    }

    fn get_cache_capacity(&self) -> Option<CacheCapacity> {
        None
    }
}

#[async_trait]
impl CompressionStrategy for Noop {
    async fn compress<'a>(&self, data: Cow<'a, [u8]>) -> Result<Cow<'a, [u8]>> {
        Ok(data)
    }

    async fn decompress<'a>(&self, data: Cow<'a, [u8]>) -> Result<Cow<'a, [u8]>> {
        Ok(data)
    }
}

#[cfg(test)]
mod tests {
    use super::Noop;
    use crate::{async_test, CompressionStrategy};

    fn create_arb_data(range: usize) -> Vec<u8> {
        let mut vec = Vec::with_capacity(range);
        for i in 0..range {
            vec.push((i % 255) as u8);
        }
        vec
    }

    async_test! {
        async fn test_compression() {
            let data = create_arb_data(1024);
            let zstd = Noop;
            let compressed = zstd.compress(data.clone().into()).await.unwrap();
            let decompressed = zstd.decompress(compressed).await.unwrap();
            assert_eq!(data.as_slice(), decompressed.as_ref());
        }
    }
}