musli 0.1.6

Müsli is a flexible and efficient serialization framework.
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use core::marker::PhantomData;

use crate::en::{EntriesEncoder, MapEncoder};
use crate::writer::BufWriter;
use crate::{Context, Writer};

use super::super::tag::OBJECT;
use super::{JsonbEncoder, JsonbObjectKeyEncoder, JsonbObjectPairEncoder, finish_container};

/// An object encoder for JSONB.
///
/// Just like for arrays the payload has to be buffered, since the header of an
/// object stores the size of its payload.
pub(crate) struct JsonbObjectEncoder<W, C, M>
where
    C: Context,
{
    cx: C,
    writer: W,
    variant: Option<BufWriter<C::Allocator>>,
    buffer: BufWriter<C::Allocator>,
    _marker: PhantomData<M>,
}

impl<W, C, M> JsonbObjectEncoder<W, C, M>
where
    W: Writer,
    C: Context,
    M: 'static,
{
    #[inline]
    pub(super) fn new(cx: C, writer: W) -> Self {
        Self {
            cx,
            writer,
            variant: None,
            buffer: BufWriter::new(cx.alloc()),
            _marker: PhantomData,
        }
    }

    /// Construct an object encoder which wraps the object in the single entry
    /// object whose key `variant` already contains. This is how an externally
    /// tagged map variant is encoded.
    #[inline]
    pub(super) fn with_variant(cx: C, writer: W, variant: BufWriter<C::Allocator>) -> Self {
        Self {
            cx,
            writer,
            variant: Some(variant),
            buffer: BufWriter::new(cx.alloc()),
            _marker: PhantomData,
        }
    }

    #[inline]
    fn finish(self) -> Result<(), C::Error> {
        finish_container(self.cx, self.writer, self.variant, self.buffer, OBJECT)
    }
}

impl<W, C, M> MapEncoder for JsonbObjectEncoder<W, C, M>
where
    W: Writer,
    C: Context,
    M: 'static,
{
    type Cx = C;
    type Error = C::Error;
    type Mode = M;
    type EncodeEntry<'this>
        = JsonbObjectPairEncoder<&'this mut BufWriter<C::Allocator>, C, M>
    where
        Self: 'this;

    #[inline]
    fn cx(&self) -> Self::Cx {
        self.cx
    }

    #[inline]
    fn encode_entry(&mut self) -> Result<Self::EncodeEntry<'_>, Self::Error> {
        Ok(JsonbObjectPairEncoder::new(self.cx, &mut self.buffer))
    }

    #[inline]
    fn finish_map(self) -> Result<(), Self::Error> {
        self.finish()
    }
}

impl<W, C, M> EntriesEncoder for JsonbObjectEncoder<W, C, M>
where
    W: Writer,
    C: Context,
    M: 'static,
{
    type Cx = C;
    type Error = C::Error;
    type Mode = M;
    type EncodeEntryKey<'this>
        = JsonbObjectKeyEncoder<&'this mut BufWriter<C::Allocator>, C, M>
    where
        Self: 'this;
    type EncodeEntryValue<'this>
        = JsonbEncoder<&'this mut BufWriter<C::Allocator>, C, M>
    where
        Self: 'this;

    #[inline]
    fn cx(&self) -> Self::Cx {
        self.cx
    }

    #[inline]
    fn encode_entry_key(&mut self) -> Result<Self::EncodeEntryKey<'_>, Self::Error> {
        Ok(JsonbObjectKeyEncoder::new(self.cx, &mut self.buffer))
    }

    #[inline]
    fn encode_entry_value(&mut self) -> Result<Self::EncodeEntryValue<'_>, Self::Error> {
        Ok(JsonbEncoder::new(self.cx, &mut self.buffer))
    }

    #[inline]
    fn finish_entries(self) -> Result<(), Self::Error> {
        self.finish()
    }
}