nominal_api/conjure/objects/scout/compute/api/
numeric1d_array_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 Numeric1dArraySeries {
8    Channel(Box<super::ChannelSeries>),
9    Raw(super::Reference),
10    Derived(Box<super::DerivedSeries>),
11    SelectNumeric1dArray(super::SelectSeries),
12    ToStartOfInterval(super::Numeric1dArrayToStartOfIntervalSeries),
13    TimeShift(super::Numeric1dArrayTimeShiftSeries),
14    FilterByTag(super::Numeric1dArrayTagFilterSeries),
15    SelectTags(super::Numeric1dArraySelectTagsSeries),
16    /// An unknown variant.
17    Unknown(Unknown),
18}
19impl ser::Serialize for Numeric1dArraySeries {
20    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
21    where
22        S: ser::Serializer,
23    {
24        let mut map = s.serialize_map(Some(2))?;
25        match self {
26            Numeric1dArraySeries::Channel(value) => {
27                map.serialize_entry(&"type", &"channel")?;
28                map.serialize_entry(&"channel", value)?;
29            }
30            Numeric1dArraySeries::Raw(value) => {
31                map.serialize_entry(&"type", &"raw")?;
32                map.serialize_entry(&"raw", value)?;
33            }
34            Numeric1dArraySeries::Derived(value) => {
35                map.serialize_entry(&"type", &"derived")?;
36                map.serialize_entry(&"derived", value)?;
37            }
38            Numeric1dArraySeries::SelectNumeric1dArray(value) => {
39                map.serialize_entry(&"type", &"selectNumeric1dArray")?;
40                map.serialize_entry(&"selectNumeric1dArray", value)?;
41            }
42            Numeric1dArraySeries::ToStartOfInterval(value) => {
43                map.serialize_entry(&"type", &"toStartOfInterval")?;
44                map.serialize_entry(&"toStartOfInterval", value)?;
45            }
46            Numeric1dArraySeries::TimeShift(value) => {
47                map.serialize_entry(&"type", &"timeShift")?;
48                map.serialize_entry(&"timeShift", value)?;
49            }
50            Numeric1dArraySeries::FilterByTag(value) => {
51                map.serialize_entry(&"type", &"filterByTag")?;
52                map.serialize_entry(&"filterByTag", value)?;
53            }
54            Numeric1dArraySeries::SelectTags(value) => {
55                map.serialize_entry(&"type", &"selectTags")?;
56                map.serialize_entry(&"selectTags", value)?;
57            }
58            Numeric1dArraySeries::Unknown(value) => {
59                map.serialize_entry(&"type", &value.type_)?;
60                map.serialize_entry(&value.type_, &value.value)?;
61            }
62        }
63        map.end()
64    }
65}
66impl<'de> de::Deserialize<'de> for Numeric1dArraySeries {
67    fn deserialize<D>(d: D) -> Result<Numeric1dArraySeries, D::Error>
68    where
69        D: de::Deserializer<'de>,
70    {
71        d.deserialize_map(Visitor_)
72    }
73}
74struct Visitor_;
75impl<'de> de::Visitor<'de> for Visitor_ {
76    type Value = Numeric1dArraySeries;
77    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
78        fmt.write_str("union Numeric1dArraySeries")
79    }
80    fn visit_map<A>(self, mut map: A) -> Result<Numeric1dArraySeries, A::Error>
81    where
82        A: de::MapAccess<'de>,
83    {
84        let v = match map.next_key::<UnionField_<Variant_>>()? {
85            Some(UnionField_::Type) => {
86                let variant = map.next_value()?;
87                let key = map.next_key()?;
88                match (variant, key) {
89                    (Variant_::Channel, Some(Variant_::Channel)) => {
90                        let value = map.next_value()?;
91                        Numeric1dArraySeries::Channel(value)
92                    }
93                    (Variant_::Raw, Some(Variant_::Raw)) => {
94                        let value = map.next_value()?;
95                        Numeric1dArraySeries::Raw(value)
96                    }
97                    (Variant_::Derived, Some(Variant_::Derived)) => {
98                        let value = map.next_value()?;
99                        Numeric1dArraySeries::Derived(value)
100                    }
101                    (
102                        Variant_::SelectNumeric1dArray,
103                        Some(Variant_::SelectNumeric1dArray),
104                    ) => {
105                        let value = map.next_value()?;
106                        Numeric1dArraySeries::SelectNumeric1dArray(value)
107                    }
108                    (Variant_::ToStartOfInterval, Some(Variant_::ToStartOfInterval)) => {
109                        let value = map.next_value()?;
110                        Numeric1dArraySeries::ToStartOfInterval(value)
111                    }
112                    (Variant_::TimeShift, Some(Variant_::TimeShift)) => {
113                        let value = map.next_value()?;
114                        Numeric1dArraySeries::TimeShift(value)
115                    }
116                    (Variant_::FilterByTag, Some(Variant_::FilterByTag)) => {
117                        let value = map.next_value()?;
118                        Numeric1dArraySeries::FilterByTag(value)
119                    }
120                    (Variant_::SelectTags, Some(Variant_::SelectTags)) => {
121                        let value = map.next_value()?;
122                        Numeric1dArraySeries::SelectTags(value)
123                    }
124                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
125                        if type_ == b {
126                            let value = map.next_value()?;
127                            Numeric1dArraySeries::Unknown(Unknown { type_, value })
128                        } else {
129                            return Err(
130                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
131                            )
132                        }
133                    }
134                    (variant, Some(key)) => {
135                        return Err(
136                            de::Error::invalid_value(
137                                de::Unexpected::Str(key.as_str()),
138                                &variant.as_str(),
139                            ),
140                        );
141                    }
142                    (variant, None) => {
143                        return Err(de::Error::missing_field(variant.as_str()));
144                    }
145                }
146            }
147            Some(UnionField_::Value(variant)) => {
148                let value = match &variant {
149                    Variant_::Channel => {
150                        let value = map.next_value()?;
151                        Numeric1dArraySeries::Channel(value)
152                    }
153                    Variant_::Raw => {
154                        let value = map.next_value()?;
155                        Numeric1dArraySeries::Raw(value)
156                    }
157                    Variant_::Derived => {
158                        let value = map.next_value()?;
159                        Numeric1dArraySeries::Derived(value)
160                    }
161                    Variant_::SelectNumeric1dArray => {
162                        let value = map.next_value()?;
163                        Numeric1dArraySeries::SelectNumeric1dArray(value)
164                    }
165                    Variant_::ToStartOfInterval => {
166                        let value = map.next_value()?;
167                        Numeric1dArraySeries::ToStartOfInterval(value)
168                    }
169                    Variant_::TimeShift => {
170                        let value = map.next_value()?;
171                        Numeric1dArraySeries::TimeShift(value)
172                    }
173                    Variant_::FilterByTag => {
174                        let value = map.next_value()?;
175                        Numeric1dArraySeries::FilterByTag(value)
176                    }
177                    Variant_::SelectTags => {
178                        let value = map.next_value()?;
179                        Numeric1dArraySeries::SelectTags(value)
180                    }
181                    Variant_::Unknown(type_) => {
182                        let value = map.next_value()?;
183                        Numeric1dArraySeries::Unknown(Unknown {
184                            type_: type_.clone(),
185                            value,
186                        })
187                    }
188                };
189                if map.next_key::<UnionTypeField_>()?.is_none() {
190                    return Err(de::Error::missing_field("type"));
191                }
192                let type_variant = map.next_value::<Variant_>()?;
193                if variant != type_variant {
194                    return Err(
195                        de::Error::invalid_value(
196                            de::Unexpected::Str(type_variant.as_str()),
197                            &variant.as_str(),
198                        ),
199                    );
200                }
201                value
202            }
203            None => return Err(de::Error::missing_field("type")),
204        };
205        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
206            return Err(de::Error::invalid_length(3, &"type and value fields"));
207        }
208        Ok(v)
209    }
210}
211#[derive(PartialEq)]
212enum Variant_ {
213    Channel,
214    Raw,
215    Derived,
216    SelectNumeric1dArray,
217    ToStartOfInterval,
218    TimeShift,
219    FilterByTag,
220    SelectTags,
221    Unknown(Box<str>),
222}
223impl Variant_ {
224    fn as_str(&self) -> &'static str {
225        match *self {
226            Variant_::Channel => "channel",
227            Variant_::Raw => "raw",
228            Variant_::Derived => "derived",
229            Variant_::SelectNumeric1dArray => "selectNumeric1dArray",
230            Variant_::ToStartOfInterval => "toStartOfInterval",
231            Variant_::TimeShift => "timeShift",
232            Variant_::FilterByTag => "filterByTag",
233            Variant_::SelectTags => "selectTags",
234            Variant_::Unknown(_) => "unknown variant",
235        }
236    }
237}
238impl<'de> de::Deserialize<'de> for Variant_ {
239    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
240    where
241        D: de::Deserializer<'de>,
242    {
243        d.deserialize_str(VariantVisitor_)
244    }
245}
246struct VariantVisitor_;
247impl<'de> de::Visitor<'de> for VariantVisitor_ {
248    type Value = Variant_;
249    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
250        fmt.write_str("string")
251    }
252    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
253    where
254        E: de::Error,
255    {
256        let v = match value {
257            "channel" => Variant_::Channel,
258            "raw" => Variant_::Raw,
259            "derived" => Variant_::Derived,
260            "selectNumeric1dArray" => Variant_::SelectNumeric1dArray,
261            "toStartOfInterval" => Variant_::ToStartOfInterval,
262            "timeShift" => Variant_::TimeShift,
263            "filterByTag" => Variant_::FilterByTag,
264            "selectTags" => Variant_::SelectTags,
265            value => Variant_::Unknown(value.to_string().into_boxed_str()),
266        };
267        Ok(v)
268    }
269}
270///An unknown variant of the Numeric1dArraySeries union.
271#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
272pub struct Unknown {
273    type_: Box<str>,
274    value: conjure_object::Any,
275}
276impl Unknown {
277    /// Returns the unknown variant's type name.
278    #[inline]
279    pub fn type_(&self) -> &str {
280        &self.type_
281    }
282}
nominal_api/conjure/objects/scout/compute/api/numeric1d_array_series.rs

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