nominal_api/conjure/objects/scout/compute/api/
range_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 RangeSeries {
8    ApproximateThreshold(super::ApproximateThresholdRanges),
9    BooleanToRanges(super::BooleanToRanges),
10    DurationFilter(super::DurationFilterRanges),
11    EnumFilter(super::EnumFilterRanges),
12    EnumSeriesEqualityRangesNode(super::EnumSeriesEqualityRanges),
13    EventsSearch(super::EventsSearchRanges),
14    IntersectRange(super::IntersectRanges),
15    LiteralRanges(super::LiteralRanges),
16    /// Computes ranges where the input time series matches a filter defined by lower and upper bounds, and an operator.
17    MinMaxThreshold(super::MinMaxThresholdRanges),
18    Not(super::NotRanges),
19    OnChange(super::OnChangeRanges),
20    Peak(super::PeakRanges),
21    RangeNumericAggregation(super::RangesNumericAggregation),
22    Raw(super::Reference),
23    Derived(Box<super::DerivedSeries>),
24    SeriesCrossoverRangesNode(super::SeriesCrossoverRanges),
25    SeriesEqualityRangesNode(super::SeriesEqualityRanges),
26    StabilityDetection(super::StabilityDetectionRanges),
27    StaleRange(super::StaleRanges),
28    /// Computes ranges where the input time series matches a filter defined by a single threshold and an operator.
29    Threshold(super::ThresholdingRanges),
30    UnionRange(super::UnionRanges),
31    PaddedRanges(super::PaddedRanges),
32    /// An unknown variant.
33    Unknown(Unknown),
34}
35impl ser::Serialize for RangeSeries {
36    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
37    where
38        S: ser::Serializer,
39    {
40        let mut map = s.serialize_map(Some(2))?;
41        match self {
42            RangeSeries::ApproximateThreshold(value) => {
43                map.serialize_entry(&"type", &"approximateThreshold")?;
44                map.serialize_entry(&"approximateThreshold", value)?;
45            }
46            RangeSeries::BooleanToRanges(value) => {
47                map.serialize_entry(&"type", &"booleanToRanges")?;
48                map.serialize_entry(&"booleanToRanges", value)?;
49            }
50            RangeSeries::DurationFilter(value) => {
51                map.serialize_entry(&"type", &"durationFilter")?;
52                map.serialize_entry(&"durationFilter", value)?;
53            }
54            RangeSeries::EnumFilter(value) => {
55                map.serialize_entry(&"type", &"enumFilter")?;
56                map.serialize_entry(&"enumFilter", value)?;
57            }
58            RangeSeries::EnumSeriesEqualityRangesNode(value) => {
59                map.serialize_entry(&"type", &"enumSeriesEqualityRangesNode")?;
60                map.serialize_entry(&"enumSeriesEqualityRangesNode", value)?;
61            }
62            RangeSeries::EventsSearch(value) => {
63                map.serialize_entry(&"type", &"eventsSearch")?;
64                map.serialize_entry(&"eventsSearch", value)?;
65            }
66            RangeSeries::IntersectRange(value) => {
67                map.serialize_entry(&"type", &"intersectRange")?;
68                map.serialize_entry(&"intersectRange", value)?;
69            }
70            RangeSeries::LiteralRanges(value) => {
71                map.serialize_entry(&"type", &"literalRanges")?;
72                map.serialize_entry(&"literalRanges", value)?;
73            }
74            RangeSeries::MinMaxThreshold(value) => {
75                map.serialize_entry(&"type", &"minMaxThreshold")?;
76                map.serialize_entry(&"minMaxThreshold", value)?;
77            }
78            RangeSeries::Not(value) => {
79                map.serialize_entry(&"type", &"not")?;
80                map.serialize_entry(&"not", value)?;
81            }
82            RangeSeries::OnChange(value) => {
83                map.serialize_entry(&"type", &"onChange")?;
84                map.serialize_entry(&"onChange", value)?;
85            }
86            RangeSeries::Peak(value) => {
87                map.serialize_entry(&"type", &"peak")?;
88                map.serialize_entry(&"peak", value)?;
89            }
90            RangeSeries::RangeNumericAggregation(value) => {
91                map.serialize_entry(&"type", &"rangeNumericAggregation")?;
92                map.serialize_entry(&"rangeNumericAggregation", value)?;
93            }
94            RangeSeries::Raw(value) => {
95                map.serialize_entry(&"type", &"raw")?;
96                map.serialize_entry(&"raw", value)?;
97            }
98            RangeSeries::Derived(value) => {
99                map.serialize_entry(&"type", &"derived")?;
100                map.serialize_entry(&"derived", value)?;
101            }
102            RangeSeries::SeriesCrossoverRangesNode(value) => {
103                map.serialize_entry(&"type", &"seriesCrossoverRangesNode")?;
104                map.serialize_entry(&"seriesCrossoverRangesNode", value)?;
105            }
106            RangeSeries::SeriesEqualityRangesNode(value) => {
107                map.serialize_entry(&"type", &"seriesEqualityRangesNode")?;
108                map.serialize_entry(&"seriesEqualityRangesNode", value)?;
109            }
110            RangeSeries::StabilityDetection(value) => {
111                map.serialize_entry(&"type", &"stabilityDetection")?;
112                map.serialize_entry(&"stabilityDetection", value)?;
113            }
114            RangeSeries::StaleRange(value) => {
115                map.serialize_entry(&"type", &"staleRange")?;
116                map.serialize_entry(&"staleRange", value)?;
117            }
118            RangeSeries::Threshold(value) => {
119                map.serialize_entry(&"type", &"threshold")?;
120                map.serialize_entry(&"threshold", value)?;
121            }
122            RangeSeries::UnionRange(value) => {
123                map.serialize_entry(&"type", &"unionRange")?;
124                map.serialize_entry(&"unionRange", value)?;
125            }
126            RangeSeries::PaddedRanges(value) => {
127                map.serialize_entry(&"type", &"paddedRanges")?;
128                map.serialize_entry(&"paddedRanges", value)?;
129            }
130            RangeSeries::Unknown(value) => {
131                map.serialize_entry(&"type", &value.type_)?;
132                map.serialize_entry(&value.type_, &value.value)?;
133            }
134        }
135        map.end()
136    }
137}
138impl<'de> de::Deserialize<'de> for RangeSeries {
139    fn deserialize<D>(d: D) -> Result<RangeSeries, D::Error>
140    where
141        D: de::Deserializer<'de>,
142    {
143        d.deserialize_map(Visitor_)
144    }
145}
146struct Visitor_;
147impl<'de> de::Visitor<'de> for Visitor_ {
148    type Value = RangeSeries;
149    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
150        fmt.write_str("union RangeSeries")
151    }
152    fn visit_map<A>(self, mut map: A) -> Result<RangeSeries, A::Error>
153    where
154        A: de::MapAccess<'de>,
155    {
156        let v = match map.next_key::<UnionField_<Variant_>>()? {
157            Some(UnionField_::Type) => {
158                let variant = map.next_value()?;
159                let key = map.next_key()?;
160                match (variant, key) {
161                    (
162                        Variant_::ApproximateThreshold,
163                        Some(Variant_::ApproximateThreshold),
164                    ) => {
165                        let value = map.next_value()?;
166                        RangeSeries::ApproximateThreshold(value)
167                    }
168                    (Variant_::BooleanToRanges, Some(Variant_::BooleanToRanges)) => {
169                        let value = map.next_value()?;
170                        RangeSeries::BooleanToRanges(value)
171                    }
172                    (Variant_::DurationFilter, Some(Variant_::DurationFilter)) => {
173                        let value = map.next_value()?;
174                        RangeSeries::DurationFilter(value)
175                    }
176                    (Variant_::EnumFilter, Some(Variant_::EnumFilter)) => {
177                        let value = map.next_value()?;
178                        RangeSeries::EnumFilter(value)
179                    }
180                    (
181                        Variant_::EnumSeriesEqualityRangesNode,
182                        Some(Variant_::EnumSeriesEqualityRangesNode),
183                    ) => {
184                        let value = map.next_value()?;
185                        RangeSeries::EnumSeriesEqualityRangesNode(value)
186                    }
187                    (Variant_::EventsSearch, Some(Variant_::EventsSearch)) => {
188                        let value = map.next_value()?;
189                        RangeSeries::EventsSearch(value)
190                    }
191                    (Variant_::IntersectRange, Some(Variant_::IntersectRange)) => {
192                        let value = map.next_value()?;
193                        RangeSeries::IntersectRange(value)
194                    }
195                    (Variant_::LiteralRanges, Some(Variant_::LiteralRanges)) => {
196                        let value = map.next_value()?;
197                        RangeSeries::LiteralRanges(value)
198                    }
199                    (Variant_::MinMaxThreshold, Some(Variant_::MinMaxThreshold)) => {
200                        let value = map.next_value()?;
201                        RangeSeries::MinMaxThreshold(value)
202                    }
203                    (Variant_::Not, Some(Variant_::Not)) => {
204                        let value = map.next_value()?;
205                        RangeSeries::Not(value)
206                    }
207                    (Variant_::OnChange, Some(Variant_::OnChange)) => {
208                        let value = map.next_value()?;
209                        RangeSeries::OnChange(value)
210                    }
211                    (Variant_::Peak, Some(Variant_::Peak)) => {
212                        let value = map.next_value()?;
213                        RangeSeries::Peak(value)
214                    }
215                    (
216                        Variant_::RangeNumericAggregation,
217                        Some(Variant_::RangeNumericAggregation),
218                    ) => {
219                        let value = map.next_value()?;
220                        RangeSeries::RangeNumericAggregation(value)
221                    }
222                    (Variant_::Raw, Some(Variant_::Raw)) => {
223                        let value = map.next_value()?;
224                        RangeSeries::Raw(value)
225                    }
226                    (Variant_::Derived, Some(Variant_::Derived)) => {
227                        let value = map.next_value()?;
228                        RangeSeries::Derived(value)
229                    }
230                    (
231                        Variant_::SeriesCrossoverRangesNode,
232                        Some(Variant_::SeriesCrossoverRangesNode),
233                    ) => {
234                        let value = map.next_value()?;
235                        RangeSeries::SeriesCrossoverRangesNode(value)
236                    }
237                    (
238                        Variant_::SeriesEqualityRangesNode,
239                        Some(Variant_::SeriesEqualityRangesNode),
240                    ) => {
241                        let value = map.next_value()?;
242                        RangeSeries::SeriesEqualityRangesNode(value)
243                    }
244                    (
245                        Variant_::StabilityDetection,
246                        Some(Variant_::StabilityDetection),
247                    ) => {
248                        let value = map.next_value()?;
249                        RangeSeries::StabilityDetection(value)
250                    }
251                    (Variant_::StaleRange, Some(Variant_::StaleRange)) => {
252                        let value = map.next_value()?;
253                        RangeSeries::StaleRange(value)
254                    }
255                    (Variant_::Threshold, Some(Variant_::Threshold)) => {
256                        let value = map.next_value()?;
257                        RangeSeries::Threshold(value)
258                    }
259                    (Variant_::UnionRange, Some(Variant_::UnionRange)) => {
260                        let value = map.next_value()?;
261                        RangeSeries::UnionRange(value)
262                    }
263                    (Variant_::PaddedRanges, Some(Variant_::PaddedRanges)) => {
264                        let value = map.next_value()?;
265                        RangeSeries::PaddedRanges(value)
266                    }
267                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
268                        if type_ == b {
269                            let value = map.next_value()?;
270                            RangeSeries::Unknown(Unknown { type_, value })
271                        } else {
272                            return Err(
273                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
274                            )
275                        }
276                    }
277                    (variant, Some(key)) => {
278                        return Err(
279                            de::Error::invalid_value(
280                                de::Unexpected::Str(key.as_str()),
281                                &variant.as_str(),
282                            ),
283                        );
284                    }
285                    (variant, None) => {
286                        return Err(de::Error::missing_field(variant.as_str()));
287                    }
288                }
289            }
290            Some(UnionField_::Value(variant)) => {
291                let value = match &variant {
292                    Variant_::ApproximateThreshold => {
293                        let value = map.next_value()?;
294                        RangeSeries::ApproximateThreshold(value)
295                    }
296                    Variant_::BooleanToRanges => {
297                        let value = map.next_value()?;
298                        RangeSeries::BooleanToRanges(value)
299                    }
300                    Variant_::DurationFilter => {
301                        let value = map.next_value()?;
302                        RangeSeries::DurationFilter(value)
303                    }
304                    Variant_::EnumFilter => {
305                        let value = map.next_value()?;
306                        RangeSeries::EnumFilter(value)
307                    }
308                    Variant_::EnumSeriesEqualityRangesNode => {
309                        let value = map.next_value()?;
310                        RangeSeries::EnumSeriesEqualityRangesNode(value)
311                    }
312                    Variant_::EventsSearch => {
313                        let value = map.next_value()?;
314                        RangeSeries::EventsSearch(value)
315                    }
316                    Variant_::IntersectRange => {
317                        let value = map.next_value()?;
318                        RangeSeries::IntersectRange(value)
319                    }
320                    Variant_::LiteralRanges => {
321                        let value = map.next_value()?;
322                        RangeSeries::LiteralRanges(value)
323                    }
324                    Variant_::MinMaxThreshold => {
325                        let value = map.next_value()?;
326                        RangeSeries::MinMaxThreshold(value)
327                    }
328                    Variant_::Not => {
329                        let value = map.next_value()?;
330                        RangeSeries::Not(value)
331                    }
332                    Variant_::OnChange => {
333                        let value = map.next_value()?;
334                        RangeSeries::OnChange(value)
335                    }
336                    Variant_::Peak => {
337                        let value = map.next_value()?;
338                        RangeSeries::Peak(value)
339                    }
340                    Variant_::RangeNumericAggregation => {
341                        let value = map.next_value()?;
342                        RangeSeries::RangeNumericAggregation(value)
343                    }
344                    Variant_::Raw => {
345                        let value = map.next_value()?;
346                        RangeSeries::Raw(value)
347                    }
348                    Variant_::Derived => {
349                        let value = map.next_value()?;
350                        RangeSeries::Derived(value)
351                    }
352                    Variant_::SeriesCrossoverRangesNode => {
353                        let value = map.next_value()?;
354                        RangeSeries::SeriesCrossoverRangesNode(value)
355                    }
356                    Variant_::SeriesEqualityRangesNode => {
357                        let value = map.next_value()?;
358                        RangeSeries::SeriesEqualityRangesNode(value)
359                    }
360                    Variant_::StabilityDetection => {
361                        let value = map.next_value()?;
362                        RangeSeries::StabilityDetection(value)
363                    }
364                    Variant_::StaleRange => {
365                        let value = map.next_value()?;
366                        RangeSeries::StaleRange(value)
367                    }
368                    Variant_::Threshold => {
369                        let value = map.next_value()?;
370                        RangeSeries::Threshold(value)
371                    }
372                    Variant_::UnionRange => {
373                        let value = map.next_value()?;
374                        RangeSeries::UnionRange(value)
375                    }
376                    Variant_::PaddedRanges => {
377                        let value = map.next_value()?;
378                        RangeSeries::PaddedRanges(value)
379                    }
380                    Variant_::Unknown(type_) => {
381                        let value = map.next_value()?;
382                        RangeSeries::Unknown(Unknown {
383                            type_: type_.clone(),
384                            value,
385                        })
386                    }
387                };
388                if map.next_key::<UnionTypeField_>()?.is_none() {
389                    return Err(de::Error::missing_field("type"));
390                }
391                let type_variant = map.next_value::<Variant_>()?;
392                if variant != type_variant {
393                    return Err(
394                        de::Error::invalid_value(
395                            de::Unexpected::Str(type_variant.as_str()),
396                            &variant.as_str(),
397                        ),
398                    );
399                }
400                value
401            }
402            None => return Err(de::Error::missing_field("type")),
403        };
404        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
405            return Err(de::Error::invalid_length(3, &"type and value fields"));
406        }
407        Ok(v)
408    }
409}
410#[derive(PartialEq)]
411enum Variant_ {
412    ApproximateThreshold,
413    BooleanToRanges,
414    DurationFilter,
415    EnumFilter,
416    EnumSeriesEqualityRangesNode,
417    EventsSearch,
418    IntersectRange,
419    LiteralRanges,
420    MinMaxThreshold,
421    Not,
422    OnChange,
423    Peak,
424    RangeNumericAggregation,
425    Raw,
426    Derived,
427    SeriesCrossoverRangesNode,
428    SeriesEqualityRangesNode,
429    StabilityDetection,
430    StaleRange,
431    Threshold,
432    UnionRange,
433    PaddedRanges,
434    Unknown(Box<str>),
435}
436impl Variant_ {
437    fn as_str(&self) -> &'static str {
438        match *self {
439            Variant_::ApproximateThreshold => "approximateThreshold",
440            Variant_::BooleanToRanges => "booleanToRanges",
441            Variant_::DurationFilter => "durationFilter",
442            Variant_::EnumFilter => "enumFilter",
443            Variant_::EnumSeriesEqualityRangesNode => "enumSeriesEqualityRangesNode",
444            Variant_::EventsSearch => "eventsSearch",
445            Variant_::IntersectRange => "intersectRange",
446            Variant_::LiteralRanges => "literalRanges",
447            Variant_::MinMaxThreshold => "minMaxThreshold",
448            Variant_::Not => "not",
449            Variant_::OnChange => "onChange",
450            Variant_::Peak => "peak",
451            Variant_::RangeNumericAggregation => "rangeNumericAggregation",
452            Variant_::Raw => "raw",
453            Variant_::Derived => "derived",
454            Variant_::SeriesCrossoverRangesNode => "seriesCrossoverRangesNode",
455            Variant_::SeriesEqualityRangesNode => "seriesEqualityRangesNode",
456            Variant_::StabilityDetection => "stabilityDetection",
457            Variant_::StaleRange => "staleRange",
458            Variant_::Threshold => "threshold",
459            Variant_::UnionRange => "unionRange",
460            Variant_::PaddedRanges => "paddedRanges",
461            Variant_::Unknown(_) => "unknown variant",
462        }
463    }
464}
465impl<'de> de::Deserialize<'de> for Variant_ {
466    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
467    where
468        D: de::Deserializer<'de>,
469    {
470        d.deserialize_str(VariantVisitor_)
471    }
472}
473struct VariantVisitor_;
474impl<'de> de::Visitor<'de> for VariantVisitor_ {
475    type Value = Variant_;
476    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
477        fmt.write_str("string")
478    }
479    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
480    where
481        E: de::Error,
482    {
483        let v = match value {
484            "approximateThreshold" => Variant_::ApproximateThreshold,
485            "booleanToRanges" => Variant_::BooleanToRanges,
486            "durationFilter" => Variant_::DurationFilter,
487            "enumFilter" => Variant_::EnumFilter,
488            "enumSeriesEqualityRangesNode" => Variant_::EnumSeriesEqualityRangesNode,
489            "eventsSearch" => Variant_::EventsSearch,
490            "intersectRange" => Variant_::IntersectRange,
491            "literalRanges" => Variant_::LiteralRanges,
492            "minMaxThreshold" => Variant_::MinMaxThreshold,
493            "not" => Variant_::Not,
494            "onChange" => Variant_::OnChange,
495            "peak" => Variant_::Peak,
496            "rangeNumericAggregation" => Variant_::RangeNumericAggregation,
497            "raw" => Variant_::Raw,
498            "derived" => Variant_::Derived,
499            "seriesCrossoverRangesNode" => Variant_::SeriesCrossoverRangesNode,
500            "seriesEqualityRangesNode" => Variant_::SeriesEqualityRangesNode,
501            "stabilityDetection" => Variant_::StabilityDetection,
502            "staleRange" => Variant_::StaleRange,
503            "threshold" => Variant_::Threshold,
504            "unionRange" => Variant_::UnionRange,
505            "paddedRanges" => Variant_::PaddedRanges,
506            value => Variant_::Unknown(value.to_string().into_boxed_str()),
507        };
508        Ok(v)
509    }
510}
511///An unknown variant of the RangeSeries union.
512#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
513pub struct Unknown {
514    type_: Box<str>,
515    value: conjure_object::Any,
516}
517impl Unknown {
518    /// Returns the unknown variant's type name.
519    #[inline]
520    pub fn type_(&self) -> &str {
521        &self.type_
522    }
523}
nominal_api/conjure/objects/scout/compute/api/range_series.rs

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