cachet 0.7.0 

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

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! Builder methods for serialization of cache Key and Value.

use std::hash::Hash;

use bytesbuf::BytesView;
use bytesbuf::mem::GlobalPool;
use serde::Serialize;
use serde::de::DeserializeOwned;

use super::transform::TransformBuilder;
use crate::serialize::codec::{PostcardCodec, PostcardEncoder};
use crate::{CacheBuilder, CacheTier, CacheTierBuilder, FallbackBuilder};

impl<K, V, CT> CacheBuilder<K, V, CT>
where
    K: Clone + Hash + Eq + Send + Sync + 'static,
    V: Clone + Send + Sync + 'static,
    CT: CacheTier<K, V> + Send + Sync + 'static,
{
    /// Applies a serialization boundary that converts keys and values to [`BytesView`](bytesbuf::BytesView).
    ///
    /// Subsequent `.fallback()` tiers must work with `BytesView` keys and values.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use cachet::Cache;
    /// use tick::Clock;
    ///
    /// let clock = Clock::new_tokio();
    /// let remote = Cache::builder::<bytesbuf::BytesView, bytesbuf::BytesView>(clock.clone()).memory();
    ///
    /// let cache = Cache::builder::<String, String>(clock)
    ///     .memory()
    ///     .serialize()
    ///     .fallback(remote)
    ///     .build();
    /// ```
    #[must_use]
    pub fn serialize(self) -> TransformBuilder<K, V, BytesView, BytesView, Self>
    where
        K: Serialize,
        V: Serialize + DeserializeOwned,
    {
        let pool = GlobalPool::new();
        self.transform(PostcardEncoder::new(pool.clone()), PostcardCodec::new(pool))
    }
}

impl<K, V, PB, FB> FallbackBuilder<K, V, PB, FB>
where
    K: Clone + Hash + Eq + Send + Sync + 'static,
    V: Clone + Send + Sync + 'static,
    PB: CacheTierBuilder<K, V>,
    FB: CacheTierBuilder<K, V>,
{
    /// Applies a serialization boundary on a fallback builder.
    #[must_use]
    pub fn serialize(self) -> TransformBuilder<K, V, BytesView, BytesView, Self>
    where
        K: Serialize,
        V: Serialize + DeserializeOwned,
    {
        let pool = GlobalPool::new();
        self.transform(PostcardEncoder::new(pool.clone()), PostcardCodec::new(pool))
    }
}