conjure_codegen/types/
parameter_type.rs

1use conjure_object::serde::{ser, de};
2use conjure_object::serde::ser::SerializeMap as SerializeMap_;
3use conjure_object::private::{UnionField_, UnionTypeField_};
4use std::fmt;
5#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6pub enum ParameterType {
7    Body(super::BodyParameterType),
8    Header(super::HeaderParameterType),
9    Path(super::PathParameterType),
10    Query(super::QueryParameterType),
11}
12impl ser::Serialize for ParameterType {
13    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
14    where
15        S: ser::Serializer,
16    {
17        let mut map = s.serialize_map(Some(2))?;
18        match self {
19            ParameterType::Body(value) => {
20                map.serialize_entry(&"type", &"body")?;
21                map.serialize_entry(&"body", value)?;
22            }
23            ParameterType::Header(value) => {
24                map.serialize_entry(&"type", &"header")?;
25                map.serialize_entry(&"header", value)?;
26            }
27            ParameterType::Path(value) => {
28                map.serialize_entry(&"type", &"path")?;
29                map.serialize_entry(&"path", value)?;
30            }
31            ParameterType::Query(value) => {
32                map.serialize_entry(&"type", &"query")?;
33                map.serialize_entry(&"query", value)?;
34            }
35        }
36        map.end()
37    }
38}
39impl<'de> de::Deserialize<'de> for ParameterType {
40    fn deserialize<D>(d: D) -> Result<ParameterType, D::Error>
41    where
42        D: de::Deserializer<'de>,
43    {
44        d.deserialize_map(Visitor_)
45    }
46}
47struct Visitor_;
48impl<'de> de::Visitor<'de> for Visitor_ {
49    type Value = ParameterType;
50    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
51        fmt.write_str("union ParameterType")
52    }
53    fn visit_map<A>(self, mut map: A) -> Result<ParameterType, A::Error>
54    where
55        A: de::MapAccess<'de>,
56    {
57        let v = match map.next_key::<UnionField_<Variant_>>()? {
58            Some(UnionField_::Type) => {
59                let variant = map.next_value()?;
60                let key = map.next_key()?;
61                match (variant, key) {
62                    (Variant_::Body, Some(Variant_::Body)) => {
63                        let value = map.next_value()?;
64                        ParameterType::Body(value)
65                    }
66                    (Variant_::Header, Some(Variant_::Header)) => {
67                        let value = map.next_value()?;
68                        ParameterType::Header(value)
69                    }
70                    (Variant_::Path, Some(Variant_::Path)) => {
71                        let value = map.next_value()?;
72                        ParameterType::Path(value)
73                    }
74                    (Variant_::Query, Some(Variant_::Query)) => {
75                        let value = map.next_value()?;
76                        ParameterType::Query(value)
77                    }
78                    (variant, Some(key)) => {
79                        return Err(
80                            de::Error::invalid_value(
81                                de::Unexpected::Str(key.as_str()),
82                                &variant.as_str(),
83                            ),
84                        );
85                    }
86                    (variant, None) => {
87                        return Err(de::Error::missing_field(variant.as_str()));
88                    }
89                }
90            }
91            Some(UnionField_::Value(variant)) => {
92                let value = match &variant {
93                    Variant_::Body => {
94                        let value = map.next_value()?;
95                        ParameterType::Body(value)
96                    }
97                    Variant_::Header => {
98                        let value = map.next_value()?;
99                        ParameterType::Header(value)
100                    }
101                    Variant_::Path => {
102                        let value = map.next_value()?;
103                        ParameterType::Path(value)
104                    }
105                    Variant_::Query => {
106                        let value = map.next_value()?;
107                        ParameterType::Query(value)
108                    }
109                };
110                if map.next_key::<UnionTypeField_>()?.is_none() {
111                    return Err(de::Error::missing_field("type"));
112                }
113                let type_variant = map.next_value::<Variant_>()?;
114                if variant != type_variant {
115                    return Err(
116                        de::Error::invalid_value(
117                            de::Unexpected::Str(type_variant.as_str()),
118                            &variant.as_str(),
119                        ),
120                    );
121                }
122                value
123            }
124            None => return Err(de::Error::missing_field("type")),
125        };
126        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
127            return Err(de::Error::invalid_length(3, &"type and value fields"));
128        }
129        Ok(v)
130    }
131}
132#[derive(PartialEq)]
133enum Variant_ {
134    Body,
135    Header,
136    Path,
137    Query,
138}
139impl Variant_ {
140    fn as_str(&self) -> &'static str {
141        match *self {
142            Variant_::Body => "body",
143            Variant_::Header => "header",
144            Variant_::Path => "path",
145            Variant_::Query => "query",
146        }
147    }
148}
149impl<'de> de::Deserialize<'de> for Variant_ {
150    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
151    where
152        D: de::Deserializer<'de>,
153    {
154        d.deserialize_str(VariantVisitor_)
155    }
156}
157struct VariantVisitor_;
158impl<'de> de::Visitor<'de> for VariantVisitor_ {
159    type Value = Variant_;
160    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
161        fmt.write_str("string")
162    }
163    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
164    where
165        E: de::Error,
166    {
167        let v = match value {
168            "body" => Variant_::Body,
169            "header" => Variant_::Header,
170            "path" => Variant_::Path,
171            "query" => Variant_::Query,
172            value => {
173                return Err(
174                    de::Error::unknown_variant(
175                        value,
176                        &["body", "header", "path", "query"],
177                    ),
178                );
179            }
180        };
181        Ok(v)
182    }
183}
conjure_codegen/types/parameter_type.rs

conjure_codegen/types/
parameter_type.rs
