Skip to content

Commit c259ccc

Browse files
tbrezottbrezot
authored
Feat/implement serializable for base types (#99)
* implement `Serializable` for base types * implement `Serializable` for `String` * fix error management in the `Serializable` implem for `HashMap` * implement `Serializable` for boolean values * implement `Serializable` for `LinkedList` * implement `Serializable` for `Option` * fix comments
1 parent 0975ec2 commit c259ccc

1 file changed

Lines changed: 261 additions & 7 deletions

File tree

‎src/bytes_ser_de.rs‎

Lines changed: 261 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,9 @@
11
//! Implements the `Serializer` and `Deserializer` objects using LEB128.
22
33
use std::{
4+
collections::{HashMap, HashSet, LinkedList},
45
fmt::Debug,
6+
hash::Hash,
57
io::{Read, Write},
68
};
79

@@ -258,10 +260,6 @@ impl Default for Serializer {
258260
/// → 0xE5 0x8E 0x26 Output stream (LSB to MSB)
259261
///
260262
/// Source: [Wikipedia](https://en.wikipedia.org/wiki/LEB128#Encoding_format)
261-
///
262-
/// # Parameters
263-
///
264-
/// - `n` : `usize` for which to compute the length of the serialization
265263
#[must_use]
266264
pub fn to_leb128_len(n: usize) -> usize {
267265
let mut n = n >> 7;
@@ -273,6 +271,220 @@ pub fn to_leb128_len(n: usize) -> usize {
273271
size
274272
}
275273

274+
impl Serializable for bool {
275+
type Error = CryptoCoreError;
276+
277+
fn length(&self) -> usize {
278+
1
279+
}
280+
281+
fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
282+
ser.write_leb128_u64(*self as u64)
283+
}
284+
285+
fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
286+
let b = de.read_leb128_u64()?;
287+
match b {
288+
0 => Ok(false),
289+
1 => Ok(true),
290+
_ => Err(CryptoCoreError::GenericDeserializationError(format!(
291+
"not a valid boolean value serialization {b}"
292+
))),
293+
}
294+
}
295+
}
296+
297+
impl Serializable for u64 {
298+
type Error = CryptoCoreError;
299+
300+
fn length(&self) -> usize {
301+
if *self == 0 {
302+
1
303+
} else {
304+
(64 - self.leading_zeros()).div_ceil(7) as usize
305+
}
306+
}
307+
308+
fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
309+
ser.write_leb128_u64(*self)
310+
}
311+
312+
fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
313+
de.read_leb128_u64()
314+
}
315+
}
316+
317+
impl Serializable for usize {
318+
type Error = CryptoCoreError;
319+
320+
fn length(&self) -> usize {
321+
to_leb128_len(*self)
322+
}
323+
324+
fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
325+
ser.write_leb128_u64(*self as u64)
326+
}
327+
328+
fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
329+
de.read_leb128_u64().and_then(|n| {
330+
usize::try_from(n).map_err(|_| {
331+
CryptoCoreError::GenericDeserializationError("not an usize number".to_string())
332+
})
333+
})
334+
}
335+
}
336+
337+
impl Serializable for String {
338+
type Error = CryptoCoreError;
339+
340+
fn length(&self) -> usize {
341+
self.len().length() + self.len()
342+
}
343+
344+
fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
345+
ser.write_vec(self.as_bytes())
346+
}
347+
348+
fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
349+
de.read_vec().and_then(|bytes| {
350+
String::from_utf8(bytes)
351+
.map_err(|e| CryptoCoreError::GenericDeserializationError(e.to_string()))
352+
})
353+
}
354+
}
355+
356+
impl<T: Serializable> Serializable for Option<T>
357+
where
358+
T::Error: From<CryptoCoreError>,
359+
{
360+
type Error = T::Error;
361+
362+
fn length(&self) -> usize {
363+
1 + self.as_ref().map(|t| t.length()).unwrap_or_default()
364+
}
365+
366+
fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
367+
if let Some(t) = self {
368+
let mut n = ser.write(&true)?;
369+
n += ser.write(t)?;
370+
Ok(n)
371+
} else {
372+
ser.write(&false).map_err(Self::Error::from)
373+
}
374+
}
375+
376+
fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
377+
let is_some = de.read::<bool>()?;
378+
if is_some {
379+
de.read().map(Some)
380+
} else {
381+
Ok(None)
382+
}
383+
}
384+
}
385+
386+
impl<T: Serializable> Serializable for Vec<T>
387+
where
388+
T::Error: From<CryptoCoreError>,
389+
{
390+
type Error = T::Error;
391+
392+
fn length(&self) -> usize {
393+
self.len().length() + self.iter().map(Serializable::length).sum::<usize>()
394+
}
395+
396+
fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
397+
self.iter()
398+
.try_fold(ser.write(&self.len())?, |n, t| Ok(n + ser.write(t)?))
399+
}
400+
401+
fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
402+
let length = de.read::<usize>()?;
403+
(0..length).map(|_| de.read::<T>()).collect()
404+
}
405+
}
406+
407+
impl<T: Serializable> Serializable for LinkedList<T>
408+
where
409+
T::Error: From<CryptoCoreError>,
410+
{
411+
type Error = T::Error;
412+
413+
fn length(&self) -> usize {
414+
self.len().length() + self.iter().map(Serializable::length).sum::<usize>()
415+
}
416+
417+
fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
418+
self.iter()
419+
.try_fold(ser.write(&self.len())?, |n, t| Ok(n + ser.write(t)?))
420+
}
421+
422+
fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
423+
let length = de.read::<usize>()?;
424+
(0..length).map(|_| de.read::<T>()).collect()
425+
}
426+
}
427+
428+
impl<T: Hash + Eq + Serializable> Serializable for HashSet<T>
429+
where
430+
T::Error: From<CryptoCoreError>,
431+
{
432+
type Error = T::Error;
433+
434+
fn length(&self) -> usize {
435+
self.len().length() + self.iter().map(Serializable::length).sum::<usize>()
436+
}
437+
438+
fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
439+
self.iter()
440+
.try_fold(ser.write(&self.len())?, |n, t| Ok(n + ser.write(t)?))
441+
}
442+
443+
fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
444+
let length = de.read::<usize>()?;
445+
(0..length).map(|_| de.read::<T>()).collect()
446+
}
447+
}
448+
449+
impl<K: Hash + Eq + Serializable, V: Serializable> Serializable for HashMap<K, V> {
450+
type Error = CryptoCoreError;
451+
452+
fn length(&self) -> usize {
453+
self.len().length()
454+
+ self
455+
.iter()
456+
.map(|(k, v)| k.length() + v.length())
457+
.sum::<usize>()
458+
}
459+
460+
fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
461+
self.iter()
462+
.try_fold(ser.write(&self.len())?, |mut n, (k, v)| {
463+
n += ser
464+
.write(k)
465+
.map_err(|e| CryptoCoreError::GenericDeserializationError(e.to_string()))?;
466+
n += ser
467+
.write(v)
468+
.map_err(|e| CryptoCoreError::GenericDeserializationError(e.to_string()))?;
469+
Ok(n)
470+
})
471+
}
472+
473+
fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
474+
let length = de.read::<usize>()?;
475+
(0..length)
476+
.map(|_| {
477+
Ok((
478+
de.read::<K>()
479+
.map_err(|e| CryptoCoreError::GenericDeserializationError(e.to_string()))?,
480+
de.read::<V>()
481+
.map_err(|e| CryptoCoreError::GenericDeserializationError(e.to_string()))?,
482+
))
483+
})
484+
.collect()
485+
}
486+
}
487+
276488
struct ByteIterator<'a>(&'a mut Deserializer<'a>);
277489

