aldrin-core 0.13.0

Shared core components of Aldrin, a message bus for service-oriented RPC and interprocess communication.
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

#[cfg(feature = "introspection")]
use crate::introspection::{ir, DynIntrospectable, Introspectable, LexicalId, References};
use crate::tags::{PrimaryTag, Tag};
use crate::{Deserialize, DeserializeError, Deserializer, Serialize, SerializeError, Serializer};

macro_rules! impl_tuple {
    { $len:literal, $( ($tag:ident, $gen:ident, $idx:tt) ),+ } => {
        impl<$( $tag: Tag ),+> Tag for ($( $tag ,)+) { }

        impl<$( $tag: PrimaryTag ),+> PrimaryTag for ($( $tag ,)+) {
            type Tag = ($( $tag::Tag ,)+);
        }

        impl<$( $tag, $gen ),+> Serialize<($( $tag ,)+)> for ($( $gen ,)+)
        where
            $(
                $tag: Tag,
                $gen: Serialize<$tag>,
            )+
        {
            fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
                let mut serializer = serializer.serialize_struct2()?;

                $(
                    serializer.serialize($idx as u32, self.$idx)?;
                )+

                serializer.finish()
            }
        }

        impl<$( $tag, $gen ),+> Deserialize<($( $tag ,)+)> for ($( $gen ,)+)
        where
            $(
                $tag: Tag,
                $gen: Deserialize<$tag>,
            )+
        {
            fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
                let mut deserializer = deserializer.deserialize_struct()?;

                $(
                    #[allow(non_snake_case)]
                    let mut $gen = None;
                )+

                while let Some(deserializer) = deserializer.deserialize()? {
                    match deserializer.id() {
                        $( $idx => $gen = deserializer.deserialize().map(Some)?, )+
                        _ => return Err(DeserializeError::InvalidSerialization),
                    }
                }

                deserializer.finish_with(|_| {
                    Ok(($( $gen.ok_or(DeserializeError::InvalidSerialization)?, )+))
                })
            }
        }

        impl<'a, $( $tag, $gen ),+> Serialize<($( $tag ,)+)> for &'a ($( $gen ,)+)
        where
            $(
                $tag: Tag,
                &'a $gen: Serialize<$tag>,
            )+
        {
            fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
                let mut serializer = serializer.serialize_struct2()?;

                $(
                    serializer.serialize($idx as u32, &self.$idx)?;
                )+

                serializer.finish()
            }
        }

        #[cfg(feature = "introspection")]
        impl<$( $gen ),+> Introspectable for ($( $gen, )+)
        where
            $( $gen: Introspectable ),+
        {
            fn layout() -> ir::LayoutIr {
                ir::StructIr::builder("std", concat!("Tuple", $len))
                    $(
                        .field(
                            ir::FieldIr::builder(
                                $idx,
                                concat!("field", $idx),
                                true,
                                $gen::lexical_id(),
                            )
                            .finish(),
                        )
                    )+
                    .finish()
                    .into()
            }

            fn lexical_id() -> LexicalId {
                LexicalId::custom_generic(
                    "std",
                    concat!("Tuple", $len),
                    &[$( $gen::lexical_id() ),+],
                )
            }

            fn add_references(references: &mut References) {
                let types: [DynIntrospectable; $len] = [
                    $( DynIntrospectable::new::<$gen>() ),+
                ];

                references.extend(types);
            }
        }
    };
}

impl_tuple! { 1, (T0, U0, 0) }
impl_tuple! { 2, (T0, U0, 0), (T1, U1, 1) }
impl_tuple! { 3, (T0, U0, 0), (T1, U1, 1), (T2, U2, 2) }
impl_tuple! { 4, (T0, U0, 0), (T1, U1, 1), (T2, U2, 2), (T3, U3, 3) }
impl_tuple! { 5, (T0, U0, 0), (T1, U1, 1), (T2, U2, 2), (T3, U3, 3), (T4, U4, 4) }
impl_tuple! { 6, (T0, U0, 0), (T1, U1, 1), (T2, U2, 2), (T3, U3, 3), (T4, U4, 4), (T5, U5, 5) }

impl_tuple! {
    7,
    (T0, U0, 0), (T1, U1, 1), (T2, U2, 2), (T3, U3, 3), (T4, U4, 4), (T5, U5, 5), (T6, U6, 6)
}

impl_tuple! {
    8,
    (T0, U0, 0), (T1, U1, 1), (T2, U2, 2), (T3, U3, 3), (T4, U4, 4), (T5, U5, 5), (T6, U6, 6),
    (T7, U7, 7)
}

impl_tuple! {
    9,
    (T0, U0, 0), (T1, U1, 1), (T2, U2, 2), (T3, U3, 3), (T4, U4, 4), (T5, U5, 5), (T6, U6, 6),
    (T7, U7, 7), (T8, U8, 8)
}

impl_tuple! {
    10,
    (T0, U0, 0), (T1, U1, 1), (T2, U2, 2), (T3, U3, 3), (T4, U4, 4), (T5, U5, 5), (T6, U6, 6),
    (T7, U7, 7), (T8, U8, 8), (T9, U9, 9)
}

impl_tuple! {
    11,
    (T0, U0, 0), (T1, U1, 1), (T2, U2, 2), (T3, U3, 3), (T4, U4, 4), (T5, U5, 5), (T6, U6, 6),
    (T7, U7, 7), (T8, U8, 8), (T9, U9, 9), (T10, U10, 10)
}

impl_tuple! {
    12,
    (T0, U0, 0), (T1, U1, 1), (T2, U2, 2), (T3, U3, 3), (T4, U4, 4), (T5, U5, 5), (T6, U6, 6),
    (T7, U7, 7), (T8, U8, 8), (T9, U9, 9), (T10, U10, 10), (T11, U11, 11)
}