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

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