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

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