teloxide-ng 0.17.1

An elegant Telegram bots framework for Rust
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
74
75
76
77
78
79
80
81
82

//! Various serializers for dialogue storages.

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

/// A serializer for memory storages.
pub trait Serializer<D> {
    type Error;

    fn serialize(&self, val: &D) -> Result<Vec<u8>, Self::Error>;
    fn deserialize(&self, data: &[u8]) -> Result<D, Self::Error>;
}

/// The JSON serializer for memory storages.
pub struct Json;

impl<D> Serializer<D> for Json
where
    D: Serialize + DeserializeOwned,
{
    type Error = serde_json::Error;

    fn serialize(&self, val: &D) -> Result<Vec<u8>, Self::Error> {
        serde_json::to_vec(val)
    }

    fn deserialize(&self, data: &[u8]) -> Result<D, Self::Error> {
        serde_json::from_slice(data)
    }
}

/// The [CBOR] serializer for memory storages.
///
/// [CBOR]: https://en.wikipedia.org/wiki/CBOR
#[cfg(feature = "cbor-serializer")]
pub struct Cbor;

#[cfg(feature = "cbor-serializer")]
impl<D> Serializer<D> for Cbor
where
    D: Serialize + DeserializeOwned,
{
    type Error = serde_cbor::Error;

    fn serialize(&self, val: &D) -> Result<Vec<u8>, Self::Error> {
        serde_cbor::to_vec(val)
    }

    fn deserialize(&self, data: &[u8]) -> Result<D, Self::Error> {
        serde_cbor::from_slice(data)
    }
}

/// The [Bincode] serializer for memory storages.
///
/// Can't serialize if the length is unknown, [see this issue](https://github.com/bincode-org/bincode/issues/167).
/// Use [`Cbor`] or [`Json`] if you are storing structs like [`Message`].
///
/// [Bincode]: https://github.com/servo/bincode
/// [`Cbor`]: crate::dispatching::dialogue::serializer::Cbor
/// [`Json`]: crate::dispatching::dialogue::serializer::Json
/// [`Message`]: crate::types::Message
#[cfg(feature = "bincode-serializer")]
pub struct Bincode;

#[cfg(feature = "bincode-serializer")]
impl<D> Serializer<D> for Bincode
where
    D: Serialize + DeserializeOwned,
{
    type Error = Box<dyn std::error::Error + Send + Sync>;

    fn serialize(&self, val: &D) -> Result<Vec<u8>, Self::Error> {
        bincode::serde::encode_to_vec(val, bincode::config::standard())
            .map_err(|err| Box::new(err) as Self::Error)
    }

    fn deserialize(&self, data: &[u8]) -> Result<D, Self::Error> {
        bincode::serde::decode_from_slice(data, bincode::config::standard())
            .map(|(value, _)| value)
            .map_err(|err| Box::new(err) as Self::Error)
    }
}