autapi 0.0.1

Automatic OpenAPI specification from function signatures
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

macro_rules! transparent_serialize {
    (
        serde $ty:ident <
            $($lt:lifetime;)?
            $($gen:ident $(: $($bound:path)* )? ),*
        > $(via $via_ty:ident <- $func:expr)?
    ) => {
        impl<$($lt,)? $($gen: ?Sized),*> crate::schema::SchemaSerialize for $ty<$($lt,)? $($gen,)*>
        where
            crate::schema::macros::transparent_serialize!(@via $($via_ty)?): serde::Serialize,
            $($($($gen: $bound,)*)?)*
        {
            fn schema_serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                <
                    crate::schema::macros::transparent_serialize!(@via $($via_ty)?) as serde::Serialize
                >::serialize($($func)?(self), serializer)
            }
            fn is_present(&self) -> bool {
                true
            }
        }
    };
    (
        schema $ty:ident <
            $($lt:lifetime;)?
            $($gen:ident $(: $($bound:path)* )? ),*
        > via $via_ty:ident <- $func:expr
    ) => {
        impl<$($lt,)? $($gen: ?Sized),*> crate::schema::SchemaSerialize for $ty<$($lt,)? $($gen,)*>
        where
            $via_ty: crate::schema::SchemaSerialize,
            $($($($gen: $bound,)*)?)*
        {
            fn schema_serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                <$via_ty as crate::schema::SchemaSerialize>::schema_serialize(
                    &*$func(self),
                    serializer
                )
            }
            fn is_present(&self) -> bool {
                <$via_ty as crate::schema::SchemaSerialize>::is_present(
                    &*$func(self),
                )
            }
        }
    };
    (@via $via:ident) => { $via };
    (@via) => { Self };
}

macro_rules! transparent_deserialize {
    (
        serde $ty:ident <
            $($lt:lifetime;)?
            $($gen:ident $(: $($bound:path)* )? ),*
        > $(via $via:ident)?
    ) => {
        #[allow(dead_code)]
        impl<$($lt,)? $($gen: ?Sized,)*> crate::schema::SchemaDeserialize for $ty <$($lt)? $($gen,)*>
        where
            crate::schema::macros::transparent_deserialize!(@via $($via)?): for<'de> serde::Deserialize<'de>,
            $($($($gen: $bound),*)?)*
        {
            fn schema_deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                <
                    crate::schema::macros::transparent_deserialize!(@via $($via)?) as serde::Deserialize
                >::deserialize(deserializer).map(Into::into)
            }
            fn deserialize_missing() -> Option<Self> {
                None
            }
        }
    };
    (
        schema $ty:ident <
            $($lt:lifetime;)?
            $($gen:ident $(: $($bound:path)* )? ),*
        > via $via:ident $(-> $func:expr)?
    ) => {
        impl<$($lt,)? $($gen: ?Sized,)*> crate::schema::SchemaDeserialize for $ty <$($lt,)? $($gen,)*>
        where
            $via: crate::schema::SchemaDeserialize,
            $($($($gen: $bound),*)?)*
        {
            fn schema_deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                <
                    $via as crate::schema::SchemaDeserialize
                >::schema_deserialize(deserializer).map(
                    crate::schema::macros::transparent_deserialize!(@via_func $($func)?)
                )
            }
            fn deserialize_missing() -> Option<Self> {
                <
                    $via as crate::schema::SchemaDeserialize
                >::deserialize_missing().map(
                    crate::schema::macros::transparent_deserialize!(@via_func $($func)?)
                )
            }
        }
    };
    (@via $via:ident) => { $via };
    (@via) => { Self };
    (@via_func $via_func:expr) => { $via_func };
    (@via_func) => { Into::into };
}

macro_rules! transparent_serde {
    (
        $serde_or_schema:ident $ty:ident <
            $($lt:lifetime;)?
            $($gen:ident $(: $($bound:path)* )? ),*
        >
    ) => {
        crate::schema::macros::transparent_serialize!(
            $serde_or_schema $ty <
                $($lt;)?
                $($gen $(: $($bound)*)?),*
            >
        );
        crate::schema::macros::transparent_deserialize!(
            $serde_or_schema $ty <
                $($lt;)?
                $($gen $(: $($bound)*)?),*
            >
        );
    };
}

pub(crate) use transparent_deserialize;
pub(crate) use transparent_serde;
pub(crate) use transparent_serialize;