nominal_api_conjure/conjure/objects/scout/compute/resolved/api/
ranges_node.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 RangesNode {
8    DurationFilter(super::DurationFilterRangesNode),
9    EnumEquality(super::EnumEqualityRangesNode),
10    EnumFilter(super::EnumFilterRangesNode),
11    Extrema(super::ExtremaRangesNode),
12    IntersectRange(super::IntersectRangesNode),
13    LiteralRanges(super::LiteralRangesNode),
14    MinMaxThreshold(super::MinMaxThresholdRangesNode),
15    Not(super::NotRangesNode),
16    OnChange(super::OnChangeRangesNode),
17    RangeNumericAggregation(super::RangesNumericAggregationNode),
18    SeriesCrossoverRangesNode(super::SeriesCrossoverRangesNode),
19    StaleRange(super::StaleRangesNode),
20    StabilityDetection(super::StabilityDetectionRangesNode),
21    Threshold(super::ThresholdingRangesNode),
22    UnionRange(super::UnionRangesNode),
23    PaddedRanges(super::PaddedRangesNode),
24    /// An unknown variant.
25    Unknown(Unknown),
26}
27impl ser::Serialize for RangesNode {
28    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
29    where
30        S: ser::Serializer,
31    {
32        let mut map = s.serialize_map(Some(2))?;
33        match self {
34            RangesNode::DurationFilter(value) => {
35                map.serialize_entry(&"type", &"durationFilter")?;
36                map.serialize_entry(&"durationFilter", value)?;
37            }
38            RangesNode::EnumEquality(value) => {
39                map.serialize_entry(&"type", &"enumEquality")?;
40                map.serialize_entry(&"enumEquality", value)?;
41            }
42            RangesNode::EnumFilter(value) => {
43                map.serialize_entry(&"type", &"enumFilter")?;
44                map.serialize_entry(&"enumFilter", value)?;
45            }
46            RangesNode::Extrema(value) => {
47                map.serialize_entry(&"type", &"extrema")?;
48                map.serialize_entry(&"extrema", value)?;
49            }
50            RangesNode::IntersectRange(value) => {
51                map.serialize_entry(&"type", &"intersectRange")?;
52                map.serialize_entry(&"intersectRange", value)?;
53            }
54            RangesNode::LiteralRanges(value) => {
55                map.serialize_entry(&"type", &"literalRanges")?;
56                map.serialize_entry(&"literalRanges", value)?;
57            }
58            RangesNode::MinMaxThreshold(value) => {
59                map.serialize_entry(&"type", &"minMaxThreshold")?;
60                map.serialize_entry(&"minMaxThreshold", value)?;
61            }
62            RangesNode::Not(value) => {
63                map.serialize_entry(&"type", &"not")?;
64                map.serialize_entry(&"not", value)?;
65            }
66            RangesNode::OnChange(value) => {
67                map.serialize_entry(&"type", &"onChange")?;
68                map.serialize_entry(&"onChange", value)?;
69            }
70            RangesNode::RangeNumericAggregation(value) => {
71                map.serialize_entry(&"type", &"rangeNumericAggregation")?;
72                map.serialize_entry(&"rangeNumericAggregation", value)?;
73            }
74            RangesNode::SeriesCrossoverRangesNode(value) => {
75                map.serialize_entry(&"type", &"seriesCrossoverRangesNode")?;
76                map.serialize_entry(&"seriesCrossoverRangesNode", value)?;
77            }
78            RangesNode::StaleRange(value) => {
79                map.serialize_entry(&"type", &"staleRange")?;
80                map.serialize_entry(&"staleRange", value)?;
81            }
82            RangesNode::StabilityDetection(value) => {
83                map.serialize_entry(&"type", &"stabilityDetection")?;
84                map.serialize_entry(&"stabilityDetection", value)?;
85            }
86            RangesNode::Threshold(value) => {
87                map.serialize_entry(&"type", &"threshold")?;
88                map.serialize_entry(&"threshold", value)?;
89            }
90            RangesNode::UnionRange(value) => {
91                map.serialize_entry(&"type", &"unionRange")?;
92                map.serialize_entry(&"unionRange", value)?;
93            }
94            RangesNode::PaddedRanges(value) => {
95                map.serialize_entry(&"type", &"paddedRanges")?;
96                map.serialize_entry(&"paddedRanges", value)?;
97            }
98            RangesNode::Unknown(value) => {
99                map.serialize_entry(&"type", &value.type_)?;
100                map.serialize_entry(&value.type_, &value.value)?;
101            }
102        }
103        map.end()
104    }
105}
106impl<'de> de::Deserialize<'de> for RangesNode {
107    fn deserialize<D>(d: D) -> Result<RangesNode, D::Error>
108    where
109        D: de::Deserializer<'de>,
110    {
111        d.deserialize_map(Visitor_)
112    }
113}
114struct Visitor_;
115impl<'de> de::Visitor<'de> for Visitor_ {
116    type Value = RangesNode;
117    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
118        fmt.write_str("union RangesNode")
119    }
120    fn visit_map<A>(self, mut map: A) -> Result<RangesNode, A::Error>
121    where
122        A: de::MapAccess<'de>,
123    {
124        let v = match map.next_key::<UnionField_<Variant_>>()? {
125            Some(UnionField_::Type) => {
126                let variant = map.next_value()?;
127                let key = map.next_key()?;
128                match (variant, key) {
129                    (Variant_::DurationFilter, Some(Variant_::DurationFilter)) => {
130                        let value = map.next_value()?;
131                        RangesNode::DurationFilter(value)
132                    }
133                    (Variant_::EnumEquality, Some(Variant_::EnumEquality)) => {
134                        let value = map.next_value()?;
135                        RangesNode::EnumEquality(value)
136                    }
137                    (Variant_::EnumFilter, Some(Variant_::EnumFilter)) => {
138                        let value = map.next_value()?;
139                        RangesNode::EnumFilter(value)
140                    }
141                    (Variant_::Extrema, Some(Variant_::Extrema)) => {
142                        let value = map.next_value()?;
143                        RangesNode::Extrema(value)
144                    }
145                    (Variant_::IntersectRange, Some(Variant_::IntersectRange)) => {
146                        let value = map.next_value()?;
147                        RangesNode::IntersectRange(value)
148                    }
149                    (Variant_::LiteralRanges, Some(Variant_::LiteralRanges)) => {
150                        let value = map.next_value()?;
151                        RangesNode::LiteralRanges(value)
152                    }
153                    (Variant_::MinMaxThreshold, Some(Variant_::MinMaxThreshold)) => {
154                        let value = map.next_value()?;
155                        RangesNode::MinMaxThreshold(value)
156                    }
157                    (Variant_::Not, Some(Variant_::Not)) => {
158                        let value = map.next_value()?;
159                        RangesNode::Not(value)
160                    }
161                    (Variant_::OnChange, Some(Variant_::OnChange)) => {
162                        let value = map.next_value()?;
163                        RangesNode::OnChange(value)
164                    }
165                    (
166                        Variant_::RangeNumericAggregation,
167                        Some(Variant_::RangeNumericAggregation),
168                    ) => {
169                        let value = map.next_value()?;
170                        RangesNode::RangeNumericAggregation(value)
171                    }
172                    (
173                        Variant_::SeriesCrossoverRangesNode,
174                        Some(Variant_::SeriesCrossoverRangesNode),
175                    ) => {
176                        let value = map.next_value()?;
177                        RangesNode::SeriesCrossoverRangesNode(value)
178                    }
179                    (Variant_::StaleRange, Some(Variant_::StaleRange)) => {
180                        let value = map.next_value()?;
181                        RangesNode::StaleRange(value)
182                    }
183                    (
184                        Variant_::StabilityDetection,
185                        Some(Variant_::StabilityDetection),
186                    ) => {
187                        let value = map.next_value()?;
188                        RangesNode::StabilityDetection(value)
189                    }
190                    (Variant_::Threshold, Some(Variant_::Threshold)) => {
191                        let value = map.next_value()?;
192                        RangesNode::Threshold(value)
193                    }
194                    (Variant_::UnionRange, Some(Variant_::UnionRange)) => {
195                        let value = map.next_value()?;
196                        RangesNode::UnionRange(value)
197                    }
198                    (Variant_::PaddedRanges, Some(Variant_::PaddedRanges)) => {
199                        let value = map.next_value()?;
200                        RangesNode::PaddedRanges(value)
201                    }
202                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
203                        if type_ == b {
204                            let value = map.next_value()?;
205                            RangesNode::Unknown(Unknown { type_, value })
206                        } else {
207                            return Err(
208                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
209                            )
210                        }
211                    }
212                    (variant, Some(key)) => {
213                        return Err(
214                            de::Error::invalid_value(
215                                de::Unexpected::Str(key.as_str()),
216                                &variant.as_str(),
217                            ),
218                        );
219                    }
220                    (variant, None) => {
221                        return Err(de::Error::missing_field(variant.as_str()));
222                    }
223                }
224            }
225            Some(UnionField_::Value(variant)) => {
226                let value = match &variant {
227                    Variant_::DurationFilter => {
228                        let value = map.next_value()?;
229                        RangesNode::DurationFilter(value)
230                    }
231                    Variant_::EnumEquality => {
232                        let value = map.next_value()?;
233                        RangesNode::EnumEquality(value)
234                    }
235                    Variant_::EnumFilter => {
236                        let value = map.next_value()?;
237                        RangesNode::EnumFilter(value)
238                    }
239                    Variant_::Extrema => {
240                        let value = map.next_value()?;
241                        RangesNode::Extrema(value)
242                    }
243                    Variant_::IntersectRange => {
244                        let value = map.next_value()?;
245                        RangesNode::IntersectRange(value)
246                    }
247                    Variant_::LiteralRanges => {
248                        let value = map.next_value()?;
249                        RangesNode::LiteralRanges(value)
250                    }
251                    Variant_::MinMaxThreshold => {
252                        let value = map.next_value()?;
253                        RangesNode::MinMaxThreshold(value)
254                    }
255                    Variant_::Not => {
256                        let value = map.next_value()?;
257                        RangesNode::Not(value)
258                    }
259                    Variant_::OnChange => {
260                        let value = map.next_value()?;
261                        RangesNode::OnChange(value)
262                    }
263                    Variant_::RangeNumericAggregation => {
264                        let value = map.next_value()?;
265                        RangesNode::RangeNumericAggregation(value)
266                    }
267                    Variant_::SeriesCrossoverRangesNode => {
268                        let value = map.next_value()?;
269                        RangesNode::SeriesCrossoverRangesNode(value)
270                    }
271                    Variant_::StaleRange => {
272                        let value = map.next_value()?;
273                        RangesNode::StaleRange(value)
274                    }
275                    Variant_::StabilityDetection => {
276                        let value = map.next_value()?;
277                        RangesNode::StabilityDetection(value)
278                    }
279                    Variant_::Threshold => {
280                        let value = map.next_value()?;
281                        RangesNode::Threshold(value)
282                    }
283                    Variant_::UnionRange => {
284                        let value = map.next_value()?;
285                        RangesNode::UnionRange(value)
286                    }
287                    Variant_::PaddedRanges => {
288                        let value = map.next_value()?;
289                        RangesNode::PaddedRanges(value)
290                    }
291                    Variant_::Unknown(type_) => {
292                        let value = map.next_value()?;
293                        RangesNode::Unknown(Unknown {
294                            type_: type_.clone(),
295                            value,
296                        })
297                    }
298                };
299                if map.next_key::<UnionTypeField_>()?.is_none() {
300                    return Err(de::Error::missing_field("type"));
301                }
302                let type_variant = map.next_value::<Variant_>()?;
303                if variant != type_variant {
304                    return Err(
305                        de::Error::invalid_value(
306                            de::Unexpected::Str(type_variant.as_str()),
307                            &variant.as_str(),
308                        ),
309                    );
310                }
311                value
312            }
313            None => return Err(de::Error::missing_field("type")),
314        };
315        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
316            return Err(de::Error::invalid_length(3, &"type and value fields"));
317        }
318        Ok(v)
319    }
320}
321#[derive(PartialEq)]
322enum Variant_ {
323    DurationFilter,
324    EnumEquality,
325    EnumFilter,
326    Extrema,
327    IntersectRange,
328    LiteralRanges,
329    MinMaxThreshold,
330    Not,
331    OnChange,
332    RangeNumericAggregation,
333    SeriesCrossoverRangesNode,
334    StaleRange,
335    StabilityDetection,
336    Threshold,
337    UnionRange,
338    PaddedRanges,
339    Unknown(Box<str>),
340}
341impl Variant_ {
342    fn as_str(&self) -> &'static str {
343        match *self {
344            Variant_::DurationFilter => "durationFilter",
345            Variant_::EnumEquality => "enumEquality",
346            Variant_::EnumFilter => "enumFilter",
347            Variant_::Extrema => "extrema",
348            Variant_::IntersectRange => "intersectRange",
349            Variant_::LiteralRanges => "literalRanges",
350            Variant_::MinMaxThreshold => "minMaxThreshold",
351            Variant_::Not => "not",
352            Variant_::OnChange => "onChange",
353            Variant_::RangeNumericAggregation => "rangeNumericAggregation",
354            Variant_::SeriesCrossoverRangesNode => "seriesCrossoverRangesNode",
355            Variant_::StaleRange => "staleRange",
356            Variant_::StabilityDetection => "stabilityDetection",
357            Variant_::Threshold => "threshold",
358            Variant_::UnionRange => "unionRange",
359            Variant_::PaddedRanges => "paddedRanges",
360            Variant_::Unknown(_) => "unknown variant",
361        }
362    }
363}
364impl<'de> de::Deserialize<'de> for Variant_ {
365    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
366    where
367        D: de::Deserializer<'de>,
368    {
369        d.deserialize_str(VariantVisitor_)
370    }
371}
372struct VariantVisitor_;
373impl<'de> de::Visitor<'de> for VariantVisitor_ {
374    type Value = Variant_;
375    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
376        fmt.write_str("string")
377    }
378    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
379    where
380        E: de::Error,
381    {
382        let v = match value {
383            "durationFilter" => Variant_::DurationFilter,
384            "enumEquality" => Variant_::EnumEquality,
385            "enumFilter" => Variant_::EnumFilter,
386            "extrema" => Variant_::Extrema,
387            "intersectRange" => Variant_::IntersectRange,
388            "literalRanges" => Variant_::LiteralRanges,
389            "minMaxThreshold" => Variant_::MinMaxThreshold,
390            "not" => Variant_::Not,
391            "onChange" => Variant_::OnChange,
392            "rangeNumericAggregation" => Variant_::RangeNumericAggregation,
393            "seriesCrossoverRangesNode" => Variant_::SeriesCrossoverRangesNode,
394            "staleRange" => Variant_::StaleRange,
395            "stabilityDetection" => Variant_::StabilityDetection,
396            "threshold" => Variant_::Threshold,
397            "unionRange" => Variant_::UnionRange,
398            "paddedRanges" => Variant_::PaddedRanges,
399            value => Variant_::Unknown(value.to_string().into_boxed_str()),
400        };
401        Ok(v)
402    }
403}
404///An unknown variant of the RangesNode union.
405#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
406pub struct Unknown {
407    type_: Box<str>,
408    value: conjure_object::Any,
409}
410impl Unknown {
411    /// Returns the unknown variant's type name.
412    #[inline]
413    pub fn type_(&self) -> &str {
414        &self.type_
415    }
416}
nominal_api_conjure/conjure/objects/scout/compute/resolved/api/ranges_node.rs

nominal_api_conjure/conjure/objects/scout/compute/resolved/api/
ranges_node.rs
