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 EnumSeries {
8 #[deprecated(
9 note = "AggregateEnumSeries is deprecated. Use `enumAggregation` with `aggregation.GroupByAggregationBuilder` instead.\n"
10 )]
11 Aggregate(super::AggregateEnumSeries),
12 Raw(super::Reference),
13 Channel(Box<super::ChannelSeries>),
14 Derived(Box<super::DerivedSeries>),
15 Resample(super::EnumResampleSeries),
16 NthPointDownsample(super::EnumNthPointDownsampleSeries),
17 TimeRangeFilter(super::EnumTimeRangeFilterSeries),
18 TimeShift(super::EnumTimeShiftSeries),
19 Union(super::EnumUnionSeries),
20 FilterTransformation(super::EnumFilterTransformationSeries),
21 ValueMap(super::ValueMapSeries),
22 Select1dArrayIndex(super::SelectIndexFrom1dEnumArraySeries),
23 ExtractFromStruct(super::ExtractEnumFromStructSeries),
24 EventAggregation(super::EventsEnumSeries),
25 EnumAggregation(super::EnumAggregation),
26 SelectEnum(super::SelectSeries),
27 FilterByTag(super::EnumTagFilterSeries),
28 SelectTags(super::EnumSelectTagsSeries),
29 ScalarUdf(super::ScalarUdfSeries),
30 ToStartOfInterval(super::EnumToStartOfIntervalSeries),
31 Unknown(Unknown),
33}
34impl ser::Serialize for EnumSeries {
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 #[allow(deprecated)]
42 EnumSeries::Aggregate(value) => {
43 map.serialize_entry(&"type", &"aggregate")?;
44 map.serialize_entry(&"aggregate", value)?;
45 }
46 EnumSeries::Raw(value) => {
47 map.serialize_entry(&"type", &"raw")?;
48 map.serialize_entry(&"raw", value)?;
49 }
50 EnumSeries::Channel(value) => {
51 map.serialize_entry(&"type", &"channel")?;
52 map.serialize_entry(&"channel", value)?;
53 }
54 EnumSeries::Derived(value) => {
55 map.serialize_entry(&"type", &"derived")?;
56 map.serialize_entry(&"derived", value)?;
57 }
58 EnumSeries::Resample(value) => {
59 map.serialize_entry(&"type", &"resample")?;
60 map.serialize_entry(&"resample", value)?;
61 }
62 EnumSeries::NthPointDownsample(value) => {
63 map.serialize_entry(&"type", &"nthPointDownsample")?;
64 map.serialize_entry(&"nthPointDownsample", value)?;
65 }
66 EnumSeries::TimeRangeFilter(value) => {
67 map.serialize_entry(&"type", &"timeRangeFilter")?;
68 map.serialize_entry(&"timeRangeFilter", value)?;
69 }
70 EnumSeries::TimeShift(value) => {
71 map.serialize_entry(&"type", &"timeShift")?;
72 map.serialize_entry(&"timeShift", value)?;
73 }
74 EnumSeries::Union(value) => {
75 map.serialize_entry(&"type", &"union")?;
76 map.serialize_entry(&"union", value)?;
77 }
78 EnumSeries::FilterTransformation(value) => {
79 map.serialize_entry(&"type", &"filterTransformation")?;
80 map.serialize_entry(&"filterTransformation", value)?;
81 }
82 EnumSeries::ValueMap(value) => {
83 map.serialize_entry(&"type", &"valueMap")?;
84 map.serialize_entry(&"valueMap", value)?;
85 }
86 EnumSeries::Select1dArrayIndex(value) => {
87 map.serialize_entry(&"type", &"select1dArrayIndex")?;
88 map.serialize_entry(&"select1dArrayIndex", value)?;
89 }
90 EnumSeries::ExtractFromStruct(value) => {
91 map.serialize_entry(&"type", &"extractFromStruct")?;
92 map.serialize_entry(&"extractFromStruct", value)?;
93 }
94 EnumSeries::EventAggregation(value) => {
95 map.serialize_entry(&"type", &"eventAggregation")?;
96 map.serialize_entry(&"eventAggregation", value)?;
97 }
98 EnumSeries::EnumAggregation(value) => {
99 map.serialize_entry(&"type", &"enumAggregation")?;
100 map.serialize_entry(&"enumAggregation", value)?;
101 }
102 EnumSeries::SelectEnum(value) => {
103 map.serialize_entry(&"type", &"selectEnum")?;
104 map.serialize_entry(&"selectEnum", value)?;
105 }
106 EnumSeries::FilterByTag(value) => {
107 map.serialize_entry(&"type", &"filterByTag")?;
108 map.serialize_entry(&"filterByTag", value)?;
109 }
110 EnumSeries::SelectTags(value) => {
111 map.serialize_entry(&"type", &"selectTags")?;
112 map.serialize_entry(&"selectTags", value)?;
113 }
114 EnumSeries::ScalarUdf(value) => {
115 map.serialize_entry(&"type", &"scalarUdf")?;
116 map.serialize_entry(&"scalarUdf", value)?;
117 }
118 EnumSeries::ToStartOfInterval(value) => {
119 map.serialize_entry(&"type", &"toStartOfInterval")?;
120 map.serialize_entry(&"toStartOfInterval", value)?;
121 }
122 EnumSeries::Unknown(value) => {
123 map.serialize_entry(&"type", &value.type_)?;
124 map.serialize_entry(&value.type_, &value.value)?;
125 }
126 }
127 map.end()
128 }
129}
130impl<'de> de::Deserialize<'de> for EnumSeries {
131 fn deserialize<D>(d: D) -> Result<EnumSeries, D::Error>
132 where
133 D: de::Deserializer<'de>,
134 {
135 d.deserialize_map(Visitor_)
136 }
137}
138struct Visitor_;
139impl<'de> de::Visitor<'de> for Visitor_ {
140 type Value = EnumSeries;
141 fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
142 fmt.write_str("union EnumSeries")
143 }
144 fn visit_map<A>(self, mut map: A) -> Result<EnumSeries, A::Error>
145 where
146 A: de::MapAccess<'de>,
147 {
148 let v = match map.next_key::<UnionField_<Variant_>>()? {
149 Some(UnionField_::Type) => {
150 let variant = map.next_value()?;
151 let key = map.next_key()?;
152 match (variant, key) {
153 #[allow(deprecated)]
154 (Variant_::Aggregate, Some(Variant_::Aggregate)) => {
155 let value = map.next_value()?;
156 EnumSeries::Aggregate(value)
157 }
158 (Variant_::Raw, Some(Variant_::Raw)) => {
159 let value = map.next_value()?;
160 EnumSeries::Raw(value)
161 }
162 (Variant_::Channel, Some(Variant_::Channel)) => {
163 let value = map.next_value()?;
164 EnumSeries::Channel(value)
165 }
166 (Variant_::Derived, Some(Variant_::Derived)) => {
167 let value = map.next_value()?;
168 EnumSeries::Derived(value)
169 }
170 (Variant_::Resample, Some(Variant_::Resample)) => {
171 let value = map.next_value()?;
172 EnumSeries::Resample(value)
173 }
174 (
175 Variant_::NthPointDownsample,
176 Some(Variant_::NthPointDownsample),
177 ) => {
178 let value = map.next_value()?;
179 EnumSeries::NthPointDownsample(value)
180 }
181 (Variant_::TimeRangeFilter, Some(Variant_::TimeRangeFilter)) => {
182 let value = map.next_value()?;
183 EnumSeries::TimeRangeFilter(value)
184 }
185 (Variant_::TimeShift, Some(Variant_::TimeShift)) => {
186 let value = map.next_value()?;
187 EnumSeries::TimeShift(value)
188 }
189 (Variant_::Union, Some(Variant_::Union)) => {
190 let value = map.next_value()?;
191 EnumSeries::Union(value)
192 }
193 (
194 Variant_::FilterTransformation,
195 Some(Variant_::FilterTransformation),
196 ) => {
197 let value = map.next_value()?;
198 EnumSeries::FilterTransformation(value)
199 }
200 (Variant_::ValueMap, Some(Variant_::ValueMap)) => {
201 let value = map.next_value()?;
202 EnumSeries::ValueMap(value)
203 }
204 (
205 Variant_::Select1dArrayIndex,
206 Some(Variant_::Select1dArrayIndex),
207 ) => {
208 let value = map.next_value()?;
209 EnumSeries::Select1dArrayIndex(value)
210 }
211 (Variant_::ExtractFromStruct, Some(Variant_::ExtractFromStruct)) => {
212 let value = map.next_value()?;
213 EnumSeries::ExtractFromStruct(value)
214 }
215 (Variant_::EventAggregation, Some(Variant_::EventAggregation)) => {
216 let value = map.next_value()?;
217 EnumSeries::EventAggregation(value)
218 }
219 (Variant_::EnumAggregation, Some(Variant_::EnumAggregation)) => {
220 let value = map.next_value()?;
221 EnumSeries::EnumAggregation(value)
222 }
223 (Variant_::SelectEnum, Some(Variant_::SelectEnum)) => {
224 let value = map.next_value()?;
225 EnumSeries::SelectEnum(value)
226 }
227 (Variant_::FilterByTag, Some(Variant_::FilterByTag)) => {
228 let value = map.next_value()?;
229 EnumSeries::FilterByTag(value)
230 }
231 (Variant_::SelectTags, Some(Variant_::SelectTags)) => {
232 let value = map.next_value()?;
233 EnumSeries::SelectTags(value)
234 }
235 (Variant_::ScalarUdf, Some(Variant_::ScalarUdf)) => {
236 let value = map.next_value()?;
237 EnumSeries::ScalarUdf(value)
238 }
239 (Variant_::ToStartOfInterval, Some(Variant_::ToStartOfInterval)) => {
240 let value = map.next_value()?;
241 EnumSeries::ToStartOfInterval(value)
242 }
243 (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
244 if type_ == b {
245 let value = map.next_value()?;
246 EnumSeries::Unknown(Unknown { type_, value })
247 } else {
248 return Err(
249 de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
250 )
251 }
252 }
253 (variant, Some(key)) => {
254 return Err(
255 de::Error::invalid_value(
256 de::Unexpected::Str(key.as_str()),
257 &variant.as_str(),
258 ),
259 );
260 }
261 (variant, None) => {
262 return Err(de::Error::missing_field(variant.as_str()));
263 }
264 }
265 }
266 Some(UnionField_::Value(variant)) => {
267 let value = match &variant {
268 Variant_::Aggregate => {
269 let value = map.next_value()?;
270 #[allow(deprecated)] EnumSeries::Aggregate(value)
271 }
272 Variant_::Raw => {
273 let value = map.next_value()?;
274 EnumSeries::Raw(value)
275 }
276 Variant_::Channel => {
277 let value = map.next_value()?;
278 EnumSeries::Channel(value)
279 }
280 Variant_::Derived => {
281 let value = map.next_value()?;
282 EnumSeries::Derived(value)
283 }
284 Variant_::Resample => {
285 let value = map.next_value()?;
286 EnumSeries::Resample(value)
287 }
288 Variant_::NthPointDownsample => {
289 let value = map.next_value()?;
290 EnumSeries::NthPointDownsample(value)
291 }
292 Variant_::TimeRangeFilter => {
293 let value = map.next_value()?;
294 EnumSeries::TimeRangeFilter(value)
295 }
296 Variant_::TimeShift => {
297 let value = map.next_value()?;
298 EnumSeries::TimeShift(value)
299 }
300 Variant_::Union => {
301 let value = map.next_value()?;
302 EnumSeries::Union(value)
303 }
304 Variant_::FilterTransformation => {
305 let value = map.next_value()?;
306 EnumSeries::FilterTransformation(value)
307 }
308 Variant_::ValueMap => {
309 let value = map.next_value()?;
310 EnumSeries::ValueMap(value)
311 }
312 Variant_::Select1dArrayIndex => {
313 let value = map.next_value()?;
314 EnumSeries::Select1dArrayIndex(value)
315 }
316 Variant_::ExtractFromStruct => {
317 let value = map.next_value()?;
318 EnumSeries::ExtractFromStruct(value)
319 }
320 Variant_::EventAggregation => {
321 let value = map.next_value()?;
322 EnumSeries::EventAggregation(value)
323 }
324 Variant_::EnumAggregation => {
325 let value = map.next_value()?;
326 EnumSeries::EnumAggregation(value)
327 }
328 Variant_::SelectEnum => {
329 let value = map.next_value()?;
330 EnumSeries::SelectEnum(value)
331 }
332 Variant_::FilterByTag => {
333 let value = map.next_value()?;
334 EnumSeries::FilterByTag(value)
335 }
336 Variant_::SelectTags => {
337 let value = map.next_value()?;
338 EnumSeries::SelectTags(value)
339 }
340 Variant_::ScalarUdf => {
341 let value = map.next_value()?;
342 EnumSeries::ScalarUdf(value)
343 }
344 Variant_::ToStartOfInterval => {
345 let value = map.next_value()?;
346 EnumSeries::ToStartOfInterval(value)
347 }
348 Variant_::Unknown(type_) => {
349 let value = map.next_value()?;
350 EnumSeries::Unknown(Unknown {
351 type_: type_.clone(),
352 value,
353 })
354 }
355 };
356 if map.next_key::<UnionTypeField_>()?.is_none() {
357 return Err(de::Error::missing_field("type"));
358 }
359 let type_variant = map.next_value::<Variant_>()?;
360 if variant != type_variant {
361 return Err(
362 de::Error::invalid_value(
363 de::Unexpected::Str(type_variant.as_str()),
364 &variant.as_str(),
365 ),
366 );
367 }
368 value
369 }
370 None => return Err(de::Error::missing_field("type")),
371 };
372 if map.next_key::<UnionField_<Variant_>>()?.is_some() {
373 return Err(de::Error::invalid_length(3, &"type and value fields"));
374 }
375 Ok(v)
376 }
377}
378#[derive(PartialEq)]
379enum Variant_ {
380 Aggregate,
381 Raw,
382 Channel,
383 Derived,
384 Resample,
385 NthPointDownsample,
386 TimeRangeFilter,
387 TimeShift,
388 Union,
389 FilterTransformation,
390 ValueMap,
391 Select1dArrayIndex,
392 ExtractFromStruct,
393 EventAggregation,
394 EnumAggregation,
395 SelectEnum,
396 FilterByTag,
397 SelectTags,
398 ScalarUdf,
399 ToStartOfInterval,
400 Unknown(Box<str>),
401}
402impl Variant_ {
403 fn as_str(&self) -> &'static str {
404 match *self {
405 Variant_::Aggregate => "aggregate",
406 Variant_::Raw => "raw",
407 Variant_::Channel => "channel",
408 Variant_::Derived => "derived",
409 Variant_::Resample => "resample",
410 Variant_::NthPointDownsample => "nthPointDownsample",
411 Variant_::TimeRangeFilter => "timeRangeFilter",
412 Variant_::TimeShift => "timeShift",
413 Variant_::Union => "union",
414 Variant_::FilterTransformation => "filterTransformation",
415 Variant_::ValueMap => "valueMap",
416 Variant_::Select1dArrayIndex => "select1dArrayIndex",
417 Variant_::ExtractFromStruct => "extractFromStruct",
418 Variant_::EventAggregation => "eventAggregation",
419 Variant_::EnumAggregation => "enumAggregation",
420 Variant_::SelectEnum => "selectEnum",
421 Variant_::FilterByTag => "filterByTag",
422 Variant_::SelectTags => "selectTags",
423 Variant_::ScalarUdf => "scalarUdf",
424 Variant_::ToStartOfInterval => "toStartOfInterval",
425 Variant_::Unknown(_) => "unknown variant",
426 }
427 }
428}
429impl<'de> de::Deserialize<'de> for Variant_ {
430 fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
431 where
432 D: de::Deserializer<'de>,
433 {
434 d.deserialize_str(VariantVisitor_)
435 }
436}
437struct VariantVisitor_;
438impl<'de> de::Visitor<'de> for VariantVisitor_ {
439 type Value = Variant_;
440 fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
441 fmt.write_str("string")
442 }
443 fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
444 where
445 E: de::Error,
446 {
447 let v = match value {
448 "aggregate" => Variant_::Aggregate,
449 "raw" => Variant_::Raw,
450 "channel" => Variant_::Channel,
451 "derived" => Variant_::Derived,
452 "resample" => Variant_::Resample,
453 "nthPointDownsample" => Variant_::NthPointDownsample,
454 "timeRangeFilter" => Variant_::TimeRangeFilter,
455 "timeShift" => Variant_::TimeShift,
456 "union" => Variant_::Union,
457 "filterTransformation" => Variant_::FilterTransformation,
458 "valueMap" => Variant_::ValueMap,
459 "select1dArrayIndex" => Variant_::Select1dArrayIndex,
460 "extractFromStruct" => Variant_::ExtractFromStruct,
461 "eventAggregation" => Variant_::EventAggregation,
462 "enumAggregation" => Variant_::EnumAggregation,
463 "selectEnum" => Variant_::SelectEnum,
464 "filterByTag" => Variant_::FilterByTag,
465 "selectTags" => Variant_::SelectTags,
466 "scalarUdf" => Variant_::ScalarUdf,
467 "toStartOfInterval" => Variant_::ToStartOfInterval,
468 value => Variant_::Unknown(value.to_string().into_boxed_str()),
469 };
470 Ok(v)
471 }
472}
473#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
475pub struct Unknown {
476 type_: Box<str>,
477 value: conjure_object::Any,
478}
479impl Unknown {
480 #[inline]
482 pub fn type_(&self) -> &str {
483 &self.type_
484 }
485}