278490
impl<'a> ByteIterator<'a> {
@@ -390,7 +602,9 @@ pub fn test_serialization<T: PartialEq + Debug + Serializable>(v: &T) -> Result<
390602

391603
#[cfg(test)]
392604
mod tests {
393-
use super::{to_leb128_len, Deserializer, Serializable, Serializer};
605+
use std::collections::{HashMap, HashSet};
606+
607+
use super::{test_serialization, to_leb128_len, Deserializer, Serializable, Serializer};
394608
use crate::{
395609
bytes_ser_de::{pack, unpack},
396610
reexport::rand_core::{RngCore, SeedableRng},
@@ -408,7 +622,7 @@ mod tests {
408622
type Error = CryptoCoreError;
409623

410624
fn length(&self) -> usize {
411-
to_leb128_len(self.bytes.len()) + self.bytes.len()
625+
self.bytes.len().length() + self.bytes.len()
412626
}
413627

414628
fn write(&self, ser: &mut crate::bytes_ser_de::Serializer) -> Result<usize, Self::Error> {
@@ -428,7 +642,7 @@ mod tests {
428642
let mut ser = Serializer::new();
429643
for i in 1..1000 {
430644
let n = rng.next_u32();
431-
let length = ser.write_leb128_u64(u64::from(n)).unwrap();
645+
let length = ser.write_leb128_u64(n as u64).unwrap();
432646
assert_eq!(
433647
length,
434648
to_leb128_len(n as usize),
@@ -512,4 +726,44 @@ mod tests {
512726
assert_eq!(booleans, res);
513727
}
514728
}
729+
730+
#[test]
731+
fn test_base_serializations() {
732+
let mut rng = CsRng::from_entropy();
733+
734+
let n = 0u64;
735+
test_serialization(&n).unwrap();
736+
737+
#[cfg(target_pointer_width = "64")]
738+
{
739+
for i in 0..64 {
740+
let n: u64 = 1 << i;
741+
assert_eq!(n.length(), to_leb128_len(n as usize))
742+
}
743+
}
744+
#[cfg(target_pointer_width = "32")]
745+
{
746+
for i in 0..32 {
747+
let n: u64 = 1 << i;
748+
assert_eq!(n.length(), to_leb128_len(n as usize))
749+
}
750+
}
751+
752+
let string = format!(
753+
"{:?}",
754+
(0..1000).map(|_| rng.next_u64()).collect::<Vec<_>>()
755+
);
756+
test_serialization(&string).unwrap();
757+
758+
let v = (0..1000).map(|_| rng.next_u64()).collect::<Vec<_>>();
759+
test_serialization(&v).unwrap();
760+
761+
let s = (0..1000).map(|_| rng.next_u64()).collect::<HashSet<_>>();
762+
test_serialization(&s).unwrap();
763+
764+
let m = (0..1000)
765+
.map(|_| (rng.next_u64(), rng.next_u64()))
766+
.collect::<HashMap<_, _>>();
767+
test_serialization(&m).unwrap();
768+
}
515769
}

0 commit comments

Comments
 (0)