nominal_api/conjure/objects/scout/chartdefinition/api/
table_column_numeric_aggregation.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, PartialEq, Eq, PartialOrd, Ord, Hash)]
6pub enum TableColumnNumericAggregation {
7    First(super::NoConfigAggregation),
8    Last(super::NoConfigAggregation),
9    Mean(super::NoConfigAggregation),
10    Min(super::NoConfigAggregation),
11    Max(super::NoConfigAggregation),
12    /// An unknown variant.
13    Unknown(Unknown),
14}
15impl ser::Serialize for TableColumnNumericAggregation {
16    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
17    where
18        S: ser::Serializer,
19    {
20        let mut map = s.serialize_map(Some(2))?;
21        match self {
22            TableColumnNumericAggregation::First(value) => {
23                map.serialize_entry(&"type", &"first")?;
24                map.serialize_entry(&"first", value)?;
25            }
26            TableColumnNumericAggregation::Last(value) => {
27                map.serialize_entry(&"type", &"last")?;
28                map.serialize_entry(&"last", value)?;
29            }
30            TableColumnNumericAggregation::Mean(value) => {
31                map.serialize_entry(&"type", &"mean")?;
32                map.serialize_entry(&"mean", value)?;
33            }
34            TableColumnNumericAggregation::Min(value) => {
35                map.serialize_entry(&"type", &"min")?;
36                map.serialize_entry(&"min", value)?;
37            }
38            TableColumnNumericAggregation::Max(value) => {
39                map.serialize_entry(&"type", &"max")?;
40                map.serialize_entry(&"max", value)?;
41            }
42            TableColumnNumericAggregation::Unknown(value) => {
43                map.serialize_entry(&"type", &value.type_)?;
44                map.serialize_entry(&value.type_, &value.value)?;
45            }
46        }
47        map.end()
48    }
49}
50impl<'de> de::Deserialize<'de> for TableColumnNumericAggregation {
51    fn deserialize<D>(d: D) -> Result<TableColumnNumericAggregation, D::Error>
52    where
53        D: de::Deserializer<'de>,
54    {
55        d.deserialize_map(Visitor_)
56    }
57}
58struct Visitor_;
59impl<'de> de::Visitor<'de> for Visitor_ {
60    type Value = TableColumnNumericAggregation;
61    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
62        fmt.write_str("union TableColumnNumericAggregation")
63    }
64    fn visit_map<A>(self, mut map: A) -> Result<TableColumnNumericAggregation, A::Error>
65    where
66        A: de::MapAccess<'de>,
67    {
68        let v = match map.next_key::<UnionField_<Variant_>>()? {
69            Some(UnionField_::Type) => {
70                let variant = map.next_value()?;
71                let key = map.next_key()?;
72                match (variant, key) {
73                    (Variant_::First, Some(Variant_::First)) => {
74                        let value = map.next_value()?;
75                        TableColumnNumericAggregation::First(value)
76                    }
77                    (Variant_::Last, Some(Variant_::Last)) => {
78                        let value = map.next_value()?;
79                        TableColumnNumericAggregation::Last(value)
80                    }
81                    (Variant_::Mean, Some(Variant_::Mean)) => {
82                        let value = map.next_value()?;
83                        TableColumnNumericAggregation::Mean(value)
84                    }
85                    (Variant_::Min, Some(Variant_::Min)) => {
86                        let value = map.next_value()?;
87                        TableColumnNumericAggregation::Min(value)
88                    }
89                    (Variant_::Max, Some(Variant_::Max)) => {
90                        let value = map.next_value()?;
91                        TableColumnNumericAggregation::Max(value)
92                    }
93                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
94                        if type_ == b {
95                            let value = map.next_value()?;
96                            TableColumnNumericAggregation::Unknown(Unknown {
97                                type_,
98                                value,
99                            })
100                        } else {
101                            return Err(
102                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
103                            )
104                        }
105                    }
106                    (variant, Some(key)) => {
107                        return Err(
108                            de::Error::invalid_value(
109                                de::Unexpected::Str(key.as_str()),
110                                &variant.as_str(),
111                            ),
112                        );
113                    }
114                    (variant, None) => {
115                        return Err(de::Error::missing_field(variant.as_str()));
116                    }
117                }
118            }
119            Some(UnionField_::Value(variant)) => {
120                let value = match &variant {
121                    Variant_::First => {
122                        let value = map.next_value()?;
123                        TableColumnNumericAggregation::First(value)
124                    }
125                    Variant_::Last => {
126                        let value = map.next_value()?;
127                        TableColumnNumericAggregation::Last(value)
128                    }
129                    Variant_::Mean => {
130                        let value = map.next_value()?;
131                        TableColumnNumericAggregation::Mean(value)
132                    }
133                    Variant_::Min => {
134                        let value = map.next_value()?;
135                        TableColumnNumericAggregation::Min(value)
136                    }
137                    Variant_::Max => {
138                        let value = map.next_value()?;
139                        TableColumnNumericAggregation::Max(value)
140                    }
141                    Variant_::Unknown(type_) => {
142                        let value = map.next_value()?;
143                        TableColumnNumericAggregation::Unknown(Unknown {
144                            type_: type_.clone(),
145                            value,
146                        })
147                    }
148                };
149                if map.next_key::<UnionTypeField_>()?.is_none() {
150                    return Err(de::Error::missing_field("type"));
151                }
152                let type_variant = map.next_value::<Variant_>()?;
153                if variant != type_variant {
154                    return Err(
155                        de::Error::invalid_value(
156                            de::Unexpected::Str(type_variant.as_str()),
157                            &variant.as_str(),
158                        ),
159                    );
160                }
161                value
162            }
163            None => return Err(de::Error::missing_field("type")),
164        };
165        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
166            return Err(de::Error::invalid_length(3, &"type and value fields"));
167        }
168        Ok(v)
169    }
170}
171#[derive(PartialEq)]
172enum Variant_ {
173    First,
174    Last,
175    Mean,
176    Min,
177    Max,
178    Unknown(Box<str>),
179}
180impl Variant_ {
181    fn as_str(&self) -> &'static str {
182        match *self {
183            Variant_::First => "first",
184            Variant_::Last => "last",
185            Variant_::Mean => "mean",
186            Variant_::Min => "min",
187            Variant_::Max => "max",
188            Variant_::Unknown(_) => "unknown variant",
189        }
190    }
191}
192impl<'de> de::Deserialize<'de> for Variant_ {
193    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
194    where
195        D: de::Deserializer<'de>,
196    {
197        d.deserialize_str(VariantVisitor_)
198    }
199}
200struct VariantVisitor_;
201impl<'de> de::Visitor<'de> for VariantVisitor_ {
202    type Value = Variant_;
203    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
204        fmt.write_str("string")
205    }
206    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
207    where
208        E: de::Error,
209    {
210        let v = match value {
211            "first" => Variant_::First,
212            "last" => Variant_::Last,
213            "mean" => Variant_::Mean,
214            "min" => Variant_::Min,
215            "max" => Variant_::Max,
216            value => Variant_::Unknown(value.to_string().into_boxed_str()),
217        };
218        Ok(v)
219    }
220}
221///An unknown variant of the TableColumnNumericAggregation union.
222#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
223pub struct Unknown {
224    type_: Box<str>,
225    value: conjure_object::Any,
226}
227impl Unknown {
228    /// Returns the unknown variant's type name.
229    #[inline]
230    pub fn type_(&self) -> &str {
231        &self.type_
232    }
233}
nominal_api/conjure/objects/scout/chartdefinition/api/table_column_numeric_aggregation.rs

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