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
use crate::{serialize::TypedSerialized, Error};
use alloc::{format, vec::Vec};
use core::marker::PhantomData;
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct BincodeSerializer<T> {
serialized: Vec<u8>,
_type: PhantomData<T>,
}
impl<T> TypedSerialized for BincodeSerializer<T> {
type T = T;
fn new(serialized: Vec<u8>) -> Self
where
Self: Sized,
{
Self {
serialized,
_type: PhantomData::default(),
}
}
fn as_slice(&self) -> &[u8] {
&self.serialized
}
fn into_vec(self) -> Vec<u8> {
self.serialized
}
fn serialize(v: &Self::T) -> Result<Self, Error>
where
Self: Sized,
Self::T: Serialize,
{
let serialized = bincode::serialize(v).map_err(|e| {
Error::serialization_error(&format!("failed to serialize data by bincode: {:?}", e))
})?;
Ok(Self::new(serialized))
}
fn deserialize<'de>(&'de self) -> Result<Self::T, Error>
where
Self::T: Deserialize<'de>,
{
bincode::deserialize(self.as_slice()).map_err(|e| {
Error::deserialization_error(&format!(
"error on bincode deserialization after decryption: {:?}",
e
))
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_bincode_serializer() -> Result<(), Error> {
#[derive(PartialEq, Debug, Serialize, Deserialize)]
struct Message(i32);
let msg = Message(42);
let serialized_msg = BincodeSerializer::serialize(&msg)?;
let deserialized_msg = serialized_msg.deserialize()?;
assert_eq!(msg, deserialized_msg);
Ok(())
}
}