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

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