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

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