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

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