nominal_api/conjure/objects/scout/chartdefinition/api/
viz_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 VizDefinition {
8    Cartesian(Box<super::CartesianChartDefinition>),
9    Checklist(Box<super::ChecklistChartDefinition>),
10    Frequency(Box<super::FrequencyChartDefinition>),
11    Geo(Box<super::GeoVizDefinition>),
12    Geo3d(Box<super::Geo3dDefinition>),
13    Histogram(Box<super::HistogramChartDefinition>),
14    Log(Box<super::LogPanelDefinition>),
15    Markdown(Box<super::MarkdownPanelDefinition>),
16    Plotly(Box<super::PlotlyPanelDefinition>),
17    Procedure(Box<super::ProcedureVizDefinition>),
18    TimeSeries(Box<super::TimeSeriesChartDefinition>),
19    TimeSeriesTable(Box<super::TimeSeriesTablePanelDefinition>),
20    ValueTable(Box<super::ValueTableDefinition>),
21    Video(Box<super::VideoVizDefinition>),
22    /// An unknown variant.
23    Unknown(Unknown),
24}
25impl ser::Serialize for VizDefinition {
26    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
27    where
28        S: ser::Serializer,
29    {
30        let mut map = s.serialize_map(Some(2))?;
31        match self {
32            VizDefinition::Cartesian(value) => {
33                map.serialize_entry(&"type", &"cartesian")?;
34                map.serialize_entry(&"cartesian", value)?;
35            }
36            VizDefinition::Checklist(value) => {
37                map.serialize_entry(&"type", &"checklist")?;
38                map.serialize_entry(&"checklist", value)?;
39            }
40            VizDefinition::Frequency(value) => {
41                map.serialize_entry(&"type", &"frequency")?;
42                map.serialize_entry(&"frequency", value)?;
43            }
44            VizDefinition::Geo(value) => {
45                map.serialize_entry(&"type", &"geo")?;
46                map.serialize_entry(&"geo", value)?;
47            }
48            VizDefinition::Geo3d(value) => {
49                map.serialize_entry(&"type", &"geo3d")?;
50                map.serialize_entry(&"geo3d", value)?;
51            }
52            VizDefinition::Histogram(value) => {
53                map.serialize_entry(&"type", &"histogram")?;
54                map.serialize_entry(&"histogram", value)?;
55            }
56            VizDefinition::Log(value) => {
57                map.serialize_entry(&"type", &"log")?;
58                map.serialize_entry(&"log", value)?;
59            }
60            VizDefinition::Markdown(value) => {
61                map.serialize_entry(&"type", &"markdown")?;
62                map.serialize_entry(&"markdown", value)?;
63            }
64            VizDefinition::Plotly(value) => {
65                map.serialize_entry(&"type", &"plotly")?;
66                map.serialize_entry(&"plotly", value)?;
67            }
68            VizDefinition::Procedure(value) => {
69                map.serialize_entry(&"type", &"procedure")?;
70                map.serialize_entry(&"procedure", value)?;
71            }
72            VizDefinition::TimeSeries(value) => {
73                map.serialize_entry(&"type", &"timeSeries")?;
74                map.serialize_entry(&"timeSeries", value)?;
75            }
76            VizDefinition::TimeSeriesTable(value) => {
77                map.serialize_entry(&"type", &"timeSeriesTable")?;
78                map.serialize_entry(&"timeSeriesTable", value)?;
79            }
80            VizDefinition::ValueTable(value) => {
81                map.serialize_entry(&"type", &"valueTable")?;
82                map.serialize_entry(&"valueTable", value)?;
83            }
84            VizDefinition::Video(value) => {
85                map.serialize_entry(&"type", &"video")?;
86                map.serialize_entry(&"video", value)?;
87            }
88            VizDefinition::Unknown(value) => {
89                map.serialize_entry(&"type", &value.type_)?;
90                map.serialize_entry(&value.type_, &value.value)?;
91            }
92        }
93        map.end()
94    }
95}
96impl<'de> de::Deserialize<'de> for VizDefinition {
97    fn deserialize<D>(d: D) -> Result<VizDefinition, D::Error>
98    where
99        D: de::Deserializer<'de>,
100    {
101        d.deserialize_map(Visitor_)
102    }
103}
104struct Visitor_;
105impl<'de> de::Visitor<'de> for Visitor_ {
106    type Value = VizDefinition;
107    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
108        fmt.write_str("union VizDefinition")
109    }
110    fn visit_map<A>(self, mut map: A) -> Result<VizDefinition, A::Error>
111    where
112        A: de::MapAccess<'de>,
113    {
114        let v = match map.next_key::<UnionField_<Variant_>>()? {
115            Some(UnionField_::Type) => {
116                let variant = map.next_value()?;
117                let key = map.next_key()?;
118                match (variant, key) {
119                    (Variant_::Cartesian, Some(Variant_::Cartesian)) => {
120                        let value = map.next_value()?;
121                        VizDefinition::Cartesian(value)
122                    }
123                    (Variant_::Checklist, Some(Variant_::Checklist)) => {
124                        let value = map.next_value()?;
125                        VizDefinition::Checklist(value)
126                    }
127                    (Variant_::Frequency, Some(Variant_::Frequency)) => {
128                        let value = map.next_value()?;
129                        VizDefinition::Frequency(value)
130                    }
131                    (Variant_::Geo, Some(Variant_::Geo)) => {
132                        let value = map.next_value()?;
133                        VizDefinition::Geo(value)
134                    }
135                    (Variant_::Geo3d, Some(Variant_::Geo3d)) => {
136                        let value = map.next_value()?;
137                        VizDefinition::Geo3d(value)
138                    }
139                    (Variant_::Histogram, Some(Variant_::Histogram)) => {
140                        let value = map.next_value()?;
141                        VizDefinition::Histogram(value)
142                    }
143                    (Variant_::Log, Some(Variant_::Log)) => {
144                        let value = map.next_value()?;
145                        VizDefinition::Log(value)
146                    }
147                    (Variant_::Markdown, Some(Variant_::Markdown)) => {
148                        let value = map.next_value()?;
149                        VizDefinition::Markdown(value)
150                    }
151                    (Variant_::Plotly, Some(Variant_::Plotly)) => {
152                        let value = map.next_value()?;
153                        VizDefinition::Plotly(value)
154                    }
155                    (Variant_::Procedure, Some(Variant_::Procedure)) => {
156                        let value = map.next_value()?;
157                        VizDefinition::Procedure(value)
158                    }
159                    (Variant_::TimeSeries, Some(Variant_::TimeSeries)) => {
160                        let value = map.next_value()?;
161                        VizDefinition::TimeSeries(value)
162                    }
163                    (Variant_::TimeSeriesTable, Some(Variant_::TimeSeriesTable)) => {
164                        let value = map.next_value()?;
165                        VizDefinition::TimeSeriesTable(value)
166                    }
167                    (Variant_::ValueTable, Some(Variant_::ValueTable)) => {
168                        let value = map.next_value()?;
169                        VizDefinition::ValueTable(value)
170                    }
171                    (Variant_::Video, Some(Variant_::Video)) => {
172                        let value = map.next_value()?;
173                        VizDefinition::Video(value)
174                    }
175                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
176                        if type_ == b {
177                            let value = map.next_value()?;
178                            VizDefinition::Unknown(Unknown { type_, value })
179                        } else {
180                            return Err(
181                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
182                            )
183                        }
184                    }
185                    (variant, Some(key)) => {
186                        return Err(
187                            de::Error::invalid_value(
188                                de::Unexpected::Str(key.as_str()),
189                                &variant.as_str(),
190                            ),
191                        );
192                    }
193                    (variant, None) => {
194                        return Err(de::Error::missing_field(variant.as_str()));
195                    }
196                }
197            }
198            Some(UnionField_::Value(variant)) => {
199                let value = match &variant {
200                    Variant_::Cartesian => {
201                        let value = map.next_value()?;
202                        VizDefinition::Cartesian(value)
203                    }
204                    Variant_::Checklist => {
205                        let value = map.next_value()?;
206                        VizDefinition::Checklist(value)
207                    }
208                    Variant_::Frequency => {
209                        let value = map.next_value()?;
210                        VizDefinition::Frequency(value)
211                    }
212                    Variant_::Geo => {
213                        let value = map.next_value()?;
214                        VizDefinition::Geo(value)
215                    }
216                    Variant_::Geo3d => {
217                        let value = map.next_value()?;
218                        VizDefinition::Geo3d(value)
219                    }
220                    Variant_::Histogram => {
221                        let value = map.next_value()?;
222                        VizDefinition::Histogram(value)
223                    }
224                    Variant_::Log => {
225                        let value = map.next_value()?;
226                        VizDefinition::Log(value)
227                    }
228                    Variant_::Markdown => {
229                        let value = map.next_value()?;
230                        VizDefinition::Markdown(value)
231                    }
232                    Variant_::Plotly => {
233                        let value = map.next_value()?;
234                        VizDefinition::Plotly(value)
235                    }
236                    Variant_::Procedure => {
237                        let value = map.next_value()?;
238                        VizDefinition::Procedure(value)
239                    }
240                    Variant_::TimeSeries => {
241                        let value = map.next_value()?;
242                        VizDefinition::TimeSeries(value)
243                    }
244                    Variant_::TimeSeriesTable => {
245                        let value = map.next_value()?;
246                        VizDefinition::TimeSeriesTable(value)
247                    }
248                    Variant_::ValueTable => {
249                        let value = map.next_value()?;
250                        VizDefinition::ValueTable(value)
251                    }
252                    Variant_::Video => {
253                        let value = map.next_value()?;
254                        VizDefinition::Video(value)
255                    }
256                    Variant_::Unknown(type_) => {
257                        let value = map.next_value()?;
258                        VizDefinition::Unknown(Unknown {
259                            type_: type_.clone(),
260                            value,
261                        })
262                    }
263                };
264                if map.next_key::<UnionTypeField_>()?.is_none() {
265                    return Err(de::Error::missing_field("type"));
266                }
267                let type_variant = map.next_value::<Variant_>()?;
268                if variant != type_variant {
269                    return Err(
270                        de::Error::invalid_value(
271                            de::Unexpected::Str(type_variant.as_str()),
272                            &variant.as_str(),
273                        ),
274                    );
275                }
276                value
277            }
278            None => return Err(de::Error::missing_field("type")),
279        };
280        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
281            return Err(de::Error::invalid_length(3, &"type and value fields"));
282        }
283        Ok(v)
284    }
285}
286#[derive(PartialEq)]
287enum Variant_ {
288    Cartesian,
289    Checklist,
290    Frequency,
291    Geo,
292    Geo3d,
293    Histogram,
294    Log,
295    Markdown,
296    Plotly,
297    Procedure,
298    TimeSeries,
299    TimeSeriesTable,
300    ValueTable,
301    Video,
302    Unknown(Box<str>),
303}
304impl Variant_ {
305    fn as_str(&self) -> &'static str {
306        match *self {
307            Variant_::Cartesian => "cartesian",
308            Variant_::Checklist => "checklist",
309            Variant_::Frequency => "frequency",
310            Variant_::Geo => "geo",
311            Variant_::Geo3d => "geo3d",
312            Variant_::Histogram => "histogram",
313            Variant_::Log => "log",
314            Variant_::Markdown => "markdown",
315            Variant_::Plotly => "plotly",
316            Variant_::Procedure => "procedure",
317            Variant_::TimeSeries => "timeSeries",
318            Variant_::TimeSeriesTable => "timeSeriesTable",
319            Variant_::ValueTable => "valueTable",
320            Variant_::Video => "video",
321            Variant_::Unknown(_) => "unknown variant",
322        }
323    }
324}
325impl<'de> de::Deserialize<'de> for Variant_ {
326    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
327    where
328        D: de::Deserializer<'de>,
329    {
330        d.deserialize_str(VariantVisitor_)
331    }
332}
333struct VariantVisitor_;
334impl<'de> de::Visitor<'de> for VariantVisitor_ {
335    type Value = Variant_;
336    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
337        fmt.write_str("string")
338    }
339    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
340    where
341        E: de::Error,
342    {
343        let v = match value {
344            "cartesian" => Variant_::Cartesian,
345            "checklist" => Variant_::Checklist,
346            "frequency" => Variant_::Frequency,
347            "geo" => Variant_::Geo,
348            "geo3d" => Variant_::Geo3d,
349            "histogram" => Variant_::Histogram,
350            "log" => Variant_::Log,
351            "markdown" => Variant_::Markdown,
352            "plotly" => Variant_::Plotly,
353            "procedure" => Variant_::Procedure,
354            "timeSeries" => Variant_::TimeSeries,
355            "timeSeriesTable" => Variant_::TimeSeriesTable,
356            "valueTable" => Variant_::ValueTable,
357            "video" => Variant_::Video,
358            value => Variant_::Unknown(value.to_string().into_boxed_str()),
359        };
360        Ok(v)
361    }
362}
363///An unknown variant of the VizDefinition union.
364#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
365pub struct Unknown {
366    type_: Box<str>,
367    value: conjure_object::Any,
368}
369impl Unknown {
370    /// Returns the unknown variant's type name.
371    #[inline]
372    pub fn type_(&self) -> &str {
373        &self.type_
374    }
375}
nominal_api/conjure/objects/scout/chartdefinition/api/viz_definition.rs

nominal_api/conjure/objects/scout/chartdefinition/api/
viz_definition.rs
