nominal_api_conjure/conjure/objects/scout/compute/api/
dataset.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 Dataset {
8    /// Single asset. Expands to one grouping per data scope on the asset. Groupings are tagged by
9    /// `assetRid` and `dataScope` so callers can safely compose multiple assets with `combine`.
10    Asset(super::Asset),
11    /// Single run. Expands to one grouping per data source attached to the run: asset-typed sources
12    /// contribute one grouping per data scope on the asset; dataset-typed sources contribute one
13    /// grouping per dataset. Groupings are tagged by `runRid` and `dataScope`; asset-typed groupings
14    /// additionally carry `assetRid` so callers can safely compose multiple runs with `combine`.
15    Run(super::Run),
16    Saved(super::SavedDataset),
17    #[deprecated(note = "use saved instead.")]
18    Dataset(super::SavedDataset),
19    Search(super::SearchDataset),
20    Combine(super::CombinedDataset),
21    Tag(super::TaggedDataset),
22    Filter(super::FilteredDataset),
23    TimeShift(super::TimeShiftedDataset),
24    WithSeries(super::WithSeriesDataset),
25    Reference(super::DatasetReference),
26    #[deprecated(note = "use reference instead.")]
27    NamedReference(super::DatasetReference),
28    /// An unknown variant.
29    Unknown(Unknown),
30}
31impl ser::Serialize for Dataset {
32    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
33    where
34        S: ser::Serializer,
35    {
36        let mut map = s.serialize_map(Some(2))?;
37        match self {
38            Dataset::Asset(value) => {
39                map.serialize_entry(&"type", &"asset")?;
40                map.serialize_entry(&"asset", value)?;
41            }
42            Dataset::Run(value) => {
43                map.serialize_entry(&"type", &"run")?;
44                map.serialize_entry(&"run", value)?;
45            }
46            Dataset::Saved(value) => {
47                map.serialize_entry(&"type", &"saved")?;
48                map.serialize_entry(&"saved", value)?;
49            }
50            #[allow(deprecated)]
51            Dataset::Dataset(value) => {
52                map.serialize_entry(&"type", &"dataset")?;
53                map.serialize_entry(&"dataset", value)?;
54            }
55            Dataset::Search(value) => {
56                map.serialize_entry(&"type", &"search")?;
57                map.serialize_entry(&"search", value)?;
58            }
59            Dataset::Combine(value) => {
60                map.serialize_entry(&"type", &"combine")?;
61                map.serialize_entry(&"combine", value)?;
62            }
63            Dataset::Tag(value) => {
64                map.serialize_entry(&"type", &"tag")?;
65                map.serialize_entry(&"tag", value)?;
66            }
67            Dataset::Filter(value) => {
68                map.serialize_entry(&"type", &"filter")?;
69                map.serialize_entry(&"filter", value)?;
70            }
71            Dataset::TimeShift(value) => {
72                map.serialize_entry(&"type", &"timeShift")?;
73                map.serialize_entry(&"timeShift", value)?;
74            }
75            Dataset::WithSeries(value) => {
76                map.serialize_entry(&"type", &"withSeries")?;
77                map.serialize_entry(&"withSeries", value)?;
78            }
79            Dataset::Reference(value) => {
80                map.serialize_entry(&"type", &"reference")?;
81                map.serialize_entry(&"reference", value)?;
82            }
83            #[allow(deprecated)]
84            Dataset::NamedReference(value) => {
85                map.serialize_entry(&"type", &"namedReference")?;
86                map.serialize_entry(&"namedReference", value)?;
87            }
88            Dataset::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 Dataset {
97    fn deserialize<D>(d: D) -> Result<Dataset, 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 = Dataset;
107    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
108        fmt.write_str("union Dataset")
109    }
110    fn visit_map<A>(self, mut map: A) -> Result<Dataset, 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_::Asset, Some(Variant_::Asset)) => {
120                        let value = map.next_value()?;
121                        Dataset::Asset(value)
122                    }
123                    (Variant_::Run, Some(Variant_::Run)) => {
124                        let value = map.next_value()?;
125                        Dataset::Run(value)
126                    }
127                    (Variant_::Saved, Some(Variant_::Saved)) => {
128                        let value = map.next_value()?;
129                        Dataset::Saved(value)
130                    }
131                    #[allow(deprecated)]
132                    (Variant_::Dataset, Some(Variant_::Dataset)) => {
133                        let value = map.next_value()?;
134                        Dataset::Dataset(value)
135                    }
136                    (Variant_::Search, Some(Variant_::Search)) => {
137                        let value = map.next_value()?;
138                        Dataset::Search(value)
139                    }
140                    (Variant_::Combine, Some(Variant_::Combine)) => {
141                        let value = map.next_value()?;
142                        Dataset::Combine(value)
143                    }
144                    (Variant_::Tag, Some(Variant_::Tag)) => {
145                        let value = map.next_value()?;
146                        Dataset::Tag(value)
147                    }
148                    (Variant_::Filter, Some(Variant_::Filter)) => {
149                        let value = map.next_value()?;
150                        Dataset::Filter(value)
151                    }
152                    (Variant_::TimeShift, Some(Variant_::TimeShift)) => {
153                        let value = map.next_value()?;
154                        Dataset::TimeShift(value)
155                    }
156                    (Variant_::WithSeries, Some(Variant_::WithSeries)) => {
157                        let value = map.next_value()?;
158                        Dataset::WithSeries(value)
159                    }
160                    (Variant_::Reference, Some(Variant_::Reference)) => {
161                        let value = map.next_value()?;
162                        Dataset::Reference(value)
163                    }
164                    #[allow(deprecated)]
165                    (Variant_::NamedReference, Some(Variant_::NamedReference)) => {
166                        let value = map.next_value()?;
167                        Dataset::NamedReference(value)
168                    }
169                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
170                        if type_ == b {
171                            let value = map.next_value()?;
172                            Dataset::Unknown(Unknown { type_, value })
173                        } else {
174                            return Err(
175                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
176                            )
177                        }
178                    }
179                    (variant, Some(key)) => {
180                        return Err(
181                            de::Error::invalid_value(
182                                de::Unexpected::Str(key.as_str()),
183                                &variant.as_str(),
184                            ),
185                        );
186                    }
187                    (variant, None) => {
188                        return Err(de::Error::missing_field(variant.as_str()));
189                    }
190                }
191            }
192            Some(UnionField_::Value(variant)) => {
193                let value = match &variant {
194                    Variant_::Asset => {
195                        let value = map.next_value()?;
196                        Dataset::Asset(value)
197                    }
198                    Variant_::Run => {
199                        let value = map.next_value()?;
200                        Dataset::Run(value)
201                    }
202                    Variant_::Saved => {
203                        let value = map.next_value()?;
204                        Dataset::Saved(value)
205                    }
206                    Variant_::Dataset => {
207                        let value = map.next_value()?;
208                        #[allow(deprecated)] Dataset::Dataset(value)
209                    }
210                    Variant_::Search => {
211                        let value = map.next_value()?;
212                        Dataset::Search(value)
213                    }
214                    Variant_::Combine => {
215                        let value = map.next_value()?;
216                        Dataset::Combine(value)
217                    }
218                    Variant_::Tag => {
219                        let value = map.next_value()?;
220                        Dataset::Tag(value)
221                    }
222                    Variant_::Filter => {
223                        let value = map.next_value()?;
224                        Dataset::Filter(value)
225                    }
226                    Variant_::TimeShift => {
227                        let value = map.next_value()?;
228                        Dataset::TimeShift(value)
229                    }
230                    Variant_::WithSeries => {
231                        let value = map.next_value()?;
232                        Dataset::WithSeries(value)
233                    }
234                    Variant_::Reference => {
235                        let value = map.next_value()?;
236                        Dataset::Reference(value)
237                    }
238                    Variant_::NamedReference => {
239                        let value = map.next_value()?;
240                        #[allow(deprecated)] Dataset::NamedReference(value)
241                    }
242                    Variant_::Unknown(type_) => {
243                        let value = map.next_value()?;
244                        Dataset::Unknown(Unknown {
245                            type_: type_.clone(),
246                            value,
247                        })
248                    }
249                };
250                if map.next_key::<UnionTypeField_>()?.is_none() {
251                    return Err(de::Error::missing_field("type"));
252                }
253                let type_variant = map.next_value::<Variant_>()?;
254                if variant != type_variant {
255                    return Err(
256                        de::Error::invalid_value(
257                            de::Unexpected::Str(type_variant.as_str()),
258                            &variant.as_str(),
259                        ),
260                    );
261                }
262                value
263            }
264            None => return Err(de::Error::missing_field("type")),
265        };
266        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
267            return Err(de::Error::invalid_length(3, &"type and value fields"));
268        }
269        Ok(v)
270    }
271}
272#[derive(PartialEq)]
273enum Variant_ {
274    Asset,
275    Run,
276    Saved,
277    Dataset,
278    Search,
279    Combine,
280    Tag,
281    Filter,
282    TimeShift,
283    WithSeries,
284    Reference,
285    NamedReference,
286    Unknown(Box<str>),
287}
288impl Variant_ {
289    fn as_str(&self) -> &'static str {
290        match *self {
291            Variant_::Asset => "asset",
292            Variant_::Run => "run",
293            Variant_::Saved => "saved",
294            Variant_::Dataset => "dataset",
295            Variant_::Search => "search",
296            Variant_::Combine => "combine",
297            Variant_::Tag => "tag",
298            Variant_::Filter => "filter",
299            Variant_::TimeShift => "timeShift",
300            Variant_::WithSeries => "withSeries",
301            Variant_::Reference => "reference",
302            Variant_::NamedReference => "namedReference",
303            Variant_::Unknown(_) => "unknown variant",
304        }
305    }
306}
307impl<'de> de::Deserialize<'de> for Variant_ {
308    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
309    where
310        D: de::Deserializer<'de>,
311    {
312        d.deserialize_str(VariantVisitor_)
313    }
314}
315struct VariantVisitor_;
316impl<'de> de::Visitor<'de> for VariantVisitor_ {
317    type Value = Variant_;
318    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
319        fmt.write_str("string")
320    }
321    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
322    where
323        E: de::Error,
324    {
325        let v = match value {
326            "asset" => Variant_::Asset,
327            "run" => Variant_::Run,
328            "saved" => Variant_::Saved,
329            "dataset" => Variant_::Dataset,
330            "search" => Variant_::Search,
331            "combine" => Variant_::Combine,
332            "tag" => Variant_::Tag,
333            "filter" => Variant_::Filter,
334            "timeShift" => Variant_::TimeShift,
335            "withSeries" => Variant_::WithSeries,
336            "reference" => Variant_::Reference,
337            "namedReference" => Variant_::NamedReference,
338            value => Variant_::Unknown(value.to_string().into_boxed_str()),
339        };
340        Ok(v)
341    }
342}
343///An unknown variant of the Dataset union.
344#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
345pub struct Unknown {
346    type_: Box<str>,
347    value: conjure_object::Any,
348}
349impl Unknown {
350    /// Returns the unknown variant's type name.
351    #[inline]
352    pub fn type_(&self) -> &str {
353        &self.type_
354    }
355}
nominal_api_conjure/conjure/objects/scout/compute/api/dataset.rs

nominal_api_conjure/conjure/objects/scout/compute/api/
dataset.rs
