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

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