aldrin_core/
value.rs

1#[cfg(test)]
2mod test;
3
4use crate::deserialize_key::DeserializeKey;
5use crate::error::{DeserializeError, SerializeError};
6#[cfg(feature = "introspection")]
7use crate::introspection::{
8    ArrayType, BuiltInType, DynIntrospectable, Introspectable, KeyTypeOf, Layout, LexicalId,
9    MapType, References, ResultType, Struct,
10};
11use crate::serialize_key::SerializeKey;
12use crate::value_deserializer::{Deserialize, Deserializer};
13use crate::value_serializer::{AsSerializeArg, Serialize, Serializer};
14use num_enum::{IntoPrimitive, TryFromPrimitive};
15use std::borrow::{Borrow, Cow};
16use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, LinkedList, VecDeque};
17use std::convert::Infallible;
18use std::hash::{BuildHasher, Hash};
19use std::mem::MaybeUninit;
20use std::ops::Deref;
21use uuid::Uuid;
22
23#[derive(
24    Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, IntoPrimitive, TryFromPrimitive,
25)]
26#[repr(u8)]
27pub enum ValueKind {
28    None = 0,
29    Some = 1,
30    Bool = 2,
31    U8 = 3,
32    I8 = 4,
33    U16 = 5,
34    I16 = 6,
35    U32 = 7,
36    I32 = 8,
37    U64 = 9,
38    I64 = 10,
39    F32 = 11,
40    F64 = 12,
41    String = 13,
42    Uuid = 14,
43    ObjectId = 15,
44    ServiceId = 16,
45    Vec = 17,
46    Bytes = 18,
47    U8Map = 19,
48    I8Map = 20,
49    U16Map = 21,
50    I16Map = 22,
51    U32Map = 23,
52    I32Map = 24,
53    U64Map = 25,
54    I64Map = 26,
55    StringMap = 27,
56    UuidMap = 28,
57    U8Set = 29,
58    I8Set = 30,
59    U16Set = 31,
60    I16Set = 32,
61    U32Set = 33,
62    I32Set = 34,
63    U64Set = 35,
64    I64Set = 36,
65    StringSet = 37,
66    UuidSet = 38,
67    Struct = 39,
68    Enum = 40,
69    Sender = 41,
70    Receiver = 42,
71}
72
73/// Wrapper for `Vec<u8>` to enable `Serialize` and `Deserialize` specializations.
74#[derive(Debug, Clone, PartialEq, Eq)]
75#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
76#[cfg_attr(
77    feature = "serde",
78    derive(serde::Serialize, serde::Deserialize),
79    serde(transparent)
80)]
81pub struct Bytes(pub Vec<u8>);
82
83impl Bytes {
84    pub fn new<T: Into<Vec<u8>>>(bytes: T) -> Self {
85        Self(bytes.into())
86    }
87}
88
89impl Deref for Bytes {
90    type Target = ByteSlice;
91
92    fn deref(&self) -> &ByteSlice {
93        ByteSlice::new(&self.0)
94    }
95}
96
97impl AsRef<ByteSlice> for Bytes {
98    fn as_ref(&self) -> &ByteSlice {
99        self
100    }
101}
102
103impl Borrow<ByteSlice> for Bytes {
104    fn borrow(&self) -> &ByteSlice {
105        self
106    }
107}
108
109impl AsRef<[u8]> for Bytes {
110    fn as_ref(&self) -> &[u8] {
111        self
112    }
113}
114
115impl From<Vec<u8>> for Bytes {
116    fn from(bytes: Vec<u8>) -> Self {
117        Self(bytes)
118    }
119}
120
121impl From<Bytes> for Vec<u8> {
122    fn from(bytes: Bytes) -> Self {
123        bytes.0
124    }
125}
126
127impl PartialEq<ByteSlice> for Bytes {
128    fn eq(&self, other: &ByteSlice) -> bool {
129        **self == *other
130    }
131}
132
133impl PartialEq<[u8]> for Bytes {
134    fn eq(&self, other: &[u8]) -> bool {
135        **self == *other
136    }
137}
138
139impl PartialEq<Bytes> for [u8] {
140    fn eq(&self, other: &Bytes) -> bool {
141        *self == ***other
142    }
143}
144
145impl Serialize for Bytes {
146    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
147        (**self).serialize(serializer)
148    }
149}
150
151impl Deserialize for Bytes {
152    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
153        deserializer.deserialize_bytes_to_vec().map(Bytes)
154    }
155}
156
157impl AsSerializeArg for Bytes {
158    type SerializeArg<'a> = &'a ByteSlice;
159
160    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
161    where
162        Self: 'a,
163    {
164        self
165    }
166}
167
168#[cfg(feature = "introspection")]
169impl Introspectable for Bytes {
170    fn layout() -> Layout {
171        BuiltInType::Bytes.into()
172    }
173
174    fn lexical_id() -> LexicalId {
175        LexicalId::BYTES
176    }
177
178    fn add_references(_references: &mut References) {}
179}
180
181/// Wrapper for `[u8]` to enable `Serialize` and `Deserialize` specializations.
182#[derive(Debug, PartialEq, Eq)]
183#[repr(transparent)]
184pub struct ByteSlice(pub [u8]);
185
186impl ByteSlice {
187    pub fn new<T: AsRef<[u8]> + ?Sized>(bytes: &T) -> &Self {
188        let self_ptr = bytes.as_ref() as *const [u8] as *const Self;
189        // Safe because of repr(transparent).
190        unsafe { &*self_ptr }
191    }
192}
193
194impl Deref for ByteSlice {
195    type Target = [u8];
196
197    fn deref(&self) -> &[u8] {
198        &self.0
199    }
200}
201
202impl AsRef<[u8]> for ByteSlice {
203    fn as_ref(&self) -> &[u8] {
204        self
205    }
206}
207
208impl AsRef<ByteSlice> for [u8] {
209    fn as_ref(&self) -> &ByteSlice {
210        ByteSlice::new(self)
211    }
212}
213
214impl<'a, T: AsRef<[u8]>> From<&'a T> for &'a ByteSlice {
215    fn from(bytes: &'a T) -> Self {
216        ByteSlice::new(bytes)
217    }
218}
219
220impl ToOwned for ByteSlice {
221    type Owned = Bytes;
222
223    fn to_owned(&self) -> Bytes {
224        Bytes::new(&self.0)
225    }
226}
227
228impl PartialEq<Bytes> for ByteSlice {
229    fn eq(&self, other: &Bytes) -> bool {
230        *self == **other
231    }
232}
233
234impl PartialEq<[u8]> for ByteSlice {
235    fn eq(&self, other: &[u8]) -> bool {
236        **self == *other
237    }
238}
239
240impl PartialEq<ByteSlice> for [u8] {
241    fn eq(&self, other: &ByteSlice) -> bool {
242        *self == **other
243    }
244}
245
246impl Serialize for ByteSlice {
247    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
248        serializer.serialize_byte_slice(self)
249    }
250}
251
252impl AsSerializeArg for ByteSlice {
253    type SerializeArg<'a> = &'a Self;
254
255    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
256    where
257        Self: 'a,
258    {
259        self
260    }
261}
262
263#[cfg(feature = "introspection")]
264impl Introspectable for ByteSlice {
265    fn layout() -> Layout {
266        BuiltInType::Bytes.into()
267    }
268
269    fn lexical_id() -> LexicalId {
270        LexicalId::BYTES
271    }
272
273    fn add_references(_references: &mut References) {}
274}
275
276/// Empty value that deserializes from everything by skipping over it.
277#[derive(Debug, Clone, Copy, PartialEq, Eq)]
278pub struct Skip;
279
280impl Deserialize for Skip {
281    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
282        deserializer.skip().map(|_| Self)
283    }
284}
285
286impl<T: Serialize + ?Sized> Serialize for &T {
287    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
288        (**self).serialize(serializer)
289    }
290}
291
292impl<T: AsSerializeArg + ?Sized> AsSerializeArg for &T {
293    type SerializeArg<'a>
294        = T::SerializeArg<'a>
295    where
296        Self: 'a;
297
298    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
299    where
300        Self: 'a,
301    {
302        (**self).as_serialize_arg()
303    }
304}
305
306#[cfg(feature = "introspection")]
307impl<T: Introspectable + ?Sized> Introspectable for &T {
308    fn layout() -> Layout {
309        BuiltInType::Box(T::lexical_id()).into()
310    }
311
312    fn lexical_id() -> LexicalId {
313        LexicalId::box_ty(T::lexical_id())
314    }
315
316    fn add_references(references: &mut References) {
317        references.add::<T>();
318    }
319}
320
321impl<T: Serialize + ?Sized> Serialize for &mut T {
322    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
323        (**self).serialize(serializer)
324    }
325}
326
327impl<T: AsSerializeArg + ?Sized> AsSerializeArg for &mut T {
328    type SerializeArg<'a>
329        = T::SerializeArg<'a>
330    where
331        Self: 'a;
332
333    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
334    where
335        Self: 'a,
336    {
337        (**self).as_serialize_arg()
338    }
339}
340
341#[cfg(feature = "introspection")]
342impl<T: Introspectable + ?Sized> Introspectable for &mut T {
343    fn layout() -> Layout {
344        BuiltInType::Box(T::lexical_id()).into()
345    }
346
347    fn lexical_id() -> LexicalId {
348        LexicalId::box_ty(T::lexical_id())
349    }
350
351    fn add_references(references: &mut References) {
352        references.add::<T>();
353    }
354}
355
356impl<T: Serialize + ?Sized> Serialize for Box<T> {
357    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
358        (**self).serialize(serializer)
359    }
360}
361
362impl<T: Deserialize> Deserialize for Box<T> {
363    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
364        T::deserialize(deserializer).map(Self::new)
365    }
366}
367
368impl<T: AsSerializeArg + ?Sized> AsSerializeArg for Box<T> {
369    type SerializeArg<'a>
370        = T::SerializeArg<'a>
371    where
372        Self: 'a;
373
374    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
375    where
376        Self: 'a,
377    {
378        (**self).as_serialize_arg()
379    }
380}
381
382#[cfg(feature = "introspection")]
383impl<T: Introspectable + ?Sized> Introspectable for Box<T> {
384    fn layout() -> Layout {
385        BuiltInType::Box(T::lexical_id()).into()
386    }
387
388    fn lexical_id() -> LexicalId {
389        LexicalId::box_ty(T::lexical_id())
390    }
391
392    fn add_references(references: &mut References) {
393        references.add::<T>();
394    }
395}
396
397impl Serialize for () {
398    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
399        serializer.serialize_none();
400        Ok(())
401    }
402}
403
404impl Deserialize for () {
405    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
406        deserializer.deserialize_none()
407    }
408}
409
410impl AsSerializeArg for () {
411    type SerializeArg<'a> = Self;
412
413    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
414    where
415        Self: 'a,
416    {
417    }
418}
419
420#[cfg(feature = "introspection")]
421impl Introspectable for () {
422    fn layout() -> Layout {
423        BuiltInType::Unit.into()
424    }
425
426    fn lexical_id() -> LexicalId {
427        LexicalId::UNIT
428    }
429
430    fn add_references(_references: &mut References) {}
431}
432
433impl<T: Serialize> Serialize for Option<T> {
434    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
435        match self {
436            Some(value) => serializer.serialize_some(value)?,
437            None => serializer.serialize_none(),
438        }
439
440        Ok(())
441    }
442}
443
444impl<T: Deserialize> Deserialize for Option<T> {
445    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
446        deserializer.deserialize_option()
447    }
448}
449
450impl<T: AsSerializeArg> AsSerializeArg for Option<T> {
451    type SerializeArg<'a>
452        = Option<T::SerializeArg<'a>>
453    where
454        Self: 'a;
455
456    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
457    where
458        Self: 'a,
459    {
460        self.as_ref().map(AsSerializeArg::as_serialize_arg)
461    }
462}
463
464#[cfg(feature = "introspection")]
465impl<T: Introspectable> Introspectable for Option<T> {
466    fn layout() -> Layout {
467        BuiltInType::Option(T::lexical_id()).into()
468    }
469
470    fn lexical_id() -> LexicalId {
471        LexicalId::option(T::lexical_id())
472    }
473
474    fn add_references(references: &mut References) {
475        references.add::<T>();
476    }
477}
478
479impl Serialize for bool {
480    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
481        serializer.serialize_bool(*self);
482        Ok(())
483    }
484}
485
486impl Deserialize for bool {
487    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
488        deserializer.deserialize_bool()
489    }
490}
491
492impl AsSerializeArg for bool {
493    type SerializeArg<'a> = Self;
494
495    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
496    where
497        Self: 'a,
498    {
499        *self
500    }
501}
502
503#[cfg(feature = "introspection")]
504impl Introspectable for bool {
505    fn layout() -> Layout {
506        BuiltInType::Bool.into()
507    }
508
509    fn lexical_id() -> LexicalId {
510        LexicalId::BOOL
511    }
512
513    fn add_references(_references: &mut References) {}
514}
515
516impl Serialize for u8 {
517    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
518        serializer.serialize_u8(*self);
519        Ok(())
520    }
521}
522
523impl Deserialize for u8 {
524    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
525        deserializer.deserialize_u8()
526    }
527}
528
529impl AsSerializeArg for u8 {
530    type SerializeArg<'a> = Self;
531
532    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
533    where
534        Self: 'a,
535    {
536        *self
537    }
538}
539
540#[cfg(feature = "introspection")]
541impl Introspectable for u8 {
542    fn layout() -> Layout {
543        BuiltInType::U8.into()
544    }
545
546    fn lexical_id() -> LexicalId {
547        LexicalId::U8
548    }
549
550    fn add_references(_references: &mut References) {}
551}
552
553impl Serialize for i8 {
554    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
555        serializer.serialize_i8(*self);
556        Ok(())
557    }
558}
559
560impl Deserialize for i8 {
561    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
562        deserializer.deserialize_i8()
563    }
564}
565
566impl AsSerializeArg for i8 {
567    type SerializeArg<'a> = Self;
568
569    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
570    where
571        Self: 'a,
572    {
573        *self
574    }
575}
576
577#[cfg(feature = "introspection")]
578impl Introspectable for i8 {
579    fn layout() -> Layout {
580        BuiltInType::I8.into()
581    }
582
583    fn lexical_id() -> LexicalId {
584        LexicalId::I8
585    }
586
587    fn add_references(_references: &mut References) {}
588}
589
590impl Serialize for u16 {
591    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
592        serializer.serialize_u16(*self);
593        Ok(())
594    }
595}
596
597impl Deserialize for u16 {
598    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
599        deserializer.deserialize_u16()
600    }
601}
602
603impl AsSerializeArg for u16 {
604    type SerializeArg<'a> = Self;
605
606    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
607    where
608        Self: 'a,
609    {
610        *self
611    }
612}
613
614#[cfg(feature = "introspection")]
615impl Introspectable for u16 {
616    fn layout() -> Layout {
617        BuiltInType::U16.into()
618    }
619
620    fn lexical_id() -> LexicalId {
621        LexicalId::U16
622    }
623
624    fn add_references(_references: &mut References) {}
625}
626
627impl Serialize for i16 {
628    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
629        serializer.serialize_i16(*self);
630        Ok(())
631    }
632}
633
634impl Deserialize for i16 {
635    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
636        deserializer.deserialize_i16()
637    }
638}
639
640impl AsSerializeArg for i16 {
641    type SerializeArg<'a> = Self;
642
643    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
644    where
645        Self: 'a,
646    {
647        *self
648    }
649}
650
651#[cfg(feature = "introspection")]
652impl Introspectable for i16 {
653    fn layout() -> Layout {
654        BuiltInType::I16.into()
655    }
656
657    fn lexical_id() -> LexicalId {
658        LexicalId::I16
659    }
660
661    fn add_references(_references: &mut References) {}
662}
663
664impl Serialize for u32 {
665    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
666        serializer.serialize_u32(*self);
667        Ok(())
668    }
669}
670
671impl Deserialize for u32 {
672    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
673        deserializer.deserialize_u32()
674    }
675}
676
677impl AsSerializeArg for u32 {
678    type SerializeArg<'a> = Self;
679
680    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
681    where
682        Self: 'a,
683    {
684        *self
685    }
686}
687
688#[cfg(feature = "introspection")]
689impl Introspectable for u32 {
690    fn layout() -> Layout {
691        BuiltInType::U32.into()
692    }
693
694    fn lexical_id() -> LexicalId {
695        LexicalId::U32
696    }
697
698    fn add_references(_references: &mut References) {}
699}
700
701impl Serialize for i32 {
702    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
703        serializer.serialize_i32(*self);
704        Ok(())
705    }
706}
707
708impl Deserialize for i32 {
709    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
710        deserializer.deserialize_i32()
711    }
712}
713
714impl AsSerializeArg for i32 {
715    type SerializeArg<'a> = Self;
716
717    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
718    where
719        Self: 'a,
720    {
721        *self
722    }
723}
724
725#[cfg(feature = "introspection")]
726impl Introspectable for i32 {
727    fn layout() -> Layout {
728        BuiltInType::I32.into()
729    }
730
731    fn lexical_id() -> LexicalId {
732        LexicalId::I32
733    }
734
735    fn add_references(_references: &mut References) {}
736}
737
738impl Serialize for u64 {
739    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
740        serializer.serialize_u64(*self);
741        Ok(())
742    }
743}
744
745impl Deserialize for u64 {
746    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
747        deserializer.deserialize_u64()
748    }
749}
750
751impl AsSerializeArg for u64 {
752    type SerializeArg<'a> = Self;
753
754    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
755    where
756        Self: 'a,
757    {
758        *self
759    }
760}
761
762#[cfg(feature = "introspection")]
763impl Introspectable for u64 {
764    fn layout() -> Layout {
765        BuiltInType::U64.into()
766    }
767
768    fn lexical_id() -> LexicalId {
769        LexicalId::U64
770    }
771
772    fn add_references(_references: &mut References) {}
773}
774
775impl Serialize for i64 {
776    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
777        serializer.serialize_i64(*self);
778        Ok(())
779    }
780}
781
782impl Deserialize for i64 {
783    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
784        deserializer.deserialize_i64()
785    }
786}
787
788impl AsSerializeArg for i64 {
789    type SerializeArg<'a> = Self;
790
791    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
792    where
793        Self: 'a,
794    {
795        *self
796    }
797}
798
799#[cfg(feature = "introspection")]
800impl Introspectable for i64 {
801    fn layout() -> Layout {
802        BuiltInType::I64.into()
803    }
804
805    fn lexical_id() -> LexicalId {
806        LexicalId::I64
807    }
808
809    fn add_references(_references: &mut References) {}
810}
811
812impl Serialize for f32 {
813    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
814        serializer.serialize_f32(*self);
815        Ok(())
816    }
817}
818
819impl Deserialize for f32 {
820    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
821        deserializer.deserialize_f32()
822    }
823}
824
825impl AsSerializeArg for f32 {
826    type SerializeArg<'a> = Self;
827
828    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
829    where
830        Self: 'a,
831    {
832        *self
833    }
834}
835
836#[cfg(feature = "introspection")]
837impl Introspectable for f32 {
838    fn layout() -> Layout {
839        BuiltInType::F32.into()
840    }
841
842    fn lexical_id() -> LexicalId {
843        LexicalId::F32
844    }
845
846    fn add_references(_references: &mut References) {}
847}
848
849impl Serialize for f64 {
850    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
851        serializer.serialize_f64(*self);
852        Ok(())
853    }
854}
855
856impl Deserialize for f64 {
857    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
858        deserializer.deserialize_f64()
859    }
860}
861
862impl AsSerializeArg for f64 {
863    type SerializeArg<'a> = Self;
864
865    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
866    where
867        Self: 'a,
868    {
869        *self
870    }
871}
872
873#[cfg(feature = "introspection")]
874impl Introspectable for f64 {
875    fn layout() -> Layout {
876        BuiltInType::F64.into()
877    }
878
879    fn lexical_id() -> LexicalId {
880        LexicalId::F64
881    }
882
883    fn add_references(_references: &mut References) {}
884}
885
886impl Serialize for str {
887    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
888        serializer.serialize_string(self)
889    }
890}
891
892impl AsSerializeArg for str {
893    type SerializeArg<'a> = &'a Self;
894
895    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
896    where
897        Self: 'a,
898    {
899        self
900    }
901}
902
903#[cfg(feature = "introspection")]
904impl Introspectable for str {
905    fn layout() -> Layout {
906        BuiltInType::String.into()
907    }
908
909    fn lexical_id() -> LexicalId {
910        LexicalId::STRING
911    }
912
913    fn add_references(_references: &mut References) {}
914}
915
916impl Serialize for String {
917    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
918        serializer.serialize_string(self)
919    }
920}
921
922impl Deserialize for String {
923    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
924        deserializer.deserialize_string()
925    }
926}
927
928impl AsSerializeArg for String {
929    type SerializeArg<'a> = &'a str;
930
931    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
932    where
933        Self: 'a,
934    {
935        self
936    }
937}
938
939#[cfg(feature = "introspection")]
940impl Introspectable for String {
941    fn layout() -> Layout {
942        BuiltInType::String.into()
943    }
944
945    fn lexical_id() -> LexicalId {
946        LexicalId::STRING
947    }
948
949    fn add_references(_references: &mut References) {}
950}
951
952impl Serialize for Uuid {
953    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
954        serializer.serialize_uuid(*self);
955        Ok(())
956    }
957}
958
959impl Deserialize for Uuid {
960    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
961        deserializer.deserialize_uuid()
962    }
963}
964
965impl AsSerializeArg for Uuid {
966    type SerializeArg<'a> = Self;
967
968    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
969    where
970        Self: 'a,
971    {
972        *self
973    }
974}
975
976#[cfg(feature = "introspection")]
977impl Introspectable for Uuid {
978    fn layout() -> Layout {
979        BuiltInType::Uuid.into()
980    }
981
982    fn lexical_id() -> LexicalId {
983        LexicalId::UUID
984    }
985
986    fn add_references(_references: &mut References) {}
987}
988
989impl<T: Serialize> Serialize for Vec<T> {
990    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
991        serializer.serialize_vec_iter(self)
992    }
993}
994
995impl<T: Deserialize> Deserialize for Vec<T> {
996    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
997        deserializer.deserialize_vec_extend_new()
998    }
999}
1000
1001impl<T: Serialize> AsSerializeArg for Vec<T> {
1002    type SerializeArg<'a>
1003        = &'a [T]
1004    where
1005        Self: 'a;
1006
1007    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1008    where
1009        Self: 'a,
1010    {
1011        self
1012    }
1013}
1014
1015#[cfg(feature = "introspection")]
1016impl<T: Introspectable> Introspectable for Vec<T> {
1017    fn layout() -> Layout {
1018        BuiltInType::Vec(T::lexical_id()).into()
1019    }
1020
1021    fn lexical_id() -> LexicalId {
1022        LexicalId::vec(T::lexical_id())
1023    }
1024
1025    fn add_references(references: &mut References) {
1026        references.add::<T>();
1027    }
1028}
1029
1030impl<T: Serialize> Serialize for VecDeque<T> {
1031    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1032        serializer.serialize_vec_iter(self)
1033    }
1034}
1035
1036impl<T: Deserialize> Deserialize for VecDeque<T> {
1037    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
1038        deserializer.deserialize_vec_extend_new()
1039    }
1040}
1041
1042impl<T: Serialize> AsSerializeArg for VecDeque<T> {
1043    type SerializeArg<'a>
1044        = &'a Self
1045    where
1046        Self: 'a;
1047
1048    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1049    where
1050        Self: 'a,
1051    {
1052        self
1053    }
1054}
1055
1056#[cfg(feature = "introspection")]
1057impl<T: Introspectable> Introspectable for VecDeque<T> {
1058    fn layout() -> Layout {
1059        BuiltInType::Vec(T::lexical_id()).into()
1060    }
1061
1062    fn lexical_id() -> LexicalId {
1063        LexicalId::vec(T::lexical_id())
1064    }
1065
1066    fn add_references(references: &mut References) {
1067        references.add::<T>();
1068    }
1069}
1070
1071impl<T: Serialize> Serialize for LinkedList<T> {
1072    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1073        serializer.serialize_vec_iter(self)
1074    }
1075}
1076
1077impl<T: Deserialize> Deserialize for LinkedList<T> {
1078    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
1079        deserializer.deserialize_vec_extend_new()
1080    }
1081}
1082
1083impl<T: Serialize> AsSerializeArg for LinkedList<T> {
1084    type SerializeArg<'a>
1085        = &'a Self
1086    where
1087        Self: 'a;
1088
1089    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1090    where
1091        Self: 'a,
1092    {
1093        self
1094    }
1095}
1096
1097#[cfg(feature = "introspection")]
1098impl<T: Introspectable> Introspectable for LinkedList<T> {
1099    fn layout() -> Layout {
1100        BuiltInType::Vec(T::lexical_id()).into()
1101    }
1102
1103    fn lexical_id() -> LexicalId {
1104        LexicalId::vec(T::lexical_id())
1105    }
1106
1107    fn add_references(references: &mut References) {
1108        references.add::<T>();
1109    }
1110}
1111
1112impl<T: Serialize> Serialize for [T] {
1113    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1114        serializer.serialize_vec_iter(self)
1115    }
1116}
1117
1118impl<T: Serialize> AsSerializeArg for [T] {
1119    type SerializeArg<'a>
1120        = &'a Self
1121    where
1122        Self: 'a;
1123
1124    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1125    where
1126        Self: 'a,
1127    {
1128        self
1129    }
1130}
1131
1132#[cfg(feature = "introspection")]
1133impl<T: Introspectable> Introspectable for [T] {
1134    fn layout() -> Layout {
1135        BuiltInType::Vec(T::lexical_id()).into()
1136    }
1137
1138    fn lexical_id() -> LexicalId {
1139        LexicalId::vec(T::lexical_id())
1140    }
1141
1142    fn add_references(references: &mut References) {
1143        references.add::<T>();
1144    }
1145}
1146
1147impl<T: Serialize, const N: usize> Serialize for [T; N] {
1148    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1149        serializer.serialize_vec_iter(self)
1150    }
1151}
1152
1153impl<T: Deserialize, const N: usize> Deserialize for [T; N] {
1154    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
1155        let mut deserializer = deserializer.deserialize_vec()?;
1156
1157        if deserializer.len() != N {
1158            return Err(DeserializeError::UnexpectedValue);
1159        }
1160
1161        // SAFETY: This create an array of MaybeUninit<T>, which don't require initialization.
1162        let mut arr: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
1163
1164        // Manually count number of elements, so that the safety of this function doesn't depend on
1165        // the correctness of VecDeserializer.
1166        let mut num = 0;
1167
1168        for elem in &mut arr {
1169            match deserializer.deserialize_element() {
1170                Ok(value) => {
1171                    elem.write(value);
1172                    num += 1;
1173                }
1174
1175                Err(e) => {
1176                    for elem in &mut arr[..num] {
1177                        // SAFETY: The first num elements have been initialized.
1178                        unsafe {
1179                            elem.assume_init_drop();
1180                        }
1181                    }
1182
1183                    return Err(e);
1184                }
1185            }
1186        }
1187
1188        // Panic, because this would indicate a bug in this crate.
1189        assert_eq!(num, N);
1190
1191        // SAFETY: Exactly num elements have been and num equals N.
1192        //
1193        // It's currently impossible to transmute [MaybeUninit<T>; N] to [T; N] when T is a generic
1194        // or N a const generic. See https://github.com/rust-lang/rust/issues/61956.
1195        let value = unsafe {
1196            (*(&MaybeUninit::new(arr) as *const _ as *const MaybeUninit<[T; N]>)).assume_init_read()
1197        };
1198
1199        deserializer.finish(value)
1200    }
1201}
1202
1203impl<T: Serialize, const N: usize> AsSerializeArg for [T; N] {
1204    type SerializeArg<'a>
1205        = &'a Self
1206    where
1207        Self: 'a;
1208
1209    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1210    where
1211        Self: 'a,
1212    {
1213        self
1214    }
1215}
1216
1217#[cfg(feature = "introspection")]
1218impl<T: Introspectable, const N: usize> Introspectable for [T; N] {
1219    fn layout() -> Layout {
1220        BuiltInType::Array(ArrayType::new(T::lexical_id(), N as u32)).into()
1221    }
1222
1223    fn lexical_id() -> LexicalId {
1224        LexicalId::array(T::lexical_id(), N as u32)
1225    }
1226
1227    fn add_references(references: &mut References) {
1228        references.add::<T>();
1229    }
1230}
1231
1232impl Serialize for bytes::Bytes {
1233    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1234        serializer.serialize_byte_slice(self)
1235    }
1236}
1237
1238impl Deserialize for bytes::Bytes {
1239    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
1240        deserializer.deserialize_bytes_to_vec().map(Self::from)
1241    }
1242}
1243
1244impl AsSerializeArg for bytes::Bytes {
1245    type SerializeArg<'a> = &'a ByteSlice;
1246
1247    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1248    where
1249        Self: 'a,
1250    {
1251        ByteSlice::new(self)
1252    }
1253}
1254
1255#[cfg(feature = "introspection")]
1256impl Introspectable for bytes::Bytes {
1257    fn layout() -> Layout {
1258        BuiltInType::Bytes.into()
1259    }
1260
1261    fn lexical_id() -> LexicalId {
1262        LexicalId::BYTES
1263    }
1264
1265    fn add_references(_references: &mut References) {}
1266}
1267
1268impl Serialize for bytes::BytesMut {
1269    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1270        serializer.serialize_byte_slice(self)
1271    }
1272}
1273
1274impl Deserialize for bytes::BytesMut {
1275    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
1276        // This is inefficient, but bytes doesn't currently offer a better alternative.
1277        let vec = deserializer.deserialize_bytes_to_vec()?;
1278        Ok(Self::from(vec.as_slice()))
1279    }
1280}
1281
1282impl AsSerializeArg for bytes::BytesMut {
1283    type SerializeArg<'a> = &'a ByteSlice;
1284
1285    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1286    where
1287        Self: 'a,
1288    {
1289        ByteSlice::new(self)
1290    }
1291}
1292
1293#[cfg(feature = "introspection")]
1294impl Introspectable for bytes::BytesMut {
1295    fn layout() -> Layout {
1296        BuiltInType::Bytes.into()
1297    }
1298
1299    fn lexical_id() -> LexicalId {
1300        LexicalId::BYTES
1301    }
1302
1303    fn add_references(_references: &mut References) {}
1304}
1305
1306impl<K: SerializeKey, V: Serialize, S> Serialize for HashMap<K, V, S> {
1307    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1308        serializer.serialize_map_iter(self)
1309    }
1310}
1311
1312impl<K, V, S> Deserialize for HashMap<K, V, S>
1313where
1314    K: DeserializeKey + Eq + Hash,
1315    V: Deserialize,
1316    S: BuildHasher + Default,
1317{
1318    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
1319        deserializer.deserialize_map_extend_new()
1320    }
1321}
1322
1323impl<K: SerializeKey, V: Serialize, S> AsSerializeArg for HashMap<K, V, S> {
1324    type SerializeArg<'a>
1325        = &'a Self
1326    where
1327        Self: 'a;
1328
1329    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1330    where
1331        Self: 'a,
1332    {
1333        self
1334    }
1335}
1336
1337#[cfg(feature = "introspection")]
1338impl<K, V, S> Introspectable for HashMap<K, V, S>
1339where
1340    K: KeyTypeOf,
1341    V: Introspectable,
1342{
1343    fn layout() -> Layout {
1344        BuiltInType::Map(MapType::new(K::KEY_TYPE, V::lexical_id())).into()
1345    }
1346
1347    fn lexical_id() -> LexicalId {
1348        LexicalId::map(K::KEY_TYPE, V::lexical_id())
1349    }
1350
1351    fn add_references(references: &mut References) {
1352        references.add::<V>();
1353    }
1354}
1355
1356impl<K: SerializeKey, V: Serialize> Serialize for BTreeMap<K, V> {
1357    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1358        serializer.serialize_map_iter(self)
1359    }
1360}
1361
1362impl<K: DeserializeKey + Ord, V: Deserialize> Deserialize for BTreeMap<K, V> {
1363    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
1364        deserializer.deserialize_map_extend_new()
1365    }
1366}
1367
1368impl<K: SerializeKey, V: Serialize> AsSerializeArg for BTreeMap<K, V> {
1369    type SerializeArg<'a>
1370        = &'a Self
1371    where
1372        Self: 'a;
1373
1374    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1375    where
1376        Self: 'a,
1377    {
1378        self
1379    }
1380}
1381
1382#[cfg(feature = "introspection")]
1383impl<K: KeyTypeOf, V: Introspectable> Introspectable for BTreeMap<K, V> {
1384    fn layout() -> Layout {
1385        BuiltInType::Map(MapType::new(K::KEY_TYPE, V::lexical_id())).into()
1386    }
1387
1388    fn lexical_id() -> LexicalId {
1389        LexicalId::map(K::KEY_TYPE, V::lexical_id())
1390    }
1391
1392    fn add_references(references: &mut References) {
1393        references.add::<V>();
1394    }
1395}
1396
1397impl<T: SerializeKey, S> Serialize for HashSet<T, S> {
1398    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1399        serializer.serialize_set_iter(self)
1400    }
1401}
1402
1403impl<T, S> Deserialize for HashSet<T, S>
1404where
1405    T: DeserializeKey + Eq + Hash,
1406    S: BuildHasher + Default,
1407{
1408    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
1409        deserializer.deserialize_set_extend_new()
1410    }
1411}
1412
1413impl<T: SerializeKey, S> AsSerializeArg for HashSet<T, S> {
1414    type SerializeArg<'a>
1415        = &'a Self
1416    where
1417        Self: 'a;
1418
1419    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1420    where
1421        Self: 'a,
1422    {
1423        self
1424    }
1425}
1426
1427#[cfg(feature = "introspection")]
1428impl<T: KeyTypeOf, S> Introspectable for HashSet<T, S> {
1429    fn layout() -> Layout {
1430        BuiltInType::Set(T::KEY_TYPE).into()
1431    }
1432
1433    fn lexical_id() -> LexicalId {
1434        LexicalId::set(T::KEY_TYPE)
1435    }
1436
1437    fn add_references(_references: &mut References) {}
1438}
1439
1440impl<T: SerializeKey> Serialize for BTreeSet<T> {
1441    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1442        serializer.serialize_set_iter(self)
1443    }
1444}
1445
1446impl<T: DeserializeKey + Ord> Deserialize for BTreeSet<T> {
1447    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
1448        deserializer.deserialize_set_extend_new()
1449    }
1450}
1451
1452impl<T: SerializeKey> AsSerializeArg for BTreeSet<T> {
1453    type SerializeArg<'a>
1454        = &'a Self
1455    where
1456        Self: 'a;
1457
1458    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1459    where
1460        Self: 'a,
1461    {
1462        self
1463    }
1464}
1465
1466#[cfg(feature = "introspection")]
1467impl<T: KeyTypeOf> Introspectable for BTreeSet<T> {
1468    fn layout() -> Layout {
1469        BuiltInType::Set(T::KEY_TYPE).into()
1470    }
1471
1472    fn lexical_id() -> LexicalId {
1473        LexicalId::set(T::KEY_TYPE)
1474    }
1475
1476    fn add_references(_references: &mut References) {}
1477}
1478
1479impl<'a, T> Serialize for Cow<'a, T>
1480where
1481    T: Serialize + ToOwned + ?Sized + 'a,
1482{
1483    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1484        match self {
1485            Cow::Borrowed(borrowed) => borrowed.serialize(serializer),
1486            Cow::Owned(owned) => owned.borrow().serialize(serializer),
1487        }
1488    }
1489}
1490
1491impl<'a, T> Deserialize for Cow<'a, T>
1492where
1493    T: ToOwned + ?Sized + 'a,
1494    T::Owned: Deserialize,
1495{
1496    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
1497        T::Owned::deserialize(deserializer).map(Self::Owned)
1498    }
1499}
1500
1501impl<'a, T> AsSerializeArg for Cow<'a, T>
1502where
1503    T: AsSerializeArg + ToOwned + ?Sized + 'a,
1504{
1505    type SerializeArg<'b>
1506        = T::SerializeArg<'b>
1507    where
1508        Self: 'b;
1509
1510    fn as_serialize_arg<'b>(&'b self) -> Self::SerializeArg<'b>
1511    where
1512        Self: 'b,
1513    {
1514        self.as_ref().as_serialize_arg()
1515    }
1516}
1517
1518#[cfg(feature = "introspection")]
1519impl<'a, T> Introspectable for Cow<'a, T>
1520where
1521    T: Introspectable + ToOwned + ?Sized + 'a,
1522{
1523    fn layout() -> Layout {
1524        T::layout()
1525    }
1526
1527    fn lexical_id() -> LexicalId {
1528        T::lexical_id()
1529    }
1530
1531    fn add_references(_references: &mut References) {}
1532}
1533
1534#[derive(IntoPrimitive, TryFromPrimitive)]
1535#[repr(u32)]
1536enum ResultVariant {
1537    Ok = 0,
1538    Err = 1,
1539}
1540
1541impl<T, E> Serialize for Result<T, E>
1542where
1543    T: Serialize,
1544    E: Serialize,
1545{
1546    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1547        match self {
1548            Ok(ok) => serializer.serialize_enum(ResultVariant::Ok, ok),
1549            Err(err) => serializer.serialize_enum(ResultVariant::Err, err),
1550        }
1551    }
1552}
1553
1554impl<T, E> Deserialize for Result<T, E>
1555where
1556    T: Deserialize,
1557    E: Deserialize,
1558{
1559    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
1560        let deserializer = deserializer.deserialize_enum()?;
1561
1562        match deserializer.try_variant()? {
1563            ResultVariant::Ok => deserializer.deserialize().map(Ok),
1564            ResultVariant::Err => deserializer.deserialize().map(Err),
1565        }
1566    }
1567}
1568
1569impl<T: AsSerializeArg, E: AsSerializeArg> AsSerializeArg for Result<T, E> {
1570    type SerializeArg<'a>
1571        = Result<T::SerializeArg<'a>, E::SerializeArg<'a>>
1572    where
1573        Self: 'a;
1574
1575    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1576    where
1577        Self: 'a,
1578    {
1579        self.as_ref()
1580            .map(T::as_serialize_arg)
1581            .map_err(E::as_serialize_arg)
1582    }
1583}
1584
1585#[cfg(feature = "introspection")]
1586impl<T: Introspectable, E: Introspectable> Introspectable for Result<T, E> {
1587    fn layout() -> Layout {
1588        BuiltInType::Result(ResultType::new(T::lexical_id(), E::lexical_id())).into()
1589    }
1590
1591    fn lexical_id() -> LexicalId {
1592        LexicalId::result(T::lexical_id(), E::lexical_id())
1593    }
1594
1595    fn add_references(references: &mut References) {
1596        references.add::<T>();
1597        references.add::<E>();
1598    }
1599}
1600
1601impl Serialize for Infallible {
1602    fn serialize(&self, _serializer: Serializer) -> Result<(), SerializeError> {
1603        match *self {}
1604    }
1605}
1606
1607impl Deserialize for Infallible {
1608    fn deserialize(_deserializer: Deserializer) -> Result<Self, DeserializeError> {
1609        Err(DeserializeError::UnexpectedValue)
1610    }
1611}
1612
1613impl AsSerializeArg for Infallible {
1614    type SerializeArg<'a> = Self;
1615
1616    fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1617    where
1618        Self: 'a,
1619    {
1620        *self
1621    }
1622}
1623
1624macro_rules! tuple_impls {
1625    { $len:literal, $( ($gen:ident, $idx:tt) ),+ } => {
1626        impl<$( $gen ),+> Serialize for ($( $gen, )+)
1627        where
1628            $( $gen: Serialize ),+
1629        {
1630            fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
1631                let mut serializer = serializer.serialize_struct($len)?;
1632
1633                $(
1634                    serializer.serialize_field($idx as u32, &self.$idx)?;
1635                )+
1636
1637                serializer.finish()
1638            }
1639        }
1640
1641        impl<$( $gen ),+> Deserialize for ($( $gen, )+)
1642        where
1643            $( $gen: Deserialize ),+
1644        {
1645            fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
1646                let mut deserializer = deserializer.deserialize_struct()?;
1647
1648                $(
1649                    #[allow(non_snake_case)]
1650                    let mut $gen = None;
1651                )+
1652
1653                while deserializer.has_more_fields() {
1654                    let deserializer = deserializer.deserialize_field()?;
1655
1656                    match deserializer.id() {
1657                        $( $idx => $gen = deserializer.deserialize().map(Some)?, )+
1658                        _ => deserializer.skip()?,
1659                    }
1660                }
1661
1662                deserializer.finish_with(|_| {
1663                    Ok(($( $gen.ok_or(DeserializeError::InvalidSerialization)?, )+))
1664                })
1665            }
1666        }
1667
1668        impl<$( $gen ),+> AsSerializeArg for ($( $gen, )+)
1669        where
1670            $( $gen: AsSerializeArg ),+
1671        {
1672            type SerializeArg<'a>
1673                = ($( $gen::SerializeArg<'a>, )+)
1674            where
1675                Self: 'a;
1676
1677            fn as_serialize_arg<'a>(&'a self) -> Self::SerializeArg<'a>
1678            where
1679                Self: 'a,
1680            {
1681                ($( self.$idx.as_serialize_arg(), )+)
1682            }
1683        }
1684
1685        #[cfg(feature = "introspection")]
1686        impl<$( $gen ),+> Introspectable for ($( $gen, )+)
1687        where
1688            $( $gen: Introspectable ),+
1689        {
1690            fn layout() -> Layout {
1691                Struct::builder("std", concat!("Tuple", $len))
1692                    $( .field($idx, concat!("field", $idx), true, $gen::lexical_id()) )+
1693                    .finish()
1694                    .into()
1695            }
1696
1697            fn lexical_id() -> LexicalId {
1698                LexicalId::custom_generic(
1699                    "std",
1700                    concat!("Tuple", $len),
1701                    &[$( $gen::lexical_id() ),+],
1702                )
1703            }
1704
1705            fn add_references(references: &mut References) {
1706                let types: [DynIntrospectable; $len] = [
1707                    $( DynIntrospectable::new::<$gen>() ),+
1708                ];
1709
1710                references.extend(types);
1711            }
1712        }
1713    };
1714}
1715
1716tuple_impls! {  1, (T0, 0) }
1717tuple_impls! {  2, (T0, 0), (T1, 1) }
1718tuple_impls! {  3, (T0, 0), (T1, 1), (T2, 2) }
1719tuple_impls! {  4, (T0, 0), (T1, 1), (T2, 2), (T3, 3) }
1720tuple_impls! {  5, (T0, 0), (T1, 1), (T2, 2), (T3, 3), (T4, 4) }
1721tuple_impls! {  6, (T0, 0), (T1, 1), (T2, 2), (T3, 3), (T4, 4), (T5, 5) }
1722tuple_impls! {  7, (T0, 0), (T1, 1), (T2, 2), (T3, 3), (T4, 4), (T5, 5), (T6, 6) }
1723tuple_impls! {  8, (T0, 0), (T1, 1), (T2, 2), (T3, 3), (T4, 4), (T5, 5), (T6, 6), (T7, 7) }
1724tuple_impls! {  9, (T0, 0), (T1, 1), (T2, 2), (T3, 3), (T4, 4), (T5, 5), (T6, 6), (T7, 7), (T8, 8) }
1725tuple_impls! { 10,
1726    (T0, 0), (T1, 1), (T2, 2), (T3, 3), (T4, 4), (T5, 5), (T6, 6), (T7, 7), (T8, 8), (T9, 9)
1727}
1728tuple_impls! { 11,
1729    (T0, 0), (T1, 1), (T2, 2), (T3, 3), (T4, 4), (T5, 5), (T6, 6), (T7, 7), (T8, 8), (T9, 9),
1730    (T10, 10)
1731}
1732tuple_impls! { 12,
1733    (T0, 0), (T1, 1), (T2, 2), (T3, 3), (T4, 4), (T5, 5), (T6, 6), (T7, 7), (T8, 8),
1734    (T9, 9), (T10, 10), (T11, 11)
1735}
aldrin_core/value.rs

aldrin_core/
value.rs
