aldrin_core/
value.rs

1#[cfg(test)]
2mod test;
3
4use crate::deserialize_key::DeserializeKey;
5use crate::error::{DeserializeError, SerializeError};
6use crate::serialize_key::SerializeKey;
7use crate::value_deserializer::{Deserialize, Deserializer};
8use crate::value_serializer::{Serialize, Serializer};
9use num_enum::{IntoPrimitive, TryFromPrimitive};
10use std::borrow::{Borrow, Cow};
11use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, LinkedList, VecDeque};
12use std::convert::Infallible;
13use std::hash::{BuildHasher, Hash};
14use std::mem::MaybeUninit;
15use std::ops::Deref;
16use uuid::Uuid;
17
18#[derive(
19    Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, IntoPrimitive, TryFromPrimitive,
20)]
21#[repr(u8)]
22pub enum ValueKind {
23    None = 0,
24    Some = 1,
25    Bool = 2,
26    U8 = 3,
27    I8 = 4,
28    U16 = 5,
29    I16 = 6,
30    U32 = 7,
31    I32 = 8,
32    U64 = 9,
33    I64 = 10,
34    F32 = 11,
35    F64 = 12,
36    String = 13,
37    Uuid = 14,
38    ObjectId = 15,
39    ServiceId = 16,
40    Vec = 17,
41    Bytes = 18,
42    U8Map = 19,
43    I8Map = 20,
44    U16Map = 21,
45    I16Map = 22,
46    U32Map = 23,
47    I32Map = 24,
48    U64Map = 25,
49    I64Map = 26,
50    StringMap = 27,
51    UuidMap = 28,
52    U8Set = 29,
53    I8Set = 30,
54    U16Set = 31,
55    I16Set = 32,
56    U32Set = 33,
57    I32Set = 34,
58    U64Set = 35,
59    I64Set = 36,
60    StringSet = 37,
61    UuidSet = 38,
62    Struct = 39,
63    Enum = 40,
64    Sender = 41,
65    Receiver = 42,
66}
67
68/// Wrapper for `Vec<u8>` to enable `Serialize` and `Deserialize` specializations.
69#[derive(Debug, Clone, PartialEq, Eq)]
70pub struct Bytes(pub Vec<u8>);
71
72impl Bytes {
73    pub fn new<T: Into<Vec<u8>>>(bytes: T) -> Self {
74        Self(bytes.into())
75    }
76}
77
78impl Deref for Bytes {
79    type Target = ByteSlice;
80
81    fn deref(&self) -> &ByteSlice {
82        ByteSlice::new(&self.0)
83    }
84}
85
86impl AsRef<ByteSlice> for Bytes {
87    fn as_ref(&self) -> &ByteSlice {
88        self
89    }
90}
91
92impl Borrow<ByteSlice> for Bytes {
93    fn borrow(&self) -> &ByteSlice {
94        self
95    }
96}
97
98impl AsRef<[u8]> for Bytes {
99    fn as_ref(&self) -> &[u8] {
100        self
101    }
102}
103
104impl From<Vec<u8>> for Bytes {
105    fn from(bytes: Vec<u8>) -> Self {
106        Bytes(bytes)
107    }
108}
109
110impl From<Bytes> for Vec<u8> {
111    fn from(bytes: Bytes) -> Self {
112        bytes.0
113    }
114}
115
116impl PartialEq<ByteSlice> for Bytes {
117    fn eq(&self, other: &ByteSlice) -> bool {
118        **self == *other
119    }
120}
121
122impl PartialEq<[u8]> for Bytes {
123    fn eq(&self, other: &[u8]) -> bool {
124        **self == *other
125    }
126}
127
128impl PartialEq<Bytes> for [u8] {
129    fn eq(&self, other: &Bytes) -> bool {
130        *self == ***other
131    }
132}
133
134impl Serialize for Bytes {
135    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
136        (**self).serialize(serializer)
137    }
138}
139
140impl Deserialize for Bytes {
141    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
142        deserializer.deserialize_bytes_to_vec().map(Bytes)
143    }
144}
145
146/// Wrapper for `[u8]` to enable `Serialize` and `Deserialize` specializations.
147#[derive(Debug, PartialEq, Eq)]
148#[repr(transparent)]
149pub struct ByteSlice(pub [u8]);
150
151impl ByteSlice {
152    pub fn new<T: AsRef<[u8]> + ?Sized>(bytes: &T) -> &Self {
153        let self_ptr = bytes.as_ref() as *const [u8] as *const Self;
154        // Safe because of repr(transparent).
155        unsafe { &*self_ptr }
156    }
157}
158
159impl Deref for ByteSlice {
160    type Target = [u8];
161
162    fn deref(&self) -> &[u8] {
163        &self.0
164    }
165}
166
167impl AsRef<[u8]> for ByteSlice {
168    fn as_ref(&self) -> &[u8] {
169        self
170    }
171}
172
173impl AsRef<ByteSlice> for [u8] {
174    fn as_ref(&self) -> &ByteSlice {
175        ByteSlice::new(self)
176    }
177}
178
179impl ToOwned for ByteSlice {
180    type Owned = Bytes;
181
182    fn to_owned(&self) -> Bytes {
183        Bytes::new(&self.0)
184    }
185}
186
187impl PartialEq<Bytes> for ByteSlice {
188    fn eq(&self, other: &Bytes) -> bool {
189        *self == **other
190    }
191}
192
193impl PartialEq<[u8]> for ByteSlice {
194    fn eq(&self, other: &[u8]) -> bool {
195        **self == *other
196    }
197}
198
199impl PartialEq<ByteSlice> for [u8] {
200    fn eq(&self, other: &ByteSlice) -> bool {
201        *self == **other
202    }
203}
204
205impl Serialize for ByteSlice {
206    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
207        serializer.serialize_byte_slice(self)
208    }
209}
210
211/// Empty value that deserializes from everything by skipping over it.
212#[derive(Debug, Clone, Copy, PartialEq, Eq)]
213pub struct Skip;
214
215impl Deserialize for Skip {
216    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
217        deserializer.skip().map(|_| Self)
218    }
219}
220
221impl<T: Serialize + ?Sized> Serialize for &T {
222    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
223        (**self).serialize(serializer)
224    }
225}
226
227impl<T: Serialize + ?Sized> Serialize for &mut T {
228    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
229        (**self).serialize(serializer)
230    }
231}
232
233impl<T: Serialize + ?Sized> Serialize for Box<T> {
234    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
235        (**self).serialize(serializer)
236    }
237}
238
239impl<T: Deserialize> Deserialize for Box<T> {
240    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
241        T::deserialize(deserializer).map(Box::new)
242    }
243}
244
245impl Serialize for () {
246    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
247        serializer.serialize_none();
248        Ok(())
249    }
250}
251
252impl Deserialize for () {
253    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
254        deserializer.deserialize_none()
255    }
256}
257
258impl<T: Serialize> Serialize for Option<T> {
259    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
260        match self {
261            Some(value) => serializer.serialize_some(value)?,
262            None => serializer.serialize_none(),
263        }
264
265        Ok(())
266    }
267}
268
269impl<T: Deserialize> Deserialize for Option<T> {
270    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
271        deserializer.deserialize_option()
272    }
273}
274
275impl Serialize for bool {
276    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
277        serializer.serialize_bool(*self);
278        Ok(())
279    }
280}
281
282impl Deserialize for bool {
283    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
284        deserializer.deserialize_bool()
285    }
286}
287
288impl Serialize for u8 {
289    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
290        serializer.serialize_u8(*self);
291        Ok(())
292    }
293}
294
295impl Deserialize for u8 {
296    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
297        deserializer.deserialize_u8()
298    }
299}
300
301impl Serialize for i8 {
302    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
303        serializer.serialize_i8(*self);
304        Ok(())
305    }
306}
307
308impl Deserialize for i8 {
309    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
310        deserializer.deserialize_i8()
311    }
312}
313
314impl Serialize for u16 {
315    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
316        serializer.serialize_u16(*self);
317        Ok(())
318    }
319}
320
321impl Deserialize for u16 {
322    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
323        deserializer.deserialize_u16()
324    }
325}
326
327impl Serialize for i16 {
328    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
329        serializer.serialize_i16(*self);
330        Ok(())
331    }
332}
333
334impl Deserialize for i16 {
335    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
336        deserializer.deserialize_i16()
337    }
338}
339
340impl Serialize for u32 {
341    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
342        serializer.serialize_u32(*self);
343        Ok(())
344    }
345}
346
347impl Deserialize for u32 {
348    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
349        deserializer.deserialize_u32()
350    }
351}
352
353impl Serialize for i32 {
354    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
355        serializer.serialize_i32(*self);
356        Ok(())
357    }
358}
359
360impl Deserialize for i32 {
361    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
362        deserializer.deserialize_i32()
363    }
364}
365
366impl Serialize for u64 {
367    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
368        serializer.serialize_u64(*self);
369        Ok(())
370    }
371}
372
373impl Deserialize for u64 {
374    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
375        deserializer.deserialize_u64()
376    }
377}
378
379impl Serialize for i64 {
380    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
381        serializer.serialize_i64(*self);
382        Ok(())
383    }
384}
385
386impl Deserialize for i64 {
387    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
388        deserializer.deserialize_i64()
389    }
390}
391
392impl Serialize for f32 {
393    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
394        serializer.serialize_f32(*self);
395        Ok(())
396    }
397}
398
399impl Deserialize for f32 {
400    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
401        deserializer.deserialize_f32()
402    }
403}
404
405impl Serialize for f64 {
406    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
407        serializer.serialize_f64(*self);
408        Ok(())
409    }
410}
411
412impl Deserialize for f64 {
413    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
414        deserializer.deserialize_f64()
415    }
416}
417
418impl Serialize for str {
419    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
420        serializer.serialize_string(self)
421    }
422}
423
424impl Serialize for String {
425    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
426        serializer.serialize_string(self)
427    }
428}
429
430impl Deserialize for String {
431    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
432        deserializer.deserialize_string()
433    }
434}
435
436impl Serialize for Uuid {
437    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
438        serializer.serialize_uuid(*self);
439        Ok(())
440    }
441}
442
443impl Deserialize for Uuid {
444    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
445        deserializer.deserialize_uuid()
446    }
447}
448
449impl<T: Serialize> Serialize for Vec<T> {
450    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
451        serializer.serialize_vec_iter(self)
452    }
453}
454
455impl<T: Deserialize> Deserialize for Vec<T> {
456    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
457        deserializer.deserialize_vec_extend_new()
458    }
459}
460
461impl<T: Serialize> Serialize for VecDeque<T> {
462    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
463        serializer.serialize_vec_iter(self)
464    }
465}
466
467impl<T: Deserialize> Deserialize for VecDeque<T> {
468    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
469        deserializer.deserialize_vec_extend_new()
470    }
471}
472
473impl<T: Serialize> Serialize for LinkedList<T> {
474    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
475        serializer.serialize_vec_iter(self)
476    }
477}
478
479impl<T: Deserialize> Deserialize for LinkedList<T> {
480    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
481        deserializer.deserialize_vec_extend_new()
482    }
483}
484
485impl<T: Serialize> Serialize for [T] {
486    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
487        serializer.serialize_vec_iter(self)
488    }
489}
490
491impl<T: Serialize, const N: usize> Serialize for [T; N] {
492    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
493        serializer.serialize_vec_iter(self)
494    }
495}
496
497impl<T: Deserialize, const N: usize> Deserialize for [T; N] {
498    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
499        let mut deserializer = deserializer.deserialize_vec()?;
500
501        if deserializer.remaining_elements() != N {
502            return Err(DeserializeError::UnexpectedValue);
503        }
504
505        // SAFETY: This create an array of MaybeUninit<T>, which don't require initialization.
506        let mut arr: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
507
508        // Manually count number of elements, so that the safety of this function doesn't depend on
509        // the correctness of VecDeserializer.
510        let mut num = 0;
511
512        for elem in &mut arr {
513            match deserializer.deserialize_element() {
514                Ok(value) => {
515                    elem.write(value);
516                    num += 1;
517                }
518
519                Err(e) => {
520                    for elem in &mut arr[..num] {
521                        // SAFETY: The first num elements have been initialized.
522                        unsafe {
523                            elem.assume_init_drop();
524                        }
525                    }
526
527                    return Err(e);
528                }
529            }
530        }
531
532        // Panic, because this would indicate a bug in this crate.
533        assert_eq!(num, N);
534
535        // SAFETY: Exactly num elements have been and num equals N.
536        //
537        // It's currently impossible to transmute [MaybeUninit<T>; N] to [T; N] when T is a generic
538        // or N a const generic. See https://github.com/rust-lang/rust/issues/61956.
539        let value = unsafe {
540            (*(&MaybeUninit::new(arr) as *const _ as *const MaybeUninit<[T; N]>)).assume_init_read()
541        };
542
543        Ok(value)
544    }
545}
546
547impl Serialize for bytes::Bytes {
548    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
549        serializer.serialize_byte_slice(self)
550    }
551}
552
553impl Deserialize for bytes::Bytes {
554    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
555        deserializer
556            .deserialize_bytes_to_vec()
557            .map(bytes::Bytes::from)
558    }
559}
560
561impl Serialize for bytes::BytesMut {
562    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
563        serializer.serialize_byte_slice(self)
564    }
565}
566
567impl Deserialize for bytes::BytesMut {
568    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
569        // This is inefficient, but bytes doesn't currently offer a better alternative.
570        let vec = deserializer.deserialize_bytes_to_vec()?;
571        Ok(bytes::BytesMut::from(vec.as_slice()))
572    }
573}
574
575impl<K: SerializeKey, V: Serialize, S> Serialize for HashMap<K, V, S> {
576    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
577        serializer.serialize_map_iter(self)
578    }
579}
580
581impl<K, V, S> Deserialize for HashMap<K, V, S>
582where
583    K: DeserializeKey + Eq + Hash,
584    V: Deserialize,
585    S: BuildHasher + Default,
586{
587    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
588        deserializer.deserialize_map_extend_new()
589    }
590}
591
592impl<K: SerializeKey, V: Serialize> Serialize for BTreeMap<K, V> {
593    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
594        serializer.serialize_map_iter(self)
595    }
596}
597
598impl<K: DeserializeKey + Ord, V: Deserialize> Deserialize for BTreeMap<K, V> {
599    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
600        deserializer.deserialize_map_extend_new()
601    }
602}
603
604impl<T: SerializeKey, S> Serialize for HashSet<T, S> {
605    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
606        serializer.serialize_set_iter(self)
607    }
608}
609
610impl<T, S> Deserialize for HashSet<T, S>
611where
612    T: DeserializeKey + Eq + Hash,
613    S: BuildHasher + Default,
614{
615    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
616        deserializer.deserialize_set_extend_new()
617    }
618}
619
620impl<T: SerializeKey> Serialize for BTreeSet<T> {
621    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
622        serializer.serialize_set_iter(self)
623    }
624}
625
626impl<T: DeserializeKey + Ord> Deserialize for BTreeSet<T> {
627    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
628        deserializer.deserialize_set_extend_new()
629    }
630}
631
632impl<'a, T> Serialize for Cow<'a, T>
633where
634    T: Serialize + ToOwned + ?Sized + 'a,
635{
636    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
637        match self {
638            Cow::Borrowed(borrowed) => borrowed.serialize(serializer),
639            Cow::Owned(owned) => owned.borrow().serialize(serializer),
640        }
641    }
642}
643
644impl<'a, T> Deserialize for Cow<'a, T>
645where
646    T: ToOwned + ?Sized + 'a,
647    T::Owned: Deserialize,
648{
649    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
650        T::Owned::deserialize(deserializer).map(Self::Owned)
651    }
652}
653
654impl<T, E> Serialize for Result<T, E>
655where
656    T: Serialize,
657    E: Serialize,
658{
659    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
660        match self {
661            Ok(ok) => serializer.serialize_enum(0, ok),
662            Err(err) => serializer.serialize_enum(1, err),
663        }
664    }
665}
666
667impl<T, E> Deserialize for Result<T, E>
668where
669    T: Deserialize,
670    E: Deserialize,
671{
672    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
673        let deserializer = deserializer.deserialize_enum()?;
674
675        match deserializer.variant() {
676            0 => deserializer.deserialize().map(Ok),
677            1 => deserializer.deserialize().map(Err),
678            _ => Err(DeserializeError::InvalidSerialization),
679        }
680    }
681}
682
683impl Serialize for Infallible {
684    fn serialize(&self, _serializer: Serializer) -> Result<(), SerializeError> {
685        match *self {}
686    }
687}
688
689impl Deserialize for Infallible {
690    fn deserialize(_deserializer: Deserializer) -> Result<Self, DeserializeError> {
691        Err(DeserializeError::UnexpectedValue)
692    }
693}
aldrin_core/value.rs

aldrin_core/
value.rs
