fnct 0.6.5

Simple caching library that supports cache invalidation via tags
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

//! Formatters are used to serialize and deserialize data for storing it in a
//! cache.

use std::fmt::Debug;

use serde::{de::DeserializeOwned, Serialize};

/// A formatter that can serialize data before storing it in a cache and
/// deserialize it after retrieving it from the cache.
pub trait Formatter: Debug {
    /// The unique identifier of this formatter.
    const ID: &'static str;

    /// The error to return if serialization or deserialization fails.
    type Error: std::error::Error;
    /// The type of serialized data.
    type Serialized;

    /// Serialize a `T` and return a [`Self::Serialized`].
    fn serialize<T: Serialize>(&self, value: &T) -> Result<Self::Serialized, Self::Error>;
    /// Deserialize a [`Self::Serialized`] and return a `T`.
    fn deserialize<T: DeserializeOwned>(&self, value: &Self::Serialized) -> Result<T, Self::Error>;
}

/// A formatter using the [`postcard`] crate.
#[derive(Debug, Clone, Copy, Default)]
pub struct PostcardFormatter;

impl Formatter for PostcardFormatter {
    const ID: &'static str = "postcard";

    type Error = postcard::Error;
    type Serialized = Vec<u8>;

    fn serialize<T: Serialize>(&self, value: &T) -> Result<Self::Serialized, Self::Error> {
        postcard::to_stdvec(value)
    }

    fn deserialize<T: DeserializeOwned>(&self, value: &Self::Serialized) -> Result<T, Self::Error> {
        postcard::from_bytes(value)
    }
}

/// A formatter using the [`serde_json`] crate.
#[cfg(feature = "serde_json")]
#[derive(Debug, Clone, Copy, Default)]
pub struct JsonFormatter;

#[cfg(feature = "serde_json")]
impl Formatter for JsonFormatter {
    const ID: &'static str = "json";

    type Error = serde_json::Error;
    type Serialized = String;

    fn serialize<T: Serialize>(&self, value: &T) -> Result<Self::Serialized, Self::Error> {
        serde_json::to_string(value)
    }

    fn deserialize<T: DeserializeOwned>(&self, value: &Self::Serialized) -> Result<T, Self::Error> {
        serde_json::from_str(value)
    }
}