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

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