beserial/
lib.rs

1use std::collections::HashSet;
2use std::ops::Deref;
3
4pub use byteorder::{BigEndian, ByteOrder, ReadBytesExt, WriteBytesExt};
5use failure::Fail;
6pub use num::ToPrimitive;
7
8pub use crate::types::uvar;
9use std::hash::BuildHasher;
10
11mod types;
12
13// Base traits
14
15pub trait Deserialize: Sized {
16    fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError>;
17
18    fn deserialize_from_vec(v: &Vec<u8>) -> Result<Self, SerializingError> {
19        Self::deserialize(&mut &v[..])
20    }
21}
22
23pub trait Serialize {
24    fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError>;
25    fn serialized_size(&self) -> usize;
26
27    fn serialize_to_vec(&self) -> Vec<u8> {
28        let mut v = Vec::with_capacity(self.serialized_size());
29        self.serialize(&mut v).unwrap();
30        v
31    }
32}
33
34// Error and result
35
36#[derive(Fail, Debug, PartialEq, Eq, Clone)]
37pub enum SerializingError {
38    #[fail(display = "IoError(kind={:?}, description={})", _0, _1)]
39    IoError(std::io::ErrorKind, String),
40    #[fail(display = "Invalid encoding")]
41    InvalidEncoding,
42    #[fail(display = "Invalid value")]
43    InvalidValue,
44    #[fail(display = "Overflow")]
45    Overflow,
46}
47
48impl From<std::io::Error> for SerializingError {
49    fn from(io_error: std::io::Error) -> Self {
50        SerializingError::IoError(io_error.kind(), format!("{}", io_error))
51    }
52}
53
54// TODO: Remove
55#[deprecated]
56impl From<SerializingError> for std::io::Error {
57    fn from(_: SerializingError) -> Self {
58        std::io::Error::from(std::io::ErrorKind::Other)
59    }
60}
61
62// Implementation for u8 and u16/32/64 (big endian)
63
64impl Deserialize for u8 {
65    fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
66        Ok(reader.read_u8()?)
67    }
68}
69
70impl Serialize for u8 {
71    fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
72        writer.write_u8(*self)?;
73        Ok(self.serialized_size())
74    }
75
76    fn serialized_size(&self) -> usize {
77        1
78    }
79}
80
81macro_rules! primitive_serialize {
82    ($t: ty, $len: expr, $r: ident, $w: ident) => {
83        impl Deserialize for $t {
84            fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
85                Ok(reader.$r::<BigEndian>()?)
86            }
87        }
88
89        impl Serialize for $t {
90            fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
91                writer.$w::<BigEndian>(*self)?;
92                Ok(self.serialized_size())
93            }
94
95            fn serialized_size(&self) -> usize {
96                $len
97            }
98        }
99    };
100}
101
102primitive_serialize!(u16, 2, read_u16, write_u16);
103primitive_serialize!(u32, 4, read_u32, write_u32);
104primitive_serialize!(u64, 8, read_u64, write_u64);
105
106
107// Implementation for i8 and i16/32/64 (big endian)
108
109impl Deserialize for i8 {
110    fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
111        Ok(reader.read_i8()?)
112    }
113}
114
115impl Serialize for i8 {
116    fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
117        writer.write_i8(*self)?;
118        Ok(self.serialized_size())
119    }
120
121    fn serialized_size(&self) -> usize {
122        1
123    }
124}
125
126primitive_serialize!(i16, 2, read_i16, write_i16);
127primitive_serialize!(i32, 4, read_i32, write_i32);
128primitive_serialize!(i64, 8, read_i64, write_i64);
129
130// Unit
131
132impl Deserialize for () {
133    fn deserialize<R: ReadBytesExt>(_reader: &mut R) -> Result<Self, SerializingError> { Ok(()) }
134}
135
136impl Serialize for () {
137    fn serialize<W: WriteBytesExt>(&self, _writer: &mut W) -> Result<usize, SerializingError> { Ok(0) }
138
139    fn serialized_size(&self) -> usize { 0 }
140}
141
142
143// Boolean
144
145impl Deserialize for bool {
146    fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
147        match reader.read_u8()? {
148            0 => Ok(false),
149            1 => Ok(true),
150            _ => Err(SerializingError::InvalidValue),
151        }
152    }
153}
154
155impl Serialize for bool {
156    fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
157        writer.write_u8(if *self { 1u8 } else { 0u8 })?;
158        Ok(self.serialized_size())
159    }
160
161    fn serialized_size(&self) -> usize {
162        1
163    }
164}
165
166
167// String
168
169impl DeserializeWithLength for String {
170    fn deserialize<D: Deserialize + num::ToPrimitive, R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
171        let vec: Vec<u8> = DeserializeWithLength::deserialize::<D, R>(reader)?;
172        String::from_utf8(vec).or(Err(SerializingError::InvalidEncoding))
173    }
174}
175
176impl SerializeWithLength for String {
177    fn serialize<S: Serialize + num::FromPrimitive, W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
178        self.as_bytes().to_vec().serialize::<S, W>(writer)
179    }
180
181    fn serialized_size<S: Serialize + num::FromPrimitive>(&self) -> usize {
182        self.as_bytes().to_vec().serialized_size::<S>()
183    }
184}
185
186// Vectors
187
188pub trait DeserializeWithLength: Sized {
189    fn deserialize<D: Deserialize + num::ToPrimitive, R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError>;
190    fn deserialize_from_vec<D: Deserialize + num::ToPrimitive>(v: &Vec<u8>) -> Result<Self, SerializingError> {
191        Self::deserialize::<D, _>(&mut &v[..])
192    }
193}
194
195pub trait SerializeWithLength {
196    fn serialize<S: Serialize + num::FromPrimitive, W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError>;
197    fn serialized_size<S: Serialize + num::FromPrimitive>(&self) -> usize;
198    fn serialize_to_vec<S: Serialize + num::FromPrimitive>(&self) -> Vec<u8> {
199        let mut v = Vec::with_capacity(self.serialized_size::<S>());
200        self.serialize::<S, Vec<u8>>(&mut v).unwrap();
201        v
202    }
203}
204
205impl<T: Deserialize> DeserializeWithLength for Vec<T> {
206    fn deserialize<D: Deserialize + num::ToPrimitive, R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
207        let len: D = Deserialize::deserialize(reader)?;
208        let len_u = len.to_usize().unwrap();
209        let mut v = Vec::with_capacity(len_u);
210        for _ in 0..len_u {
211            v.push(T::deserialize(reader)?);
212        }
213        Ok(v)
214    }
215}
216
217impl<T: Serialize> SerializeWithLength for Vec<T> {
218    fn serialize<S: Serialize + num::FromPrimitive, W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
219        let mut size = S::from_usize(self.len()).unwrap().serialize(writer)?;
220        for t in self {
221            size += t.serialize(writer)?;
222        }
223        Ok(size)
224    }
225
226    fn serialized_size<S: Serialize + num::FromPrimitive>(&self) -> usize {
227        let mut size = S::from_usize(self.len()).unwrap().serialized_size();
228        for t in self {
229            size += t.serialized_size();
230        }
231        size
232    }
233}
234
235// Box
236
237impl<T: Deserialize> Deserialize for Box<T> {
238    fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
239        Ok(Box::new(T::deserialize(reader)?))
240    }
241}
242
243impl<T: Serialize> Serialize for Box<T> {
244    fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
245        Ok(T::serialize(self.deref(), writer)?)
246    }
247
248    fn serialized_size(&self) -> usize {
249        self.deref().serialized_size()
250    }
251}
252
253// HashSets
254
255impl<T, H> DeserializeWithLength for HashSet<T, H>
256    where T: Deserialize + std::cmp::Eq + std::hash::Hash,
257          H: BuildHasher + Default
258{
259    fn deserialize<D: Deserialize + num::ToPrimitive, R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
260        let len: D = Deserialize::deserialize(reader)?;
261        let len_u = len.to_usize().unwrap();
262        let mut v = HashSet::with_capacity_and_hasher(len_u, H::default());
263        for _ in 0..len_u {
264            v.insert(T::deserialize(reader)?);
265        }
266        Ok(v)
267    }
268}
269
270impl<T, H> SerializeWithLength for HashSet<T, H>
271    where T: Serialize + std::cmp::Eq + std::hash::Hash,
272          H: BuildHasher
273{
274    fn serialize<S: Serialize + num::FromPrimitive, W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
275        let mut size = S::from_usize(self.len()).unwrap().serialize(writer)?;
276        for t in self {
277            size += t.serialize(writer)?;
278        }
279        Ok(size)
280    }
281
282    fn serialized_size<S: Serialize + num::FromPrimitive>(&self) -> usize {
283        let mut size = S::from_usize(self.len()).unwrap().serialized_size();
284        for t in self {
285            size += t.serialized_size();
286        }
287        size
288    }
289}
290
291// References
292
293impl<'a, T: Serialize> Serialize for &'a T {
294    fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
295        Serialize::serialize(*self, writer)
296    }
297
298    fn serialized_size(&self) -> usize {
299        Serialize::serialized_size(*self)
300    }
301}
302
303impl<T: Deserialize> Deserialize for Option<T> {
304    fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
305        let is_present: u8 = Deserialize::deserialize(reader)?;
306        match is_present {
307            0 => Ok(Option::None),
308            1 => Ok(Option::Some(Deserialize::deserialize(reader)?)),
309            _ => Err(SerializingError::InvalidValue),
310        }
311    }
312}
313
314impl<T: DeserializeWithLength> DeserializeWithLength for Option<T> {
315    fn deserialize<D: Deserialize + num::ToPrimitive, R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
316        let is_present: u8 = Deserialize::deserialize(reader)?;
317        match is_present {
318            0 => Ok(Option::None),
319            1 => Ok(Option::Some(DeserializeWithLength::deserialize::<D, R>(reader)?)),
320            _ => Err(SerializingError::InvalidValue),
321        }
322    }
323}
324
325impl<T: Serialize> Serialize for Option<T> {
326    fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
327        match self {
328            Option::Some(one) => {
329                1u8.serialize(writer)?;
330                Ok(one.serialize(writer)? + 1)
331            }
332            Option::None => {
333                0u8.serialize(writer)
334            }
335        }
336    }
337
338    fn serialized_size(&self) -> usize {
339        match self {
340            Option::Some(one) => 1 + Serialize::serialized_size(one),
341            Option::None => 1
342        }
343    }
344}
345
346impl<T: SerializeWithLength> SerializeWithLength for Option<T> {
347    fn serialize<S: Serialize + num::FromPrimitive, W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
348        match self {
349            Option::Some(one) => {
350                1u8.serialize(writer)?;
351                Ok(SerializeWithLength::serialize::<S, W>(one, writer)? + 1)
352            }
353            Option::None => {
354                0u8.serialize(writer)
355            }
356        }
357    }
358
359    fn serialized_size<S: Serialize + num::FromPrimitive>(&self) -> usize {
360        match self {
361            Option::Some(one) => 1 + SerializeWithLength::serialized_size::<S>(one),
362            Option::None => 1
363        }
364    }
365}
beserial/lib.rs

beserial/
lib.rs
