oxicode 0.2.1

A modern binary serialization library - successor to bincode
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Compatibility wrappers for serde types

use crate::{
    de::{BorrowDecode, BorrowDecoder, Decode, Decoder},
    enc::{Encode, Encoder},
    error::Error,
};

/// Wrapper for types that implement serde's Serialize/Deserialize
///
/// This allows encoding/decoding types that don't implement oxicode's
/// native Encode/Decode traits.
///
/// # Example
///
/// ```ignore
/// use oxicode::serde::Compat;
/// use serde::{Serialize, Deserialize};
///
/// #[derive(Serialize, Deserialize)]
/// struct External {
///     // Some third-party type
/// }
///
/// // Wrap it to use with oxicode
/// let wrapped = Compat(external);
/// let bytes = oxicode::encode_to_vec(&wrapped)?;
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Compat<T>(pub T);

impl<T> Encode for Compat<T>
where
    T: serde::Serialize,
{
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), Error> {
        let serializer = super::ser::Serializer::new(encoder);
        self.0
            .serialize(serializer)
            .map_err(|e| Error::OwnedCustom { message: e.msg })
    }
}

impl<T> Decode for Compat<T>
where
    T: serde::de::DeserializeOwned,
{
    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
        let deserializer = super::de::Deserializer::new(decoder);
        T::deserialize(deserializer)
            .map(Compat)
            .map_err(|e| Error::OwnedCustom { message: e.msg })
    }
}

/// Wrapper for borrowed types that implement serde's Deserialize
///
/// This allows zero-copy decoding of serde types.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct BorrowCompat<T>(pub T);

impl<T> Encode for BorrowCompat<T>
where
    T: serde::Serialize,
{
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), Error> {
        let serializer = super::ser::Serializer::new(encoder);
        self.0
            .serialize(serializer)
            .map_err(|e| Error::OwnedCustom { message: e.msg })
    }
}

impl<'de, T> BorrowDecode<'de> for BorrowCompat<T>
where
    T: serde::Deserialize<'de>,
{
    fn borrow_decode<D: BorrowDecoder<'de, Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
        let deserializer = super::de::Deserializer::new(decoder);
        T::deserialize(deserializer)
            .map(BorrowCompat)
            .map_err(|e| Error::OwnedCustom { message: e.msg })
    }
}