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

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