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

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