1use byteorder::{BigEndian, ReadBytesExt};
2use std::io;
3
4use serde::de::{
5 self, Deserialize, DeserializeSeed, EnumAccess, IntoDeserializer,
6 SeqAccess, VariantAccess, Visitor,
7};
8
9use super::error::{ProtoError, ProtoResult};
10
11#[derive(Debug)]
12pub struct Deserializer<R: io::Read> {
13 reader: R,
14}
15
16impl<R: io::Read> Deserializer<R> {
17 pub fn from_reader(reader: R) -> Self {
18 Deserializer {
19 reader: reader
20 }
21 }
22
23 pub fn to_reader(self) -> R {
24 self.reader
25 }
26
27 fn read_buf(&mut self) -> ProtoResult<Vec<u8>> {
28 let len = self.reader.read_u32::<BigEndian>()?;
29 let mut buf = vec![0; len as usize];
30 self.reader.read_exact(&mut buf)?;
31 return Ok(buf);
32 }
33}
34
35pub fn from_bytes<'a, T: Deserialize<'a>>(bytes: &[u8]) -> ProtoResult<T> {
36 let mut deserializer = Deserializer::from_reader(bytes);
37 let result = T::deserialize(&mut deserializer)?;
38 let remaining_bytes = deserializer.to_reader();
39
40 if remaining_bytes.len() == 0 {
41 Ok(result)
42 } else {
43 Err(ProtoError::Deserialization(
44 format!("Buffer not depleted. Remaining bytes: {:?}", remaining_bytes)
45 ))
46 }
47}
48
49impl<'de, 'a, R: io::Read> de::Deserializer<'de> for &'a mut Deserializer<R> {
50 type Error = ProtoError;
51
52 fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> ProtoResult<V::Value> {
53 unimplemented!()
54 }
55
56 fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
57 visitor.visit_bool(self.reader.read_u8()? > 0)
58 }
59
60 fn deserialize_i8<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
61 visitor.visit_i8(self.reader.read_i8()?)
62 }
63
64 fn deserialize_i16<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
65 visitor.visit_i16(self.reader.read_i16::<BigEndian>()?)
66 }
67
68 fn deserialize_i32<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
69 visitor.visit_i32(self.reader.read_i32::<BigEndian>()?)
70 }
71
72 fn deserialize_i64<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
73 visitor.visit_i64(self.reader.read_i64::<BigEndian>()?)
74 }
75
76 fn deserialize_u8<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
77 visitor.visit_u8(self.reader.read_u8()?)
78 }
79
80 fn deserialize_u16<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
81 visitor.visit_u16(self.reader.read_u16::<BigEndian>()?)
82 }
83
84 fn deserialize_u32<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
85 visitor.visit_u32(self.reader.read_u32::<BigEndian>()?)
86 }
87
88 fn deserialize_u64<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
89 visitor.visit_u64(self.reader.read_u64::<BigEndian>()?)
90 }
91
92 fn deserialize_f32<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
93 visitor.visit_f32(self.reader.read_f32::<BigEndian>()?)
94 }
95
96 fn deserialize_f64<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
97 visitor.visit_f64(self.reader.read_f64::<BigEndian>()?)
98 }
99
100 fn deserialize_char<V: Visitor<'de>>(self, _visitor: V) -> ProtoResult<V::Value> {
101 unimplemented!()
102 }
103
104 fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
105 visitor.visit_string(String::from_utf8(self.read_buf()?)?)
106 }
107
108 fn deserialize_string<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
109 visitor.visit_string(String::from_utf8(self.read_buf()?)?)
110 }
111
112 fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
113 visitor.visit_byte_buf(self.read_buf()?)
114 }
115
116 fn deserialize_byte_buf<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
117 visitor.visit_byte_buf(self.read_buf()?)
118 }
119
120 fn deserialize_option<V: Visitor<'de>>(self, _visitor: V) -> ProtoResult<V::Value> {
121 unimplemented!()
122 }
123
124 fn deserialize_unit<V: Visitor<'de>>(self, _visitor: V) -> ProtoResult<V::Value> {
125 unimplemented!()
126 }
127
128 fn deserialize_unit_struct<V: Visitor<'de>>(
129 self,
130 _name: &'static str,
131 _visitor: V,
132 ) -> ProtoResult<V::Value> {
133 unimplemented!()
134 }
135
136 fn deserialize_newtype_struct<V: Visitor<'de>>(
137 self,
138 _name: &'static str,
139 visitor: V,
140 ) -> ProtoResult<V::Value> {
141 visitor.visit_newtype_struct(self)
142 }
143
144 fn deserialize_seq<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
145 let len = self.reader.read_u32::<BigEndian>()? as usize;
146 visitor.visit_seq(BinarySeq::new(len, &mut *self))
147 }
148
149 fn deserialize_tuple<V: Visitor<'de>>(self, len: usize, visitor: V) -> ProtoResult<V::Value> {
150 visitor.visit_seq(BinarySeq::new(len, &mut *self))
151 }
152
153 fn deserialize_tuple_struct<V: Visitor<'de>>(
154 self,
155 _name: &'static str,
156 _len: usize,
157 visitor: V,
158 ) -> ProtoResult<V::Value> {
159 self.deserialize_seq(visitor)
160 }
161
162 fn deserialize_map<V: Visitor<'de>>(self, _visitor: V) -> ProtoResult<V::Value> {
163 unimplemented!()
164 }
165
166 fn deserialize_struct<V: Visitor<'de>>(
167 self,
168 _name: &'static str,
169 fields: &'static [&'static str],
170 visitor: V,
171 ) -> ProtoResult<V::Value> {
172 visitor.visit_seq(BinarySeq::new(fields.len(), &mut *self))
173 }
174
175 fn deserialize_enum<V: Visitor<'de>>(
176 self,
177 _name: &'static str,
178 _variants: &'static [&'static str],
179 visitor: V,
180 ) -> ProtoResult<V::Value> {
181 visitor.visit_enum(BinaryEnum::new(&mut *self))
182 }
183
184 fn deserialize_identifier<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
185 self.deserialize_str(visitor)
186 }
187
188 fn deserialize_ignored_any<V: Visitor<'de>>(self, visitor: V) -> ProtoResult<V::Value> {
189 self.deserialize_any(visitor)
190 }
191}
192
193struct BinarySeq<'a, R: io::Read> {
194 remaining: usize,
195 de: &'a mut Deserializer<R>
196}
197
198impl<'a, R: io::Read> BinarySeq<'a, R> {
199 fn new(remaining: usize, de: &'a mut Deserializer<R>) -> Self {
200 BinarySeq {
201 remaining: remaining,
202 de: de
203 }
204 }
205}
206
207impl<'de, 'a, R: io::Read> SeqAccess<'de> for BinarySeq<'a, R> {
208 type Error = ProtoError;
209
210 fn next_element_seed<T: DeserializeSeed<'de>>(&mut self, seed: T) -> ProtoResult<Option<T::Value>> {
211 if self.remaining > 0 {
212 self.remaining -= 1;
213 seed.deserialize(&mut *self.de).map(Some)
214 } else {
215 Ok(None)
216 }
217 }
218}
219
220struct BinaryEnum<'a, R: io::Read> {
221 de: &'a mut Deserializer<R>,
222}
223
224impl<'a, R: io::Read> BinaryEnum<'a, R> {
225 fn new(de: &'a mut Deserializer<R>) -> Self {
226 BinaryEnum {
227 de: de
228 }
229 }
230}
231
232impl<'de, 'a, R: io::Read> EnumAccess<'de> for BinaryEnum<'a, R> {
233 type Error = ProtoError;
234 type Variant = Self;
235
236 fn variant_seed<V>(self, seed: V) -> ProtoResult<(V::Value, Self::Variant)>
237 where
238 V: DeserializeSeed<'de>,
239 {
240 let index: u8 = de::Deserialize::deserialize(&mut *self.de)?;
241 let value: ProtoResult<_> = seed.deserialize(index.into_deserializer());
242 Ok((value?, self))
243 }
244}
245
246impl<'de, 'a, R: io::Read> VariantAccess<'de> for BinaryEnum<'a, R> {
247 type Error = ProtoError;
248
249 fn unit_variant(self) -> ProtoResult<()> {
250 Ok(())
251 }
252
253 fn newtype_variant_seed<T: DeserializeSeed<'de>>(self, seed: T) -> ProtoResult<T::Value> {
254 seed.deserialize(self.de)
255 }
256
257 fn tuple_variant<V: Visitor<'de>>(self, _len: usize, visitor: V) -> ProtoResult<V::Value> {
258 de::Deserializer::deserialize_seq(self.de, visitor)
259 }
260
261 fn struct_variant<V: Visitor<'de>>(
262 self,
263 _fields: &'static [&'static str],
264 visitor: V,
265 ) -> ProtoResult<V::Value> {
266 de::Deserializer::deserialize_map(self.de, visitor)
267 }
268}