desert_core 0.1.5

Binary serialization library for Rust (core crate)
Documentation 
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

use crate::deserializer::deserialize_iterator;
use crate::Error::DeserializationFailure;
use crate::{
    serialize_iterator, BinaryDeserializer, BinaryInput, BinaryOutput, BinarySerializer,
    DeserializationContext, SerializationContext,
};
use castaway::cast;
use nonempty_collections::NEVec;

impl<T: BinarySerializer + 'static> BinarySerializer for NEVec<T> {
    fn serialize<Output: BinaryOutput>(
        &self,
        context: &mut SerializationContext<Output>,
    ) -> crate::Result<()> {
        if let Ok(byte_vec) = cast!(self, &NEVec<u8>) {
            context.write_var_u32(byte_vec.len().get().try_into()?); // NOTE: this is inconsistent with the generic case, but this way it is compatible with the Scala version's Chunk serializer
            context.write_bytes(byte_vec.as_nonempty_slice().as_ref());
            Ok(())
        } else {
            serialize_iterator(&mut self.iter(), context)
        }
    }
}

impl<T: BinaryDeserializer + 'static> BinaryDeserializer for NEVec<T> {
    fn deserialize(context: &mut DeserializationContext<'_>) -> crate::Result<Self> {
        use std::any::TypeId;

        if TypeId::of::<T>() == TypeId::of::<u8>() {
            let length = context.read_var_u32()?; // NOTE: this is inconsistent with the generic case, but this way it is compatible with the Scala version's Chunk serializer
            let bytes = context.read_bytes(length as usize)?;
            let vec = unsafe { std::mem::transmute::<Vec<u8>, Vec<T>>(bytes.to_vec()) };
            Ok(NEVec::try_from_vec(vec)
                .ok_or_else(|| DeserializationFailure("NEVec was empty".to_string()))?)
        } else {
            let (iter, maybe_size) = deserialize_iterator(context);
            let mut vec = Vec::with_capacity(maybe_size.unwrap_or_default());
            for item in iter {
                vec.push(item?);
            }
            Ok(NEVec::try_from_vec(vec)
                .ok_or_else(|| DeserializationFailure("NEVec was empty".to_string()))?)
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::tests::roundtrip;
    use nonempty_collections::NEVec;
    use proptest::collection::vec;
    use proptest::prelude::*;
    use test_r::test;

    proptest! {
        #[test]
        fn roundtrip_u8(value in vec(any::<u8>(), 1..=1024)) {
            let nevec = NEVec::try_from_vec(value).unwrap();
            roundtrip(nevec);
        }

        #[test]
        fn roundtrip_string(value in vec(any::<String>(), 1..=100)) {
            let nevec = NEVec::try_from_vec(value).unwrap();
            roundtrip(nevec);
        }
    }
}