nominal_api/conjure/objects/scout/comparisonnotebook/api/
comparison_scatter_plot_definition.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 ComparisonScatterPlotDefinition {
8    V1(super::ComparisonScatterPlotDefinitionV1),
9    /// An unknown variant.
10    Unknown(Unknown),
11}
12impl ser::Serialize for ComparisonScatterPlotDefinition {
13    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
14    where
15        S: ser::Serializer,
16    {
17        let mut map = s.serialize_map(Some(2))?;
18        match self {
19            ComparisonScatterPlotDefinition::V1(value) => {
20                map.serialize_entry(&"type", &"v1")?;
21                map.serialize_entry(&"v1", value)?;
22            }
23            ComparisonScatterPlotDefinition::Unknown(value) => {
24                map.serialize_entry(&"type", &value.type_)?;
25                map.serialize_entry(&value.type_, &value.value)?;
26            }
27        }
28        map.end()
29    }
30}
31impl<'de> de::Deserialize<'de> for ComparisonScatterPlotDefinition {
32    fn deserialize<D>(d: D) -> Result<ComparisonScatterPlotDefinition, D::Error>
33    where
34        D: de::Deserializer<'de>,
35    {
36        d.deserialize_map(Visitor_)
37    }
38}
39struct Visitor_;
40impl<'de> de::Visitor<'de> for Visitor_ {
41    type Value = ComparisonScatterPlotDefinition;
42    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
43        fmt.write_str("union ComparisonScatterPlotDefinition")
44    }
45    fn visit_map<A>(
46        self,
47        mut map: A,
48    ) -> Result<ComparisonScatterPlotDefinition, A::Error>
49    where
50        A: de::MapAccess<'de>,
51    {
52        let v = match map.next_key::<UnionField_<Variant_>>()? {
53            Some(UnionField_::Type) => {
54                let variant = map.next_value()?;
55                let key = map.next_key()?;
56                match (variant, key) {
57                    (Variant_::V1, Some(Variant_::V1)) => {
58                        let value = map.next_value()?;
59                        ComparisonScatterPlotDefinition::V1(value)
60                    }
61                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
62                        if type_ == b {
63                            let value = map.next_value()?;
64                            ComparisonScatterPlotDefinition::Unknown(Unknown {
65                                type_,
66                                value,
67                            })
68                        } else {
69                            return Err(
70                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
71                            )
72                        }
73                    }
74                    (variant, Some(key)) => {
75                        return Err(
76                            de::Error::invalid_value(
77                                de::Unexpected::Str(key.as_str()),
78                                &variant.as_str(),
79                            ),
80                        );
81                    }
82                    (variant, None) => {
83                        return Err(de::Error::missing_field(variant.as_str()));
84                    }
85                }
86            }
87            Some(UnionField_::Value(variant)) => {
88                let value = match &variant {
89                    Variant_::V1 => {
90                        let value = map.next_value()?;
91                        ComparisonScatterPlotDefinition::V1(value)
92                    }
93                    Variant_::Unknown(type_) => {
94                        let value = map.next_value()?;
95                        ComparisonScatterPlotDefinition::Unknown(Unknown {
96                            type_: type_.clone(),
97                            value,
98                        })
99                    }
100                };
101                if map.next_key::<UnionTypeField_>()?.is_none() {
102                    return Err(de::Error::missing_field("type"));
103                }
104                let type_variant = map.next_value::<Variant_>()?;
105                if variant != type_variant {
106                    return Err(
107                        de::Error::invalid_value(
108                            de::Unexpected::Str(type_variant.as_str()),
109                            &variant.as_str(),
110                        ),
111                    );
112                }
113                value
114            }
115            None => return Err(de::Error::missing_field("type")),
116        };
117        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
118            return Err(de::Error::invalid_length(3, &"type and value fields"));
119        }
120        Ok(v)
121    }
122}
123#[derive(PartialEq)]
124enum Variant_ {
125    V1,
126    Unknown(Box<str>),
127}
128impl Variant_ {
129    fn as_str(&self) -> &'static str {
130        match *self {
131            Variant_::V1 => "v1",
132            Variant_::Unknown(_) => "unknown variant",
133        }
134    }
135}
136impl<'de> de::Deserialize<'de> for Variant_ {
137    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
138    where
139        D: de::Deserializer<'de>,
140    {
141        d.deserialize_str(VariantVisitor_)
142    }
143}
144struct VariantVisitor_;
145impl<'de> de::Visitor<'de> for VariantVisitor_ {
146    type Value = Variant_;
147    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
148        fmt.write_str("string")
149    }
150    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
151    where
152        E: de::Error,
153    {
154        let v = match value {
155            "v1" => Variant_::V1,
156            value => Variant_::Unknown(value.to_string().into_boxed_str()),
157        };
158        Ok(v)
159    }
160}
161///An unknown variant of the ComparisonScatterPlotDefinition union.
162#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
163pub struct Unknown {
164    type_: Box<str>,
165    value: conjure_object::Any,
166}
167impl Unknown {
168    /// Returns the unknown variant's type name.
169    #[inline]
170    pub fn type_(&self) -> &str {
171        &self.type_
172    }
173}
nominal_api/conjure/objects/scout/comparisonnotebook/api/comparison_scatter_plot_definition.rs

nominal_api/conjure/objects/scout/comparisonnotebook/api/
comparison_scatter_plot_definition.rs
