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 ComputeNodeResponse {
8 Range(Vec<super::Range>),
9 RangesSummary(super::RangesSummary),
10 RangeValue(Option<super::Range>),
11 Numeric(super::NumericPlot),
12 BucketedNumeric(super::BucketedNumericPlot),
13 NumericPoint(Option<super::NumericPoint>),
14 SinglePoint(Option<super::SinglePoint>),
15 ArrowNumeric(super::ArrowPlot),
16 ArrowBucketedNumeric(super::ArrowPlot),
17 Enum(super::EnumPlot),
18 EnumPoint(Option<super::EnumPoint>),
19 BucketedEnum(super::BucketedEnumPlot),
20 ArrowEnum(super::ArrowPlot),
21 ArrowBucketedEnum(super::ArrowPlot),
22 PagedLog(super::PagedLogPlot),
23 LogPoint(Option<super::LogPoint>),
24 ArrowLog(super::ArrowPlot),
25 Cartesian(super::CartesianPlot),
26 BucketedCartesian(super::BucketedCartesianPlot),
27 BucketedCartesian3d(super::BucketedCartesian3dPlot),
28 FrequencyDomain(super::FrequencyDomainPlot),
29 FrequencyDomainV2(Box<super::FrequencyDomainPlotV2>),
30 BucketedFrequencyDomain(super::BucketedFrequencyDomainPlot),
31 NumericHistogram(super::NumericHistogramPlot),
32 EnumHistogram(super::EnumHistogramPlot),
33 CurveFit(super::CurveFitResult),
35 CurveFitV2(super::CurveFitResultV2),
36 Grouped(super::GroupedComputeNodeResponses),
37 Array(Box<super::ArrowArrayPlot>),
38 BucketedStruct(super::ArrowPlot),
39 ArrowStruct(super::ArrowPlot),
40 FullResolution(super::ArrowPlot),
41 ArrowBucketedMultivariate(super::ArrowPlot),
42 Multivariate(super::BucketedMultivariatePlot),
43 Unknown(Unknown),
45}
46impl ser::Serialize for ComputeNodeResponse {
47 fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
48 where
49 S: ser::Serializer,
50 {
51 let mut map = s.serialize_map(Some(2))?;
52 match self {
53 ComputeNodeResponse::Range(value) => {
54 map.serialize_entry(&"type", &"range")?;
55 map.serialize_entry(&"range", value)?;
56 }
57 ComputeNodeResponse::RangesSummary(value) => {
58 map.serialize_entry(&"type", &"rangesSummary")?;
59 map.serialize_entry(&"rangesSummary", value)?;
60 }
61 ComputeNodeResponse::RangeValue(value) => {
62 map.serialize_entry(&"type", &"rangeValue")?;
63 map.serialize_entry(&"rangeValue", value)?;
64 }
65 ComputeNodeResponse::Numeric(value) => {
66 map.serialize_entry(&"type", &"numeric")?;
67 map.serialize_entry(&"numeric", value)?;
68 }
69 ComputeNodeResponse::BucketedNumeric(value) => {
70 map.serialize_entry(&"type", &"bucketedNumeric")?;
71 map.serialize_entry(&"bucketedNumeric", value)?;
72 }
73 ComputeNodeResponse::NumericPoint(value) => {
74 map.serialize_entry(&"type", &"numericPoint")?;
75 map.serialize_entry(&"numericPoint", value)?;
76 }
77 ComputeNodeResponse::SinglePoint(value) => {
78 map.serialize_entry(&"type", &"singlePoint")?;
79 map.serialize_entry(&"singlePoint", value)?;
80 }
81 ComputeNodeResponse::ArrowNumeric(value) => {
82 map.serialize_entry(&"type", &"arrowNumeric")?;
83 map.serialize_entry(&"arrowNumeric", value)?;
84 }
85 ComputeNodeResponse::ArrowBucketedNumeric(value) => {
86 map.serialize_entry(&"type", &"arrowBucketedNumeric")?;
87 map.serialize_entry(&"arrowBucketedNumeric", value)?;
88 }
89 ComputeNodeResponse::Enum(value) => {
90 map.serialize_entry(&"type", &"enum")?;
91 map.serialize_entry(&"enum", value)?;
92 }
93 ComputeNodeResponse::EnumPoint(value) => {
94 map.serialize_entry(&"type", &"enumPoint")?;
95 map.serialize_entry(&"enumPoint", value)?;
96 }
97 ComputeNodeResponse::BucketedEnum(value) => {
98 map.serialize_entry(&"type", &"bucketedEnum")?;
99 map.serialize_entry(&"bucketedEnum", value)?;
100 }
101 ComputeNodeResponse::ArrowEnum(value) => {
102 map.serialize_entry(&"type", &"arrowEnum")?;
103 map.serialize_entry(&"arrowEnum", value)?;
104 }
105 ComputeNodeResponse::ArrowBucketedEnum(value) => {
106 map.serialize_entry(&"type", &"arrowBucketedEnum")?;
107 map.serialize_entry(&"arrowBucketedEnum", value)?;
108 }
109 ComputeNodeResponse::PagedLog(value) => {
110 map.serialize_entry(&"type", &"pagedLog")?;
111 map.serialize_entry(&"pagedLog", value)?;
112 }
113 ComputeNodeResponse::LogPoint(value) => {
114 map.serialize_entry(&"type", &"logPoint")?;
115 map.serialize_entry(&"logPoint", value)?;
116 }
117 ComputeNodeResponse::ArrowLog(value) => {
118 map.serialize_entry(&"type", &"arrowLog")?;
119 map.serialize_entry(&"arrowLog", value)?;
120 }
121 ComputeNodeResponse::Cartesian(value) => {
122 map.serialize_entry(&"type", &"cartesian")?;
123 map.serialize_entry(&"cartesian", value)?;
124 }
125 ComputeNodeResponse::BucketedCartesian(value) => {
126 map.serialize_entry(&"type", &"bucketedCartesian")?;
127 map.serialize_entry(&"bucketedCartesian", value)?;
128 }
129 ComputeNodeResponse::BucketedCartesian3d(value) => {
130 map.serialize_entry(&"type", &"bucketedCartesian3d")?;
131 map.serialize_entry(&"bucketedCartesian3d", value)?;
132 }
133 ComputeNodeResponse::FrequencyDomain(value) => {
134 map.serialize_entry(&"type", &"frequencyDomain")?;
135 map.serialize_entry(&"frequencyDomain", value)?;
136 }
137 ComputeNodeResponse::FrequencyDomainV2(value) => {
138 map.serialize_entry(&"type", &"frequencyDomainV2")?;
139 map.serialize_entry(&"frequencyDomainV2", value)?;
140 }
141 ComputeNodeResponse::BucketedFrequencyDomain(value) => {
142 map.serialize_entry(&"type", &"bucketedFrequencyDomain")?;
143 map.serialize_entry(&"bucketedFrequencyDomain", value)?;
144 }
145 ComputeNodeResponse::NumericHistogram(value) => {
146 map.serialize_entry(&"type", &"numericHistogram")?;
147 map.serialize_entry(&"numericHistogram", value)?;
148 }
149 ComputeNodeResponse::EnumHistogram(value) => {
150 map.serialize_entry(&"type", &"enumHistogram")?;
151 map.serialize_entry(&"enumHistogram", value)?;
152 }
153 ComputeNodeResponse::CurveFit(value) => {
154 map.serialize_entry(&"type", &"curveFit")?;
155 map.serialize_entry(&"curveFit", value)?;
156 }
157 ComputeNodeResponse::CurveFitV2(value) => {
158 map.serialize_entry(&"type", &"curveFitV2")?;
159 map.serialize_entry(&"curveFitV2", value)?;
160 }
161 ComputeNodeResponse::Grouped(value) => {
162 map.serialize_entry(&"type", &"grouped")?;
163 map.serialize_entry(&"grouped", value)?;
164 }
165 ComputeNodeResponse::Array(value) => {
166 map.serialize_entry(&"type", &"array")?;
167 map.serialize_entry(&"array", value)?;
168 }
169 ComputeNodeResponse::BucketedStruct(value) => {
170 map.serialize_entry(&"type", &"bucketedStruct")?;
171 map.serialize_entry(&"bucketedStruct", value)?;
172 }
173 ComputeNodeResponse::ArrowStruct(value) => {
174 map.serialize_entry(&"type", &"arrowStruct")?;
175 map.serialize_entry(&"arrowStruct", value)?;
176 }
177 ComputeNodeResponse::FullResolution(value) => {
178 map.serialize_entry(&"type", &"fullResolution")?;
179 map.serialize_entry(&"fullResolution", value)?;
180 }
181 ComputeNodeResponse::ArrowBucketedMultivariate(value) => {
182 map.serialize_entry(&"type", &"arrowBucketedMultivariate")?;
183 map.serialize_entry(&"arrowBucketedMultivariate", value)?;
184 }
185 ComputeNodeResponse::Multivariate(value) => {
186 map.serialize_entry(&"type", &"multivariate")?;
187 map.serialize_entry(&"multivariate", value)?;
188 }
189 ComputeNodeResponse::Unknown(value) => {
190 map.serialize_entry(&"type", &value.type_)?;
191 map.serialize_entry(&value.type_, &value.value)?;
192 }
193 }
194 map.end()
195 }
196}
197impl<'de> de::Deserialize<'de> for ComputeNodeResponse {
198 fn deserialize<D>(d: D) -> Result<ComputeNodeResponse, D::Error>
199 where
200 D: de::Deserializer<'de>,
201 {
202 d.deserialize_map(Visitor_)
203 }
204}
205struct Visitor_;
206impl<'de> de::Visitor<'de> for Visitor_ {
207 type Value = ComputeNodeResponse;
208 fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
209 fmt.write_str("union ComputeNodeResponse")
210 }
211 fn visit_map<A>(self, mut map: A) -> Result<ComputeNodeResponse, A::Error>
212 where
213 A: de::MapAccess<'de>,
214 {
215 let v = match map.next_key::<UnionField_<Variant_>>()? {
216 Some(UnionField_::Type) => {
217 let variant = map.next_value()?;
218 let key = map.next_key()?;
219 match (variant, key) {
220 (Variant_::Range, Some(Variant_::Range)) => {
221 let value = map.next_value()?;
222 ComputeNodeResponse::Range(value)
223 }
224 (Variant_::RangesSummary, Some(Variant_::RangesSummary)) => {
225 let value = map.next_value()?;
226 ComputeNodeResponse::RangesSummary(value)
227 }
228 (Variant_::RangeValue, Some(Variant_::RangeValue)) => {
229 let value = map.next_value()?;
230 ComputeNodeResponse::RangeValue(value)
231 }
232 (Variant_::Numeric, Some(Variant_::Numeric)) => {
233 let value = map.next_value()?;
234 ComputeNodeResponse::Numeric(value)
235 }
236 (Variant_::BucketedNumeric, Some(Variant_::BucketedNumeric)) => {
237 let value = map.next_value()?;
238 ComputeNodeResponse::BucketedNumeric(value)
239 }
240 (Variant_::NumericPoint, Some(Variant_::NumericPoint)) => {
241 let value = map.next_value()?;
242 ComputeNodeResponse::NumericPoint(value)
243 }
244 (Variant_::SinglePoint, Some(Variant_::SinglePoint)) => {
245 let value = map.next_value()?;
246 ComputeNodeResponse::SinglePoint(value)
247 }
248 (Variant_::ArrowNumeric, Some(Variant_::ArrowNumeric)) => {
249 let value = map.next_value()?;
250 ComputeNodeResponse::ArrowNumeric(value)
251 }
252 (
253 Variant_::ArrowBucketedNumeric,
254 Some(Variant_::ArrowBucketedNumeric),
255 ) => {
256 let value = map.next_value()?;
257 ComputeNodeResponse::ArrowBucketedNumeric(value)
258 }
259 (Variant_::Enum, Some(Variant_::Enum)) => {
260 let value = map.next_value()?;
261 ComputeNodeResponse::Enum(value)
262 }
263 (Variant_::EnumPoint, Some(Variant_::EnumPoint)) => {
264 let value = map.next_value()?;
265 ComputeNodeResponse::EnumPoint(value)
266 }
267 (Variant_::BucketedEnum, Some(Variant_::BucketedEnum)) => {
268 let value = map.next_value()?;
269 ComputeNodeResponse::BucketedEnum(value)
270 }
271 (Variant_::ArrowEnum, Some(Variant_::ArrowEnum)) => {
272 let value = map.next_value()?;
273 ComputeNodeResponse::ArrowEnum(value)
274 }
275 (Variant_::ArrowBucketedEnum, Some(Variant_::ArrowBucketedEnum)) => {
276 let value = map.next_value()?;
277 ComputeNodeResponse::ArrowBucketedEnum(value)
278 }
279 (Variant_::PagedLog, Some(Variant_::PagedLog)) => {
280 let value = map.next_value()?;
281 ComputeNodeResponse::PagedLog(value)
282 }
283 (Variant_::LogPoint, Some(Variant_::LogPoint)) => {
284 let value = map.next_value()?;
285 ComputeNodeResponse::LogPoint(value)
286 }
287 (Variant_::ArrowLog, Some(Variant_::ArrowLog)) => {
288 let value = map.next_value()?;
289 ComputeNodeResponse::ArrowLog(value)
290 }
291 (Variant_::Cartesian, Some(Variant_::Cartesian)) => {
292 let value = map.next_value()?;
293 ComputeNodeResponse::Cartesian(value)
294 }
295 (Variant_::BucketedCartesian, Some(Variant_::BucketedCartesian)) => {
296 let value = map.next_value()?;
297 ComputeNodeResponse::BucketedCartesian(value)
298 }
299 (
300 Variant_::BucketedCartesian3d,
301 Some(Variant_::BucketedCartesian3d),
302 ) => {
303 let value = map.next_value()?;
304 ComputeNodeResponse::BucketedCartesian3d(value)
305 }
306 (Variant_::FrequencyDomain, Some(Variant_::FrequencyDomain)) => {
307 let value = map.next_value()?;
308 ComputeNodeResponse::FrequencyDomain(value)
309 }
310 (Variant_::FrequencyDomainV2, Some(Variant_::FrequencyDomainV2)) => {
311 let value = map.next_value()?;
312 ComputeNodeResponse::FrequencyDomainV2(value)
313 }
314 (
315 Variant_::BucketedFrequencyDomain,
316 Some(Variant_::BucketedFrequencyDomain),
317 ) => {
318 let value = map.next_value()?;
319 ComputeNodeResponse::BucketedFrequencyDomain(value)
320 }
321 (Variant_::NumericHistogram, Some(Variant_::NumericHistogram)) => {
322 let value = map.next_value()?;
323 ComputeNodeResponse::NumericHistogram(value)
324 }
325 (Variant_::EnumHistogram, Some(Variant_::EnumHistogram)) => {
326 let value = map.next_value()?;
327 ComputeNodeResponse::EnumHistogram(value)
328 }
329 (Variant_::CurveFit, Some(Variant_::CurveFit)) => {
330 let value = map.next_value()?;
331 ComputeNodeResponse::CurveFit(value)
332 }
333 (Variant_::CurveFitV2, Some(Variant_::CurveFitV2)) => {
334 let value = map.next_value()?;
335 ComputeNodeResponse::CurveFitV2(value)
336 }
337 (Variant_::Grouped, Some(Variant_::Grouped)) => {
338 let value = map.next_value()?;
339 ComputeNodeResponse::Grouped(value)
340 }
341 (Variant_::Array, Some(Variant_::Array)) => {
342 let value = map.next_value()?;
343 ComputeNodeResponse::Array(value)
344 }
345 (Variant_::BucketedStruct, Some(Variant_::BucketedStruct)) => {
346 let value = map.next_value()?;
347 ComputeNodeResponse::BucketedStruct(value)
348 }
349 (Variant_::ArrowStruct, Some(Variant_::ArrowStruct)) => {
350 let value = map.next_value()?;
351 ComputeNodeResponse::ArrowStruct(value)
352 }
353 (Variant_::FullResolution, Some(Variant_::FullResolution)) => {
354 let value = map.next_value()?;
355 ComputeNodeResponse::FullResolution(value)
356 }
357 (
358 Variant_::ArrowBucketedMultivariate,
359 Some(Variant_::ArrowBucketedMultivariate),
360 ) => {
361 let value = map.next_value()?;
362 ComputeNodeResponse::ArrowBucketedMultivariate(value)
363 }
364 (Variant_::Multivariate, Some(Variant_::Multivariate)) => {
365 let value = map.next_value()?;
366 ComputeNodeResponse::Multivariate(value)
367 }
368 (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
369 if type_ == b {
370 let value = map.next_value()?;
371 ComputeNodeResponse::Unknown(Unknown { type_, value })
372 } else {
373 return Err(
374 de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
375 )
376 }
377 }
378 (variant, Some(key)) => {
379 return Err(
380 de::Error::invalid_value(
381 de::Unexpected::Str(key.as_str()),
382 &variant.as_str(),
383 ),
384 );
385 }
386 (variant, None) => {
387 return Err(de::Error::missing_field(variant.as_str()));
388 }
389 }
390 }
391 Some(UnionField_::Value(variant)) => {
392 let value = match &variant {
393 Variant_::Range => {
394 let value = map.next_value()?;
395 ComputeNodeResponse::Range(value)
396 }
397 Variant_::RangesSummary => {
398 let value = map.next_value()?;
399 ComputeNodeResponse::RangesSummary(value)
400 }
401 Variant_::RangeValue => {
402 let value = map.next_value()?;
403 ComputeNodeResponse::RangeValue(value)
404 }
405 Variant_::Numeric => {
406 let value = map.next_value()?;
407 ComputeNodeResponse::Numeric(value)
408 }
409 Variant_::BucketedNumeric => {
410 let value = map.next_value()?;
411 ComputeNodeResponse::BucketedNumeric(value)
412 }
413 Variant_::NumericPoint => {
414 let value = map.next_value()?;
415 ComputeNodeResponse::NumericPoint(value)
416 }
417 Variant_::SinglePoint => {
418 let value = map.next_value()?;
419 ComputeNodeResponse::SinglePoint(value)
420 }
421 Variant_::ArrowNumeric => {
422 let value = map.next_value()?;
423 ComputeNodeResponse::ArrowNumeric(value)
424 }
425 Variant_::ArrowBucketedNumeric => {
426 let value = map.next_value()?;
427 ComputeNodeResponse::ArrowBucketedNumeric(value)
428 }
429 Variant_::Enum => {
430 let value = map.next_value()?;
431 ComputeNodeResponse::Enum(value)
432 }
433 Variant_::EnumPoint => {
434 let value = map.next_value()?;
435 ComputeNodeResponse::EnumPoint(value)
436 }
437 Variant_::BucketedEnum => {
438 let value = map.next_value()?;
439 ComputeNodeResponse::BucketedEnum(value)
440 }
441 Variant_::ArrowEnum => {
442 let value = map.next_value()?;
443 ComputeNodeResponse::ArrowEnum(value)
444 }
445 Variant_::ArrowBucketedEnum => {
446 let value = map.next_value()?;
447 ComputeNodeResponse::ArrowBucketedEnum(value)
448 }
449 Variant_::PagedLog => {
450 let value = map.next_value()?;
451 ComputeNodeResponse::PagedLog(value)
452 }
453 Variant_::LogPoint => {
454 let value = map.next_value()?;
455 ComputeNodeResponse::LogPoint(value)
456 }
457 Variant_::ArrowLog => {
458 let value = map.next_value()?;
459 ComputeNodeResponse::ArrowLog(value)
460 }
461 Variant_::Cartesian => {
462 let value = map.next_value()?;
463 ComputeNodeResponse::Cartesian(value)
464 }
465 Variant_::BucketedCartesian => {
466 let value = map.next_value()?;
467 ComputeNodeResponse::BucketedCartesian(value)
468 }
469 Variant_::BucketedCartesian3d => {
470 let value = map.next_value()?;
471 ComputeNodeResponse::BucketedCartesian3d(value)
472 }
473 Variant_::FrequencyDomain => {
474 let value = map.next_value()?;
475 ComputeNodeResponse::FrequencyDomain(value)
476 }
477 Variant_::FrequencyDomainV2 => {
478 let value = map.next_value()?;
479 ComputeNodeResponse::FrequencyDomainV2(value)
480 }
481 Variant_::BucketedFrequencyDomain => {
482 let value = map.next_value()?;
483 ComputeNodeResponse::BucketedFrequencyDomain(value)
484 }
485 Variant_::NumericHistogram => {
486 let value = map.next_value()?;
487 ComputeNodeResponse::NumericHistogram(value)
488 }
489 Variant_::EnumHistogram => {
490 let value = map.next_value()?;
491 ComputeNodeResponse::EnumHistogram(value)
492 }
493 Variant_::CurveFit => {
494 let value = map.next_value()?;
495 ComputeNodeResponse::CurveFit(value)
496 }
497 Variant_::CurveFitV2 => {
498 let value = map.next_value()?;
499 ComputeNodeResponse::CurveFitV2(value)
500 }
501 Variant_::Grouped => {
502 let value = map.next_value()?;
503 ComputeNodeResponse::Grouped(value)
504 }
505 Variant_::Array => {
506 let value = map.next_value()?;
507 ComputeNodeResponse::Array(value)
508 }
509 Variant_::BucketedStruct => {
510 let value = map.next_value()?;
511 ComputeNodeResponse::BucketedStruct(value)
512 }
513 Variant_::ArrowStruct => {
514 let value = map.next_value()?;
515 ComputeNodeResponse::ArrowStruct(value)
516 }
517 Variant_::FullResolution => {
518 let value = map.next_value()?;
519 ComputeNodeResponse::FullResolution(value)
520 }
521 Variant_::ArrowBucketedMultivariate => {
522 let value = map.next_value()?;
523 ComputeNodeResponse::ArrowBucketedMultivariate(value)
524 }
525 Variant_::Multivariate => {
526 let value = map.next_value()?;
527 ComputeNodeResponse::Multivariate(value)
528 }
529 Variant_::Unknown(type_) => {
530 let value = map.next_value()?;
531 ComputeNodeResponse::Unknown(Unknown {
532 type_: type_.clone(),
533 value,
534 })
535 }
536 };
537 if map.next_key::<UnionTypeField_>()?.is_none() {
538 return Err(de::Error::missing_field("type"));
539 }
540 let type_variant = map.next_value::<Variant_>()?;
541 if variant != type_variant {
542 return Err(
543 de::Error::invalid_value(
544 de::Unexpected::Str(type_variant.as_str()),
545 &variant.as_str(),
546 ),
547 );
548 }
549 value
550 }
551 None => return Err(de::Error::missing_field("type")),
552 };
553 if map.next_key::<UnionField_<Variant_>>()?.is_some() {
554 return Err(de::Error::invalid_length(3, &"type and value fields"));
555 }
556 Ok(v)
557 }
558}
559#[derive(PartialEq)]
560enum Variant_ {
561 Range,
562 RangesSummary,
563 RangeValue,
564 Numeric,
565 BucketedNumeric,
566 NumericPoint,
567 SinglePoint,
568 ArrowNumeric,
569 ArrowBucketedNumeric,
570 Enum,
571 EnumPoint,
572 BucketedEnum,
573 ArrowEnum,
574 ArrowBucketedEnum,
575 PagedLog,
576 LogPoint,
577 ArrowLog,
578 Cartesian,
579 BucketedCartesian,
580 BucketedCartesian3d,
581 FrequencyDomain,
582 FrequencyDomainV2,
583 BucketedFrequencyDomain,
584 NumericHistogram,
585 EnumHistogram,
586 CurveFit,
587 CurveFitV2,
588 Grouped,
589 Array,
590 BucketedStruct,
591 ArrowStruct,
592 FullResolution,
593 ArrowBucketedMultivariate,
594 Multivariate,
595 Unknown(Box<str>),
596}
597impl Variant_ {
598 fn as_str(&self) -> &'static str {
599 match *self {
600 Variant_::Range => "range",
601 Variant_::RangesSummary => "rangesSummary",
602 Variant_::RangeValue => "rangeValue",
603 Variant_::Numeric => "numeric",
604 Variant_::BucketedNumeric => "bucketedNumeric",
605 Variant_::NumericPoint => "numericPoint",
606 Variant_::SinglePoint => "singlePoint",
607 Variant_::ArrowNumeric => "arrowNumeric",
608 Variant_::ArrowBucketedNumeric => "arrowBucketedNumeric",
609 Variant_::Enum => "enum",
610 Variant_::EnumPoint => "enumPoint",
611 Variant_::BucketedEnum => "bucketedEnum",
612 Variant_::ArrowEnum => "arrowEnum",
613 Variant_::ArrowBucketedEnum => "arrowBucketedEnum",
614 Variant_::PagedLog => "pagedLog",
615 Variant_::LogPoint => "logPoint",
616 Variant_::ArrowLog => "arrowLog",
617 Variant_::Cartesian => "cartesian",
618 Variant_::BucketedCartesian => "bucketedCartesian",
619 Variant_::BucketedCartesian3d => "bucketedCartesian3d",
620 Variant_::FrequencyDomain => "frequencyDomain",
621 Variant_::FrequencyDomainV2 => "frequencyDomainV2",
622 Variant_::BucketedFrequencyDomain => "bucketedFrequencyDomain",
623 Variant_::NumericHistogram => "numericHistogram",
624 Variant_::EnumHistogram => "enumHistogram",
625 Variant_::CurveFit => "curveFit",
626 Variant_::CurveFitV2 => "curveFitV2",
627 Variant_::Grouped => "grouped",
628 Variant_::Array => "array",
629 Variant_::BucketedStruct => "bucketedStruct",
630 Variant_::ArrowStruct => "arrowStruct",
631 Variant_::FullResolution => "fullResolution",
632 Variant_::ArrowBucketedMultivariate => "arrowBucketedMultivariate",
633 Variant_::Multivariate => "multivariate",
634 Variant_::Unknown(_) => "unknown variant",
635 }
636 }
637}
638impl<'de> de::Deserialize<'de> for Variant_ {
639 fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
640 where
641 D: de::Deserializer<'de>,
642 {
643 d.deserialize_str(VariantVisitor_)
644 }
645}
646struct VariantVisitor_;
647impl<'de> de::Visitor<'de> for VariantVisitor_ {
648 type Value = Variant_;
649 fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
650 fmt.write_str("string")
651 }
652 fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
653 where
654 E: de::Error,
655 {
656 let v = match value {
657 "range" => Variant_::Range,
658 "rangesSummary" => Variant_::RangesSummary,
659 "rangeValue" => Variant_::RangeValue,
660 "numeric" => Variant_::Numeric,
661 "bucketedNumeric" => Variant_::BucketedNumeric,
662 "numericPoint" => Variant_::NumericPoint,
663 "singlePoint" => Variant_::SinglePoint,
664 "arrowNumeric" => Variant_::ArrowNumeric,
665 "arrowBucketedNumeric" => Variant_::ArrowBucketedNumeric,
666 "enum" => Variant_::Enum,
667 "enumPoint" => Variant_::EnumPoint,
668 "bucketedEnum" => Variant_::BucketedEnum,
669 "arrowEnum" => Variant_::ArrowEnum,
670 "arrowBucketedEnum" => Variant_::ArrowBucketedEnum,
671 "pagedLog" => Variant_::PagedLog,
672 "logPoint" => Variant_::LogPoint,
673 "arrowLog" => Variant_::ArrowLog,
674 "cartesian" => Variant_::Cartesian,
675 "bucketedCartesian" => Variant_::BucketedCartesian,
676 "bucketedCartesian3d" => Variant_::BucketedCartesian3d,
677 "frequencyDomain" => Variant_::FrequencyDomain,
678 "frequencyDomainV2" => Variant_::FrequencyDomainV2,
679 "bucketedFrequencyDomain" => Variant_::BucketedFrequencyDomain,
680 "numericHistogram" => Variant_::NumericHistogram,
681 "enumHistogram" => Variant_::EnumHistogram,
682 "curveFit" => Variant_::CurveFit,
683 "curveFitV2" => Variant_::CurveFitV2,
684 "grouped" => Variant_::Grouped,
685 "array" => Variant_::Array,
686 "bucketedStruct" => Variant_::BucketedStruct,
687 "arrowStruct" => Variant_::ArrowStruct,
688 "fullResolution" => Variant_::FullResolution,
689 "arrowBucketedMultivariate" => Variant_::ArrowBucketedMultivariate,
690 "multivariate" => Variant_::Multivariate,
691 value => Variant_::Unknown(value.to_string().into_boxed_str()),
692 };
693 Ok(v)
694 }
695}
696#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
698pub struct Unknown {
699 type_: Box<str>,
700 value: conjure_object::Any,
701}
702impl Unknown {
703 #[inline]
705 pub fn type_(&self) -> &str {
706 &self.type_
707 }
708}