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

nominal_api/conjure/objects/scout/datasource/connection/api/
scraping_config.rs
