aldrin_core/serializer/
map.rs

1use super::Serializer;
2use crate::buf_ext::BufMutExt;
3use crate::tags::{KeyTag, KeyTagImpl, Tag};
4use crate::{Serialize, SerializeError, SerializeKey, ValueKind};
5use bytes::BytesMut;
6use std::fmt;
7use std::marker::PhantomData;
8
9pub struct Map1Serializer<'a, K> {
10    buf: &'a mut BytesMut,
11    num_elems: u32,
12    depth: u8,
13    _key: PhantomData<K>,
14}
15
16impl<'a, K: KeyTag> Map1Serializer<'a, K> {
17    pub(super) fn new(
18        buf: &'a mut BytesMut,
19        num_elems: usize,
20        depth: u8,
21    ) -> Result<Self, SerializeError> {
22        if num_elems <= u32::MAX as usize {
23            buf.put_discriminant_u8(K::Impl::VALUE_KIND_MAP1);
24            buf.put_varint_u32_le(num_elems as u32);
25
26            Ok(Self {
27                buf,
28                num_elems: num_elems as u32,
29                depth,
30                _key: PhantomData,
31            })
32        } else {
33            Err(SerializeError::Overflow)
34        }
35    }
36
37    pub fn remaining_elements(&self) -> usize {
38        self.num_elems as usize
39    }
40
41    pub fn requires_additional_elements(&self) -> bool {
42        self.num_elems > 0
43    }
44
45    pub fn serialize<T: Tag>(
46        &mut self,
47        key: &(impl SerializeKey<K> + ?Sized),
48        value: impl Serialize<T>,
49    ) -> Result<&mut Self, SerializeError> {
50        if self.num_elems > 0 {
51            self.num_elems -= 1;
52
53            K::Impl::serialize_key(key.try_as_key()?, self.buf)?;
54
55            let serializer = Serializer::new(self.buf, self.depth)?;
56            serializer.serialize(value)?;
57
58            Ok(self)
59        } else {
60            Err(SerializeError::TooManyElements)
61        }
62    }
63
64    pub fn finish(self) -> Result<(), SerializeError> {
65        if self.num_elems == 0 {
66            Ok(())
67        } else {
68            Err(SerializeError::TooFewElements)
69        }
70    }
71}
72
73impl<K> fmt::Debug for Map1Serializer<'_, K> {
74    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
75        let mut f = f.debug_struct("Map1Serializer");
76
77        f.field("buf", &self.buf);
78        f.field("num_elems", &self.num_elems);
79        f.field("depth", &self.depth);
80
81        f.finish()
82    }
83}
84
85pub struct Map2Serializer<'a, K> {
86    buf: &'a mut BytesMut,
87    depth: u8,
88    _key: PhantomData<K>,
89}
90
91impl<'a, K: KeyTag> Map2Serializer<'a, K> {
92    pub(super) fn new(buf: &'a mut BytesMut, depth: u8) -> Result<Self, SerializeError> {
93        buf.put_discriminant_u8(K::Impl::VALUE_KIND_MAP2);
94
95        Ok(Self {
96            buf,
97            depth,
98            _key: PhantomData,
99        })
100    }
101
102    pub fn serialize<T: Tag>(
103        &mut self,
104        key: &(impl SerializeKey<K> + ?Sized),
105        value: impl Serialize<T>,
106    ) -> Result<&mut Self, SerializeError> {
107        self.buf.put_discriminant_u8(ValueKind::Some);
108
109        K::Impl::serialize_key(key.try_as_key()?, self.buf)?;
110
111        let serializer = Serializer::new(self.buf, self.depth)?;
112        serializer.serialize(value)?;
113
114        Ok(self)
115    }
116
117    pub fn finish(self) -> Result<(), SerializeError> {
118        self.buf.put_discriminant_u8(ValueKind::None);
119        Ok(())
120    }
121}
122
123impl<K> fmt::Debug for Map2Serializer<'_, K> {
124    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
125        let mut f = f.debug_struct("Map2Serializer");
126
127        f.field("buf", &self.buf);
128        f.field("depth", &self.depth);
129
130        f.finish()
131    }
132}
aldrin_core/serializer/map.rs

aldrin_core/serializer/
map.rs
