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

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