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