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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#[derive(Debug)]
pub enum ProtoConversionError {
DeserializationError(String),
SerializationError(String),
InvalidTypeError(String),
}
impl std::error::Error for ProtoConversionError {}
impl std::fmt::Display for ProtoConversionError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match *self {
ProtoConversionError::DeserializationError(ref s) => {
write!(f, "unable to deserialize during protobuf conversion: {}", s)
}
ProtoConversionError::SerializationError(ref s) => {
write!(f, "unable to serialize during protobuf conversion: {}", s)
}
ProtoConversionError::InvalidTypeError(ref s) => write!(
f,
"invalid type encountered during protobuf conversion: {}",
s
),
}
}
}
pub trait FromProto<P>: Sized {
fn from_proto(other: P) -> Result<Self, ProtoConversionError>;
}
pub trait FromNative<N>: Sized {
fn from_native(other: N) -> Result<Self, ProtoConversionError>;
}
pub trait FromBytes<ViaProtocol>: Sized {
fn from_bytes(bytes: &[u8]) -> Result<Self, ProtoConversionError>;
}
impl<P, N> FromBytes<P> for N
where
P: protobuf::Message,
N: FromProto<P>,
{
fn from_bytes(bytes: &[u8]) -> Result<Self, ProtoConversionError> {
let p: P = protobuf::parse_from_bytes(bytes)
.map_err(|err| ProtoConversionError::DeserializationError(err.to_string()))?;
N::from_proto(p)
}
}
pub trait IntoBytes<ViaProtocol>: Sized {
fn into_bytes(self) -> Result<Vec<u8>, ProtoConversionError>;
}
impl<P, N> IntoBytes<P> for N
where
P: protobuf::Message + FromNative<N>,
{
fn into_bytes(self) -> Result<Vec<u8>, ProtoConversionError> {
let p = P::from_native(self)?;
p.write_to_bytes()
.map_err(|err| ProtoConversionError::SerializationError(err.to_string()))
}
}
pub trait IntoNative<T>: Sized {
fn into_native(self) -> Result<T, ProtoConversionError>;
}
impl<N, P> IntoNative<N> for P
where
N: FromProto<P>,
{
fn into_native(self) -> Result<N, ProtoConversionError> {
FromProto::from_proto(self)
}
}
pub trait IntoProto<T>: Sized {
fn into_proto(self) -> Result<T, ProtoConversionError>;
}
impl<N, P> IntoProto<P> for N
where
P: FromNative<N>,
{
fn into_proto(self) -> Result<P, ProtoConversionError> {
FromNative::from_native(self)
}
}
pub mod prelude {
pub use super::FromBytes;
pub use super::FromNative;
pub use super::FromProto;
pub use super::IntoBytes;
pub use super::IntoNative;
pub use super::IntoProto;
pub use super::ProtoConversionError;
}
include!(concat!(env!("OUT_DIR"), "/protos/mod.rs"));