nominal_api/conjure/objects/scout/compute/api/deprecated/
numeric_series_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 NumericSeriesNode {
8    Raw(super::super::Reference),
9    Arithmetic(super::ArithmeticSeriesNode),
10    BitOperation(super::BitOperationSeriesNode),
11    CumulativeSum(super::CumulativeSumSeriesNode),
12    Derivative(super::DerivativeSeriesNode),
13    RollingOperation(super::RollingOperationSeriesNode),
14    UnaryArithmetic(super::UnaryArithmeticSeriesNode),
15    TimeDifference(super::TimeDifferenceSeriesNode),
16    TimeRangeFilter(super::NumericTimeRangeFilterSeriesNode),
17    TimeShift(super::NumericTimeShiftSeriesNode),
18    Union(super::NumericUnionSeriesNode),
19    ValueDifference(super::ValueDifferenceSeriesNode),
20    /// An unknown variant.
21    Unknown(Unknown),
22}
23impl ser::Serialize for NumericSeriesNode {
24    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
25    where
26        S: ser::Serializer,
27    {
28        let mut map = s.serialize_map(Some(2))?;
29        match self {
30            NumericSeriesNode::Raw(value) => {
31                map.serialize_entry(&"type", &"raw")?;
32                map.serialize_entry(&"raw", value)?;
33            }
34            NumericSeriesNode::Arithmetic(value) => {
35                map.serialize_entry(&"type", &"arithmetic")?;
36                map.serialize_entry(&"arithmetic", value)?;
37            }
38            NumericSeriesNode::BitOperation(value) => {
39                map.serialize_entry(&"type", &"bitOperation")?;
40                map.serialize_entry(&"bitOperation", value)?;
41            }
42            NumericSeriesNode::CumulativeSum(value) => {
43                map.serialize_entry(&"type", &"cumulativeSum")?;
44                map.serialize_entry(&"cumulativeSum", value)?;
45            }
46            NumericSeriesNode::Derivative(value) => {
47                map.serialize_entry(&"type", &"derivative")?;
48                map.serialize_entry(&"derivative", value)?;
49            }
50            NumericSeriesNode::RollingOperation(value) => {
51                map.serialize_entry(&"type", &"rollingOperation")?;
52                map.serialize_entry(&"rollingOperation", value)?;
53            }
54            NumericSeriesNode::UnaryArithmetic(value) => {
55                map.serialize_entry(&"type", &"unaryArithmetic")?;
56                map.serialize_entry(&"unaryArithmetic", value)?;
57            }
58            NumericSeriesNode::TimeDifference(value) => {
59                map.serialize_entry(&"type", &"timeDifference")?;
60                map.serialize_entry(&"timeDifference", value)?;
61            }
62            NumericSeriesNode::TimeRangeFilter(value) => {
63                map.serialize_entry(&"type", &"timeRangeFilter")?;
64                map.serialize_entry(&"timeRangeFilter", value)?;
65            }
66            NumericSeriesNode::TimeShift(value) => {
67                map.serialize_entry(&"type", &"timeShift")?;
68                map.serialize_entry(&"timeShift", value)?;
69            }
70            NumericSeriesNode::Union(value) => {
71                map.serialize_entry(&"type", &"union")?;
72                map.serialize_entry(&"union", value)?;
73            }
74            NumericSeriesNode::ValueDifference(value) => {
75                map.serialize_entry(&"type", &"valueDifference")?;
76                map.serialize_entry(&"valueDifference", value)?;
77            }
78            NumericSeriesNode::Unknown(value) => {
79                map.serialize_entry(&"type", &value.type_)?;
80                map.serialize_entry(&value.type_, &value.value)?;
81            }
82        }
83        map.end()
84    }
85}
86impl<'de> de::Deserialize<'de> for NumericSeriesNode {
87    fn deserialize<D>(d: D) -> Result<NumericSeriesNode, D::Error>
88    where
89        D: de::Deserializer<'de>,
90    {
91        d.deserialize_map(Visitor_)
92    }
93}
94struct Visitor_;
95impl<'de> de::Visitor<'de> for Visitor_ {
96    type Value = NumericSeriesNode;
97    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
98        fmt.write_str("union NumericSeriesNode")
99    }
100    fn visit_map<A>(self, mut map: A) -> Result<NumericSeriesNode, A::Error>
101    where
102        A: de::MapAccess<'de>,
103    {
104        let v = match map.next_key::<UnionField_<Variant_>>()? {
105            Some(UnionField_::Type) => {
106                let variant = map.next_value()?;
107                let key = map.next_key()?;
108                match (variant, key) {
109                    (Variant_::Raw, Some(Variant_::Raw)) => {
110                        let value = map.next_value()?;
111                        NumericSeriesNode::Raw(value)
112                    }
113                    (Variant_::Arithmetic, Some(Variant_::Arithmetic)) => {
114                        let value = map.next_value()?;
115                        NumericSeriesNode::Arithmetic(value)
116                    }
117                    (Variant_::BitOperation, Some(Variant_::BitOperation)) => {
118                        let value = map.next_value()?;
119                        NumericSeriesNode::BitOperation(value)
120                    }
121                    (Variant_::CumulativeSum, Some(Variant_::CumulativeSum)) => {
122                        let value = map.next_value()?;
123                        NumericSeriesNode::CumulativeSum(value)
124                    }
125                    (Variant_::Derivative, Some(Variant_::Derivative)) => {
126                        let value = map.next_value()?;
127                        NumericSeriesNode::Derivative(value)
128                    }
129                    (Variant_::RollingOperation, Some(Variant_::RollingOperation)) => {
130                        let value = map.next_value()?;
131                        NumericSeriesNode::RollingOperation(value)
132                    }
133                    (Variant_::UnaryArithmetic, Some(Variant_::UnaryArithmetic)) => {
134                        let value = map.next_value()?;
135                        NumericSeriesNode::UnaryArithmetic(value)
136                    }
137                    (Variant_::TimeDifference, Some(Variant_::TimeDifference)) => {
138                        let value = map.next_value()?;
139                        NumericSeriesNode::TimeDifference(value)
140                    }
141                    (Variant_::TimeRangeFilter, Some(Variant_::TimeRangeFilter)) => {
142                        let value = map.next_value()?;
143                        NumericSeriesNode::TimeRangeFilter(value)
144                    }
145                    (Variant_::TimeShift, Some(Variant_::TimeShift)) => {
146                        let value = map.next_value()?;
147                        NumericSeriesNode::TimeShift(value)
148                    }
149                    (Variant_::Union, Some(Variant_::Union)) => {
150                        let value = map.next_value()?;
151                        NumericSeriesNode::Union(value)
152                    }
153                    (Variant_::ValueDifference, Some(Variant_::ValueDifference)) => {
154                        let value = map.next_value()?;
155                        NumericSeriesNode::ValueDifference(value)
156                    }
157                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
158                        if type_ == b {
159                            let value = map.next_value()?;
160                            NumericSeriesNode::Unknown(Unknown { type_, value })
161                        } else {
162                            return Err(
163                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
164                            )
165                        }
166                    }
167                    (variant, Some(key)) => {
168                        return Err(
169                            de::Error::invalid_value(
170                                de::Unexpected::Str(key.as_str()),
171                                &variant.as_str(),
172                            ),
173                        );
174                    }
175                    (variant, None) => {
176                        return Err(de::Error::missing_field(variant.as_str()));
177                    }
178                }
179            }
180            Some(UnionField_::Value(variant)) => {
181                let value = match &variant {
182                    Variant_::Raw => {
183                        let value = map.next_value()?;
184                        NumericSeriesNode::Raw(value)
185                    }
186                    Variant_::Arithmetic => {
187                        let value = map.next_value()?;
188                        NumericSeriesNode::Arithmetic(value)
189                    }
190                    Variant_::BitOperation => {
191                        let value = map.next_value()?;
192                        NumericSeriesNode::BitOperation(value)
193                    }
194                    Variant_::CumulativeSum => {
195                        let value = map.next_value()?;
196                        NumericSeriesNode::CumulativeSum(value)
197                    }
198                    Variant_::Derivative => {
199                        let value = map.next_value()?;
200                        NumericSeriesNode::Derivative(value)
201                    }
202                    Variant_::RollingOperation => {
203                        let value = map.next_value()?;
204                        NumericSeriesNode::RollingOperation(value)
205                    }
206                    Variant_::UnaryArithmetic => {
207                        let value = map.next_value()?;
208                        NumericSeriesNode::UnaryArithmetic(value)
209                    }
210                    Variant_::TimeDifference => {
211                        let value = map.next_value()?;
212                        NumericSeriesNode::TimeDifference(value)
213                    }
214                    Variant_::TimeRangeFilter => {
215                        let value = map.next_value()?;
216                        NumericSeriesNode::TimeRangeFilter(value)
217                    }
218                    Variant_::TimeShift => {
219                        let value = map.next_value()?;
220                        NumericSeriesNode::TimeShift(value)
221                    }
222                    Variant_::Union => {
223                        let value = map.next_value()?;
224                        NumericSeriesNode::Union(value)
225                    }
226                    Variant_::ValueDifference => {
227                        let value = map.next_value()?;
228                        NumericSeriesNode::ValueDifference(value)
229                    }
230                    Variant_::Unknown(type_) => {
231                        let value = map.next_value()?;
232                        NumericSeriesNode::Unknown(Unknown {
233                            type_: type_.clone(),
234                            value,
235                        })
236                    }
237                };
238                if map.next_key::<UnionTypeField_>()?.is_none() {
239                    return Err(de::Error::missing_field("type"));
240                }
241                let type_variant = map.next_value::<Variant_>()?;
242                if variant != type_variant {
243                    return Err(
244                        de::Error::invalid_value(
245                            de::Unexpected::Str(type_variant.as_str()),
246                            &variant.as_str(),
247                        ),
248                    );
249                }
250                value
251            }
252            None => return Err(de::Error::missing_field("type")),
253        };
254        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
255            return Err(de::Error::invalid_length(3, &"type and value fields"));
256        }
257        Ok(v)
258    }
259}
260#[derive(PartialEq)]
261enum Variant_ {
262    Raw,
263    Arithmetic,
264    BitOperation,
265    CumulativeSum,
266    Derivative,
267    RollingOperation,
268    UnaryArithmetic,
269    TimeDifference,
270    TimeRangeFilter,
271    TimeShift,
272    Union,
273    ValueDifference,
274    Unknown(Box<str>),
275}
276impl Variant_ {
277    fn as_str(&self) -> &'static str {
278        match *self {
279            Variant_::Raw => "raw",
280            Variant_::Arithmetic => "arithmetic",
281            Variant_::BitOperation => "bitOperation",
282            Variant_::CumulativeSum => "cumulativeSum",
283            Variant_::Derivative => "derivative",
284            Variant_::RollingOperation => "rollingOperation",
285            Variant_::UnaryArithmetic => "unaryArithmetic",
286            Variant_::TimeDifference => "timeDifference",
287            Variant_::TimeRangeFilter => "timeRangeFilter",
288            Variant_::TimeShift => "timeShift",
289            Variant_::Union => "union",
290            Variant_::ValueDifference => "valueDifference",
291            Variant_::Unknown(_) => "unknown variant",
292        }
293    }
294}
295impl<'de> de::Deserialize<'de> for Variant_ {
296    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
297    where
298        D: de::Deserializer<'de>,
299    {
300        d.deserialize_str(VariantVisitor_)
301    }
302}
303struct VariantVisitor_;
304impl<'de> de::Visitor<'de> for VariantVisitor_ {
305    type Value = Variant_;
306    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
307        fmt.write_str("string")
308    }
309    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
310    where
311        E: de::Error,
312    {
313        let v = match value {
314            "raw" => Variant_::Raw,
315            "arithmetic" => Variant_::Arithmetic,
316            "bitOperation" => Variant_::BitOperation,
317            "cumulativeSum" => Variant_::CumulativeSum,
318            "derivative" => Variant_::Derivative,
319            "rollingOperation" => Variant_::RollingOperation,
320            "unaryArithmetic" => Variant_::UnaryArithmetic,
321            "timeDifference" => Variant_::TimeDifference,
322            "timeRangeFilter" => Variant_::TimeRangeFilter,
323            "timeShift" => Variant_::TimeShift,
324            "union" => Variant_::Union,
325            "valueDifference" => Variant_::ValueDifference,
326            value => Variant_::Unknown(value.to_string().into_boxed_str()),
327        };
328        Ok(v)
329    }
330}
331///An unknown variant of the NumericSeriesNode union.
332#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
333pub struct Unknown {
334    type_: Box<str>,
335    value: conjure_object::Any,
336}
337impl Unknown {
338    /// Returns the unknown variant's type name.
339    #[inline]
340    pub fn type_(&self) -> &str {
341        &self.type_
342    }
343}
nominal_api/conjure/objects/scout/compute/api/deprecated/numeric_series_node.rs

nominal_api/conjure/objects/scout/compute/api/deprecated/
numeric_series_node.rs
