aldrin_core/
serialize_key.rs

1use crate::buf_ext::BufMutExt;
2use crate::error::SerializeError;
3use crate::value::ValueKind;
4use bytes::BufMut;
5use uuid::Uuid;
6
7pub trait Sealed: Sized {
8    fn serialize_key<B: BufMut>(self, buf: &mut B) -> Result<(), SerializeError>;
9    fn serialize_map_value_kind<B: BufMut>(buf: &mut B);
10    fn serialize_set_value_kind<B: BufMut>(buf: &mut B);
11}
12
13pub trait SerializeKeyImpl: Sealed {}
14
15pub trait SerializeKey {
16    type Impl<'a>: SerializeKeyImpl
17    where
18        Self: 'a;
19
20    fn as_impl(&self) -> Self::Impl<'_>;
21}
22
23impl Sealed for u8 {
24    fn serialize_key<B: BufMut>(self, buf: &mut B) -> Result<(), SerializeError> {
25        buf.put_u8(self);
26        Ok(())
27    }
28
29    fn serialize_map_value_kind<B: BufMut>(buf: &mut B) {
30        buf.put_discriminant_u8(ValueKind::U8Map);
31    }
32
33    fn serialize_set_value_kind<B: BufMut>(buf: &mut B) {
34        buf.put_discriminant_u8(ValueKind::U8Set);
35    }
36}
37
38impl SerializeKeyImpl for u8 {}
39
40impl SerializeKey for u8 {
41    type Impl<'a> = Self;
42
43    fn as_impl(&self) -> Self::Impl<'_> {
44        *self
45    }
46}
47
48impl Sealed for i8 {
49    fn serialize_key<B: BufMut>(self, buf: &mut B) -> Result<(), SerializeError> {
50        buf.put_i8(self);
51        Ok(())
52    }
53
54    fn serialize_map_value_kind<B: BufMut>(buf: &mut B) {
55        buf.put_discriminant_u8(ValueKind::I8Map);
56    }
57
58    fn serialize_set_value_kind<B: BufMut>(buf: &mut B) {
59        buf.put_discriminant_u8(ValueKind::I8Set);
60    }
61}
62
63impl SerializeKeyImpl for i8 {}
64
65impl SerializeKey for i8 {
66    type Impl<'a> = Self;
67
68    fn as_impl(&self) -> Self::Impl<'_> {
69        *self
70    }
71}
72
73impl Sealed for u16 {
74    fn serialize_key<B: BufMut>(self, buf: &mut B) -> Result<(), SerializeError> {
75        buf.put_varint_u16_le(self);
76        Ok(())
77    }
78
79    fn serialize_map_value_kind<B: BufMut>(buf: &mut B) {
80        buf.put_discriminant_u8(ValueKind::U16Map);
81    }
82
83    fn serialize_set_value_kind<B: BufMut>(buf: &mut B) {
84        buf.put_discriminant_u8(ValueKind::U16Set);
85    }
86}
87
88impl SerializeKeyImpl for u16 {}
89
90impl SerializeKey for u16 {
91    type Impl<'a> = Self;
92
93    fn as_impl(&self) -> Self::Impl<'_> {
94        *self
95    }
96}
97
98impl Sealed for i16 {
99    fn serialize_key<B: BufMut>(self, buf: &mut B) -> Result<(), SerializeError> {
100        buf.put_varint_i16_le(self);
101        Ok(())
102    }
103
104    fn serialize_map_value_kind<B: BufMut>(buf: &mut B) {
105        buf.put_discriminant_u8(ValueKind::I16Map);
106    }
107
108    fn serialize_set_value_kind<B: BufMut>(buf: &mut B) {
109        buf.put_discriminant_u8(ValueKind::I16Set);
110    }
111}
112
113impl SerializeKeyImpl for i16 {}
114
115impl SerializeKey for i16 {
116    type Impl<'a> = Self;
117
118    fn as_impl(&self) -> Self::Impl<'_> {
119        *self
120    }
121}
122
123impl Sealed for u32 {
124    fn serialize_key<B: BufMut>(self, buf: &mut B) -> Result<(), SerializeError> {
125        buf.put_varint_u32_le(self);
126        Ok(())
127    }
128
129    fn serialize_map_value_kind<B: BufMut>(buf: &mut B) {
130        buf.put_discriminant_u8(ValueKind::U32Map);
131    }
132
133    fn serialize_set_value_kind<B: BufMut>(buf: &mut B) {
134        buf.put_discriminant_u8(ValueKind::U32Set);
135    }
136}
137
138impl SerializeKeyImpl for u32 {}
139
140impl SerializeKey for u32 {
141    type Impl<'a> = Self;
142
143    fn as_impl(&self) -> Self::Impl<'_> {
144        *self
145    }
146}
147
148impl Sealed for i32 {
149    fn serialize_key<B: BufMut>(self, buf: &mut B) -> Result<(), SerializeError> {
150        buf.put_varint_i32_le(self);
151        Ok(())
152    }
153
154    fn serialize_map_value_kind<B: BufMut>(buf: &mut B) {
155        buf.put_discriminant_u8(ValueKind::I32Map);
156    }
157
158    fn serialize_set_value_kind<B: BufMut>(buf: &mut B) {
159        buf.put_discriminant_u8(ValueKind::I32Set);
160    }
161}
162
163impl SerializeKeyImpl for i32 {}
164
165impl SerializeKey for i32 {
166    type Impl<'a> = Self;
167
168    fn as_impl(&self) -> Self::Impl<'_> {
169        *self
170    }
171}
172
173impl Sealed for u64 {
174    fn serialize_key<B: BufMut>(self, buf: &mut B) -> Result<(), SerializeError> {
175        buf.put_varint_u64_le(self);
176        Ok(())
177    }
178
179    fn serialize_map_value_kind<B: BufMut>(buf: &mut B) {
180        buf.put_discriminant_u8(ValueKind::U64Map);
181    }
182
183    fn serialize_set_value_kind<B: BufMut>(buf: &mut B) {
184        buf.put_discriminant_u8(ValueKind::U64Set);
185    }
186}
187
188impl SerializeKeyImpl for u64 {}
189
190impl SerializeKey for u64 {
191    type Impl<'a> = Self;
192
193    fn as_impl(&self) -> Self::Impl<'_> {
194        *self
195    }
196}
197
198impl Sealed for i64 {
199    fn serialize_key<B: BufMut>(self, buf: &mut B) -> Result<(), SerializeError> {
200        buf.put_varint_i64_le(self);
201        Ok(())
202    }
203
204    fn serialize_map_value_kind<B: BufMut>(buf: &mut B) {
205        buf.put_discriminant_u8(ValueKind::I64Map);
206    }
207
208    fn serialize_set_value_kind<B: BufMut>(buf: &mut B) {
209        buf.put_discriminant_u8(ValueKind::I64Set);
210    }
211}
212
213impl SerializeKeyImpl for i64 {}
214
215impl SerializeKey for i64 {
216    type Impl<'a> = Self;
217
218    fn as_impl(&self) -> Self::Impl<'_> {
219        *self
220    }
221}
222
223impl Sealed for &str {
224    fn serialize_key<B: BufMut>(self, buf: &mut B) -> Result<(), SerializeError> {
225        if self.len() <= u32::MAX as usize {
226            buf.put_varint_u32_le(self.len() as u32);
227            buf.put_slice(self.as_bytes());
228            Ok(())
229        } else {
230            Err(SerializeError::Overflow)
231        }
232    }
233
234    fn serialize_map_value_kind<B: BufMut>(buf: &mut B) {
235        buf.put_discriminant_u8(ValueKind::StringMap);
236    }
237
238    fn serialize_set_value_kind<B: BufMut>(buf: &mut B) {
239        buf.put_discriminant_u8(ValueKind::StringSet);
240    }
241}
242
243impl SerializeKeyImpl for &str {}
244
245impl SerializeKey for &str {
246    type Impl<'a>
247        = Self
248    where
249        Self: 'a;
250
251    fn as_impl(&self) -> Self::Impl<'_> {
252        self
253    }
254}
255
256impl Sealed for Uuid {
257    fn serialize_key<B: BufMut>(self, buf: &mut B) -> Result<(), SerializeError> {
258        buf.put_slice(self.as_bytes());
259        Ok(())
260    }
261
262    fn serialize_map_value_kind<B: BufMut>(buf: &mut B) {
263        buf.put_discriminant_u8(ValueKind::UuidMap);
264    }
265
266    fn serialize_set_value_kind<B: BufMut>(buf: &mut B) {
267        buf.put_discriminant_u8(ValueKind::UuidSet);
268    }
269}
270
271impl SerializeKeyImpl for Uuid {}
272
273impl SerializeKey for Uuid {
274    type Impl<'a> = Self;
275
276    fn as_impl(&self) -> Self::Impl<'_> {
277        *self
278    }
279}
280
281impl<T: SerializeKey + ?Sized> SerializeKey for &T {
282    type Impl<'a>
283        = T::Impl<'a>
284    where
285        Self: 'a;
286
287    fn as_impl(&self) -> Self::Impl<'_> {
288        (**self).as_impl()
289    }
290}
291
292impl<T: SerializeKey + ?Sized> SerializeKey for &mut T {
293    type Impl<'a>
294        = T::Impl<'a>
295    where
296        Self: 'a;
297
298    fn as_impl(&self) -> Self::Impl<'_> {
299        (**self).as_impl()
300    }
301}
302
303impl<T: SerializeKey + ?Sized> SerializeKey for Box<T> {
304    type Impl<'a>
305        = T::Impl<'a>
306    where
307        Self: 'a;
308
309    fn as_impl(&self) -> Self::Impl<'_> {
310        (**self).as_impl()
311    }
312}
313
314impl SerializeKey for String {
315    type Impl<'a> = &'a str;
316
317    fn as_impl(&self) -> Self::Impl<'_> {
318        self
319    }
320}
aldrin_core/serialize_key.rs

aldrin_core/
serialize_key.rs
