nominal_api_conjure/conjure/objects/scout/compute/api/
boolean_series.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, conjure_object::private::DeriveWith)]
6#[derive_with(PartialEq, Eq, PartialOrd, Ord, Hash)]
7pub enum BooleanSeries {
8    GreaterThan(super::GreaterThanSeries),
9    LessThan(super::LessThanSeries),
10    EqualTo(super::EqualToSeries),
11    NotEqualTo(super::NotEqualToSeries),
12    GreaterThanOrEqualTo(super::GreaterThanOrEqualToSeries),
13    LessThanOrEqualTo(super::LessThanOrEqualToSeries),
14    And(super::AndSeries),
15    Or(super::OrSeries),
16    /// An unknown variant.
17    Unknown(Unknown),
18}
19impl ser::Serialize for BooleanSeries {
20    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
21    where
22        S: ser::Serializer,
23    {
24        let mut map = s.serialize_map(Some(2))?;
25        match self {
26            BooleanSeries::GreaterThan(value) => {
27                map.serialize_entry(&"type", &"greaterThan")?;
28                map.serialize_entry(&"greaterThan", value)?;
29            }
30            BooleanSeries::LessThan(value) => {
31                map.serialize_entry(&"type", &"lessThan")?;
32                map.serialize_entry(&"lessThan", value)?;
33            }
34            BooleanSeries::EqualTo(value) => {
35                map.serialize_entry(&"type", &"equalTo")?;
36                map.serialize_entry(&"equalTo", value)?;
37            }
38            BooleanSeries::NotEqualTo(value) => {
39                map.serialize_entry(&"type", &"notEqualTo")?;
40                map.serialize_entry(&"notEqualTo", value)?;
41            }
42            BooleanSeries::GreaterThanOrEqualTo(value) => {
43                map.serialize_entry(&"type", &"greaterThanOrEqualTo")?;
44                map.serialize_entry(&"greaterThanOrEqualTo", value)?;
45            }
46            BooleanSeries::LessThanOrEqualTo(value) => {
47                map.serialize_entry(&"type", &"lessThanOrEqualTo")?;
48                map.serialize_entry(&"lessThanOrEqualTo", value)?;
49            }
50            BooleanSeries::And(value) => {
51                map.serialize_entry(&"type", &"and")?;
52                map.serialize_entry(&"and", value)?;
53            }
54            BooleanSeries::Or(value) => {
55                map.serialize_entry(&"type", &"or")?;
56                map.serialize_entry(&"or", value)?;
57            }
58            BooleanSeries::Unknown(value) => {
59                map.serialize_entry(&"type", &value.type_)?;
60                map.serialize_entry(&value.type_, &value.value)?;
61            }
62        }
63        map.end()
64    }
65}
66impl<'de> de::Deserialize<'de> for BooleanSeries {
67    fn deserialize<D>(d: D) -> Result<BooleanSeries, D::Error>
68    where
69        D: de::Deserializer<'de>,
70    {
71        d.deserialize_map(Visitor_)
72    }
73}
74struct Visitor_;
75impl<'de> de::Visitor<'de> for Visitor_ {
76    type Value = BooleanSeries;
77    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
78        fmt.write_str("union BooleanSeries")
79    }
80    fn visit_map<A>(self, mut map: A) -> Result<BooleanSeries, A::Error>
81    where
82        A: de::MapAccess<'de>,
83    {
84        let v = match map.next_key::<UnionField_<Variant_>>()? {
85            Some(UnionField_::Type) => {
86                let variant = map.next_value()?;
87                let key = map.next_key()?;
88                match (variant, key) {
89                    (Variant_::GreaterThan, Some(Variant_::GreaterThan)) => {
90                        let value = map.next_value()?;
91                        BooleanSeries::GreaterThan(value)
92                    }
93                    (Variant_::LessThan, Some(Variant_::LessThan)) => {
94                        let value = map.next_value()?;
95                        BooleanSeries::LessThan(value)
96                    }
97                    (Variant_::EqualTo, Some(Variant_::EqualTo)) => {
98                        let value = map.next_value()?;
99                        BooleanSeries::EqualTo(value)
100                    }
101                    (Variant_::NotEqualTo, Some(Variant_::NotEqualTo)) => {
102                        let value = map.next_value()?;
103                        BooleanSeries::NotEqualTo(value)
104                    }
105                    (
106                        Variant_::GreaterThanOrEqualTo,
107                        Some(Variant_::GreaterThanOrEqualTo),
108                    ) => {
109                        let value = map.next_value()?;
110                        BooleanSeries::GreaterThanOrEqualTo(value)
111                    }
112                    (Variant_::LessThanOrEqualTo, Some(Variant_::LessThanOrEqualTo)) => {
113                        let value = map.next_value()?;
114                        BooleanSeries::LessThanOrEqualTo(value)
115                    }
116                    (Variant_::And, Some(Variant_::And)) => {
117                        let value = map.next_value()?;
118                        BooleanSeries::And(value)
119                    }
120                    (Variant_::Or, Some(Variant_::Or)) => {
121                        let value = map.next_value()?;
122                        BooleanSeries::Or(value)
123                    }
124                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
125                        if type_ == b {
126                            let value = map.next_value()?;
127                            BooleanSeries::Unknown(Unknown { type_, value })
128                        } else {
129                            return Err(
130                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
131                            )
132                        }
133                    }
134                    (variant, Some(key)) => {
135                        return Err(
136                            de::Error::invalid_value(
137                                de::Unexpected::Str(key.as_str()),
138                                &variant.as_str(),
139                            ),
140                        );
141                    }
142                    (variant, None) => {
143                        return Err(de::Error::missing_field(variant.as_str()));
144                    }
145                }
146            }
147            Some(UnionField_::Value(variant)) => {
148                let value = match &variant {
149                    Variant_::GreaterThan => {
150                        let value = map.next_value()?;
151                        BooleanSeries::GreaterThan(value)
152                    }
153                    Variant_::LessThan => {
154                        let value = map.next_value()?;
155                        BooleanSeries::LessThan(value)
156                    }
157                    Variant_::EqualTo => {
158                        let value = map.next_value()?;
159                        BooleanSeries::EqualTo(value)
160                    }
161                    Variant_::NotEqualTo => {
162                        let value = map.next_value()?;
163                        BooleanSeries::NotEqualTo(value)
164                    }
165                    Variant_::GreaterThanOrEqualTo => {
166                        let value = map.next_value()?;
167                        BooleanSeries::GreaterThanOrEqualTo(value)
168                    }
169                    Variant_::LessThanOrEqualTo => {
170                        let value = map.next_value()?;
171                        BooleanSeries::LessThanOrEqualTo(value)
172                    }
173                    Variant_::And => {
174                        let value = map.next_value()?;
175                        BooleanSeries::And(value)
176                    }
177                    Variant_::Or => {
178                        let value = map.next_value()?;
179                        BooleanSeries::Or(value)
180                    }
181                    Variant_::Unknown(type_) => {
182                        let value = map.next_value()?;
183                        BooleanSeries::Unknown(Unknown {
184                            type_: type_.clone(),
185                            value,
186                        })
187                    }
188                };
189                if map.next_key::<UnionTypeField_>()?.is_none() {
190                    return Err(de::Error::missing_field("type"));
191                }
192                let type_variant = map.next_value::<Variant_>()?;
193                if variant != type_variant {
194                    return Err(
195                        de::Error::invalid_value(
196                            de::Unexpected::Str(type_variant.as_str()),
197                            &variant.as_str(),
198                        ),
199                    );
200                }
201                value
202            }
203            None => return Err(de::Error::missing_field("type")),
204        };
205        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
206            return Err(de::Error::invalid_length(3, &"type and value fields"));
207        }
208        Ok(v)
209    }
210}
211#[derive(PartialEq)]
212enum Variant_ {
213    GreaterThan,
214    LessThan,
215    EqualTo,
216    NotEqualTo,
217    GreaterThanOrEqualTo,
218    LessThanOrEqualTo,
219    And,
220    Or,
221    Unknown(Box<str>),
222}
223impl Variant_ {
224    fn as_str(&self) -> &'static str {
225        match *self {
226            Variant_::GreaterThan => "greaterThan",
227            Variant_::LessThan => "lessThan",
228            Variant_::EqualTo => "equalTo",
229            Variant_::NotEqualTo => "notEqualTo",
230            Variant_::GreaterThanOrEqualTo => "greaterThanOrEqualTo",
231            Variant_::LessThanOrEqualTo => "lessThanOrEqualTo",
232            Variant_::And => "and",
233            Variant_::Or => "or",
234            Variant_::Unknown(_) => "unknown variant",
235        }
236    }
237}
238impl<'de> de::Deserialize<'de> for Variant_ {
239    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
240    where
241        D: de::Deserializer<'de>,
242    {
243        d.deserialize_str(VariantVisitor_)
244    }
245}
246struct VariantVisitor_;
247impl<'de> de::Visitor<'de> for VariantVisitor_ {
248    type Value = Variant_;
249    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
250        fmt.write_str("string")
251    }
252    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
253    where
254        E: de::Error,
255    {
256        let v = match value {
257            "greaterThan" => Variant_::GreaterThan,
258            "lessThan" => Variant_::LessThan,
259            "equalTo" => Variant_::EqualTo,
260            "notEqualTo" => Variant_::NotEqualTo,
261            "greaterThanOrEqualTo" => Variant_::GreaterThanOrEqualTo,
262            "lessThanOrEqualTo" => Variant_::LessThanOrEqualTo,
263            "and" => Variant_::And,
264            "or" => Variant_::Or,
265            value => Variant_::Unknown(value.to_string().into_boxed_str()),
266        };
267        Ok(v)
268    }
269}
270///An unknown variant of the BooleanSeries union.
271#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
272pub struct Unknown {
273    type_: Box<str>,
274    value: conjure_object::Any,
275}
276impl Unknown {
277    /// Returns the unknown variant's type name.
278    #[inline]
279    pub fn type_(&self) -> &str {
280        &self.type_
281    }
282}
nominal_api_conjure/conjure/objects/scout/compute/api/boolean_series.rs

nominal_api_conjure/conjure/objects/scout/compute/api/
boolean_series.rs
