deser-core 0.10.1

Core traits and types of deser, use the deser crate instead
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
85
86
87

//! `SmallVec` of `smallvec`.
//!
//! It's serialized like `Vec`: `SmallVec<[u8; N]>` as bytes, everything
//! else as sequence.  The impls are for arrays as backing store
//! (`SmallVec<[T; N]>`) which requires the `const_generics` feature of
//! `smallvec`.
use ::smallvec::SmallVec;
use alloc::borrow::Cow;
use alloc::vec::Vec;

use crate::State;
use crate::adapters::bytes::{BytesBufImpl, encoding_adapter};
use crate::de::impls::{SeqTarget, collection_methods, seq_expecting, seq_sink};
use crate::de::update::Collection;
use crate::de::{Deserialize, SinkHandle};
use crate::error::Error;
use crate::ser::Serialize;
use crate::ser::impls::serialize_slice;

serialize_slice! {
    [T: Sync, A: Serialize<T>, const N: usize] SmallVec<[T; N]> => SmallVec<[A; N]>, A;
}

impl<T: Send, const N: usize> SeqTarget<T> for SmallVec<[T; N]> {
    const NAME: &'static str = "SmallVec";

    #[inline]
    fn from_vec(vec: Vec<T>) -> Result<Self, Error> {
        Ok(SmallVec::from_vec(vec))
    }
}

impl<'de, T: Send, A: Deserialize<'de, T>, const N: usize> Deserialize<'de, SmallVec<[T; N]>>
    for SmallVec<[A; N]>
{
    fn deserialize_into<'out>(
        out: &'out mut Option<SmallVec<[T; N]>>,
        state: &mut State,
    ) -> SinkHandle<'out, 'de> {
        seq_sink::<SmallVec<[T; N]>, T, A>(out, state)
    }

    fn expecting() -> Cow<'static, str> {
        seq_expecting::<SmallVec<[T; N]>, T, A>()
    }

    collection_methods!(SmallVec<[T; N]>);
}

impl<T: Send, const N: usize> Collection<T> for SmallVec<[T; N]> {
    fn empty() -> Self {
        SmallVec::new()
    }

    fn add(&mut self, value: T) -> Result<(), Error> {
        self.push(value);
        Ok(())
    }
}

impl<const N: usize> BytesBufImpl for SmallVec<[u8; N]> {
    #[inline]
    fn bytes(&self) -> &[u8] {
        self
    }

    #[inline]
    fn from_vec(bytes: Vec<u8>) -> Result<Self, Error> {
        Ok(SmallVec::from_vec(bytes))
    }

    #[inline]
    fn deserialize_into<'a, 'de>(
        out: &'a mut Option<Self>,
        state: &mut State,
    ) -> SinkHandle<'a, 'de> {
        <Self as Deserialize<'de>>::deserialize_into(out, state)
    }

    fn expecting() -> Cow<'static, str> {
        <Self as Deserialize<'static>>::expecting()
    }
}

encoding_adapter!(
    [const N: usize,] SmallVec<[u8; N]>,
);