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