nominal_api/conjure/objects/scout/rids/api/
compute_event_query.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 ComputeEventQuery {
7    SearchText(Box<super::super::super::compute::api::StringConstant>),
8    /// Filters to events after this timestamp, exclusive.
9    /// This includes events that start before, but end after this time.
10    After(Box<super::super::super::compute::api::TimestampConstant>),
11    /// Filters to events before this timestamp, exclusive.
12    /// This includes events that start before, but end after this time.
13    Before(Box<super::super::super::compute::api::TimestampConstant>),
14    AdvancedTimeFilter(super::EventTimeFilter),
15    Asset(Box<super::super::super::compute::api::StringConstant>),
16    Template(Box<super::super::super::compute::api::StringConstant>),
17    Workbook(Box<super::super::super::compute::api::StringConstant>),
18    DataReview(Box<super::super::super::compute::api::StringConstant>),
19    OriginType(super::SearchEventOriginType),
20    DataReviewCheck(Box<super::super::super::compute::api::StringConstant>),
21    DispositionStatus(super::EventDispositionStatus),
22    Priority(Box<super::super::super::compute::api::StringConstant>),
23    Assignee(Box<super::super::super::compute::api::StringConstant>),
24    EventType(super::EventType),
25    CreatedBy(Box<super::super::super::compute::api::StringConstant>),
26    Label(Box<super::super::super::compute::api::StringConstant>),
27    Property(super::Property),
28    And(Vec<super::ComputeEventQuery>),
29    Or(Vec<super::ComputeEventQuery>),
30    Not(Box<super::ComputeEventQuery>),
31    Workspace(Box<super::super::super::compute::api::StringConstant>),
32    Procedure(Box<super::super::super::compute::api::StringConstant>),
33    ProcedureExecution(Box<super::super::super::compute::api::StringConstant>),
34    StepId(Box<super::super::super::compute::api::StringConstant>),
35    /// An unknown variant.
36    Unknown(Unknown),
37}
38impl ser::Serialize for ComputeEventQuery {
39    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
40    where
41        S: ser::Serializer,
42    {
43        let mut map = s.serialize_map(Some(2))?;
44        match self {
45            ComputeEventQuery::SearchText(value) => {
46                map.serialize_entry(&"type", &"searchText")?;
47                map.serialize_entry(&"searchText", value)?;
48            }
49            ComputeEventQuery::After(value) => {
50                map.serialize_entry(&"type", &"after")?;
51                map.serialize_entry(&"after", value)?;
52            }
53            ComputeEventQuery::Before(value) => {
54                map.serialize_entry(&"type", &"before")?;
55                map.serialize_entry(&"before", value)?;
56            }
57            ComputeEventQuery::AdvancedTimeFilter(value) => {
58                map.serialize_entry(&"type", &"advancedTimeFilter")?;
59                map.serialize_entry(&"advancedTimeFilter", value)?;
60            }
61            ComputeEventQuery::Asset(value) => {
62                map.serialize_entry(&"type", &"asset")?;
63                map.serialize_entry(&"asset", value)?;
64            }
65            ComputeEventQuery::Template(value) => {
66                map.serialize_entry(&"type", &"template")?;
67                map.serialize_entry(&"template", value)?;
68            }
69            ComputeEventQuery::Workbook(value) => {
70                map.serialize_entry(&"type", &"workbook")?;
71                map.serialize_entry(&"workbook", value)?;
72            }
73            ComputeEventQuery::DataReview(value) => {
74                map.serialize_entry(&"type", &"dataReview")?;
75                map.serialize_entry(&"dataReview", value)?;
76            }
77            ComputeEventQuery::OriginType(value) => {
78                map.serialize_entry(&"type", &"originType")?;
79                map.serialize_entry(&"originType", value)?;
80            }
81            ComputeEventQuery::DataReviewCheck(value) => {
82                map.serialize_entry(&"type", &"dataReviewCheck")?;
83                map.serialize_entry(&"dataReviewCheck", value)?;
84            }
85            ComputeEventQuery::DispositionStatus(value) => {
86                map.serialize_entry(&"type", &"dispositionStatus")?;
87                map.serialize_entry(&"dispositionStatus", value)?;
88            }
89            ComputeEventQuery::Priority(value) => {
90                map.serialize_entry(&"type", &"priority")?;
91                map.serialize_entry(&"priority", value)?;
92            }
93            ComputeEventQuery::Assignee(value) => {
94                map.serialize_entry(&"type", &"assignee")?;
95                map.serialize_entry(&"assignee", value)?;
96            }
97            ComputeEventQuery::EventType(value) => {
98                map.serialize_entry(&"type", &"eventType")?;
99                map.serialize_entry(&"eventType", value)?;
100            }
101            ComputeEventQuery::CreatedBy(value) => {
102                map.serialize_entry(&"type", &"createdBy")?;
103                map.serialize_entry(&"createdBy", value)?;
104            }
105            ComputeEventQuery::Label(value) => {
106                map.serialize_entry(&"type", &"label")?;
107                map.serialize_entry(&"label", value)?;
108            }
109            ComputeEventQuery::Property(value) => {
110                map.serialize_entry(&"type", &"property")?;
111                map.serialize_entry(&"property", value)?;
112            }
113            ComputeEventQuery::And(value) => {
114                map.serialize_entry(&"type", &"and")?;
115                map.serialize_entry(&"and", value)?;
116            }
117            ComputeEventQuery::Or(value) => {
118                map.serialize_entry(&"type", &"or")?;
119                map.serialize_entry(&"or", value)?;
120            }
121            ComputeEventQuery::Not(value) => {
122                map.serialize_entry(&"type", &"not")?;
123                map.serialize_entry(&"not", value)?;
124            }
125            ComputeEventQuery::Workspace(value) => {
126                map.serialize_entry(&"type", &"workspace")?;
127                map.serialize_entry(&"workspace", value)?;
128            }
129            ComputeEventQuery::Procedure(value) => {
130                map.serialize_entry(&"type", &"procedure")?;
131                map.serialize_entry(&"procedure", value)?;
132            }
133            ComputeEventQuery::ProcedureExecution(value) => {
134                map.serialize_entry(&"type", &"procedureExecution")?;
135                map.serialize_entry(&"procedureExecution", value)?;
136            }
137            ComputeEventQuery::StepId(value) => {
138                map.serialize_entry(&"type", &"stepId")?;
139                map.serialize_entry(&"stepId", value)?;
140            }
141            ComputeEventQuery::Unknown(value) => {
142                map.serialize_entry(&"type", &value.type_)?;
143                map.serialize_entry(&value.type_, &value.value)?;
144            }
145        }
146        map.end()
147    }
148}
149impl<'de> de::Deserialize<'de> for ComputeEventQuery {
150    fn deserialize<D>(d: D) -> Result<ComputeEventQuery, D::Error>
151    where
152        D: de::Deserializer<'de>,
153    {
154        d.deserialize_map(Visitor_)
155    }
156}
157struct Visitor_;
158impl<'de> de::Visitor<'de> for Visitor_ {
159    type Value = ComputeEventQuery;
160    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
161        fmt.write_str("union ComputeEventQuery")
162    }
163    fn visit_map<A>(self, mut map: A) -> Result<ComputeEventQuery, A::Error>
164    where
165        A: de::MapAccess<'de>,
166    {
167        let v = match map.next_key::<UnionField_<Variant_>>()? {
168            Some(UnionField_::Type) => {
169                let variant = map.next_value()?;
170                let key = map.next_key()?;
171                match (variant, key) {
172                    (Variant_::SearchText, Some(Variant_::SearchText)) => {
173                        let value = map.next_value()?;
174                        ComputeEventQuery::SearchText(value)
175                    }
176                    (Variant_::After, Some(Variant_::After)) => {
177                        let value = map.next_value()?;
178                        ComputeEventQuery::After(value)
179                    }
180                    (Variant_::Before, Some(Variant_::Before)) => {
181                        let value = map.next_value()?;
182                        ComputeEventQuery::Before(value)
183                    }
184                    (
185                        Variant_::AdvancedTimeFilter,
186                        Some(Variant_::AdvancedTimeFilter),
187                    ) => {
188                        let value = map.next_value()?;
189                        ComputeEventQuery::AdvancedTimeFilter(value)
190                    }
191                    (Variant_::Asset, Some(Variant_::Asset)) => {
192                        let value = map.next_value()?;
193                        ComputeEventQuery::Asset(value)
194                    }
195                    (Variant_::Template, Some(Variant_::Template)) => {
196                        let value = map.next_value()?;
197                        ComputeEventQuery::Template(value)
198                    }
199                    (Variant_::Workbook, Some(Variant_::Workbook)) => {
200                        let value = map.next_value()?;
201                        ComputeEventQuery::Workbook(value)
202                    }
203                    (Variant_::DataReview, Some(Variant_::DataReview)) => {
204                        let value = map.next_value()?;
205                        ComputeEventQuery::DataReview(value)
206                    }
207                    (Variant_::OriginType, Some(Variant_::OriginType)) => {
208                        let value = map.next_value()?;
209                        ComputeEventQuery::OriginType(value)
210                    }
211                    (Variant_::DataReviewCheck, Some(Variant_::DataReviewCheck)) => {
212                        let value = map.next_value()?;
213                        ComputeEventQuery::DataReviewCheck(value)
214                    }
215                    (Variant_::DispositionStatus, Some(Variant_::DispositionStatus)) => {
216                        let value = map.next_value()?;
217                        ComputeEventQuery::DispositionStatus(value)
218                    }
219                    (Variant_::Priority, Some(Variant_::Priority)) => {
220                        let value = map.next_value()?;
221                        ComputeEventQuery::Priority(value)
222                    }
223                    (Variant_::Assignee, Some(Variant_::Assignee)) => {
224                        let value = map.next_value()?;
225                        ComputeEventQuery::Assignee(value)
226                    }
227                    (Variant_::EventType, Some(Variant_::EventType)) => {
228                        let value = map.next_value()?;
229                        ComputeEventQuery::EventType(value)
230                    }
231                    (Variant_::CreatedBy, Some(Variant_::CreatedBy)) => {
232                        let value = map.next_value()?;
233                        ComputeEventQuery::CreatedBy(value)
234                    }
235                    (Variant_::Label, Some(Variant_::Label)) => {
236                        let value = map.next_value()?;
237                        ComputeEventQuery::Label(value)
238                    }
239                    (Variant_::Property, Some(Variant_::Property)) => {
240                        let value = map.next_value()?;
241                        ComputeEventQuery::Property(value)
242                    }
243                    (Variant_::And, Some(Variant_::And)) => {
244                        let value = map.next_value()?;
245                        ComputeEventQuery::And(value)
246                    }
247                    (Variant_::Or, Some(Variant_::Or)) => {
248                        let value = map.next_value()?;
249                        ComputeEventQuery::Or(value)
250                    }
251                    (Variant_::Not, Some(Variant_::Not)) => {
252                        let value = map.next_value()?;
253                        ComputeEventQuery::Not(value)
254                    }
255                    (Variant_::Workspace, Some(Variant_::Workspace)) => {
256                        let value = map.next_value()?;
257                        ComputeEventQuery::Workspace(value)
258                    }
259                    (Variant_::Procedure, Some(Variant_::Procedure)) => {
260                        let value = map.next_value()?;
261                        ComputeEventQuery::Procedure(value)
262                    }
263                    (
264                        Variant_::ProcedureExecution,
265                        Some(Variant_::ProcedureExecution),
266                    ) => {
267                        let value = map.next_value()?;
268                        ComputeEventQuery::ProcedureExecution(value)
269                    }
270                    (Variant_::StepId, Some(Variant_::StepId)) => {
271                        let value = map.next_value()?;
272                        ComputeEventQuery::StepId(value)
273                    }
274                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
275                        if type_ == b {
276                            let value = map.next_value()?;
277                            ComputeEventQuery::Unknown(Unknown { type_, value })
278                        } else {
279                            return Err(
280                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
281                            )
282                        }
283                    }
284                    (variant, Some(key)) => {
285                        return Err(
286                            de::Error::invalid_value(
287                                de::Unexpected::Str(key.as_str()),
288                                &variant.as_str(),
289                            ),
290                        );
291                    }
292                    (variant, None) => {
293                        return Err(de::Error::missing_field(variant.as_str()));
294                    }
295                }
296            }
297            Some(UnionField_::Value(variant)) => {
298                let value = match &variant {
299                    Variant_::SearchText => {
300                        let value = map.next_value()?;
301                        ComputeEventQuery::SearchText(value)
302                    }
303                    Variant_::After => {
304                        let value = map.next_value()?;
305                        ComputeEventQuery::After(value)
306                    }
307                    Variant_::Before => {
308                        let value = map.next_value()?;
309                        ComputeEventQuery::Before(value)
310                    }
311                    Variant_::AdvancedTimeFilter => {
312                        let value = map.next_value()?;
313                        ComputeEventQuery::AdvancedTimeFilter(value)
314                    }
315                    Variant_::Asset => {
316                        let value = map.next_value()?;
317                        ComputeEventQuery::Asset(value)
318                    }
319                    Variant_::Template => {
320                        let value = map.next_value()?;
321                        ComputeEventQuery::Template(value)
322                    }
323                    Variant_::Workbook => {
324                        let value = map.next_value()?;
325                        ComputeEventQuery::Workbook(value)
326                    }
327                    Variant_::DataReview => {
328                        let value = map.next_value()?;
329                        ComputeEventQuery::DataReview(value)
330                    }
331                    Variant_::OriginType => {
332                        let value = map.next_value()?;
333                        ComputeEventQuery::OriginType(value)
334                    }
335                    Variant_::DataReviewCheck => {
336                        let value = map.next_value()?;
337                        ComputeEventQuery::DataReviewCheck(value)
338                    }
339                    Variant_::DispositionStatus => {
340                        let value = map.next_value()?;
341                        ComputeEventQuery::DispositionStatus(value)
342                    }
343                    Variant_::Priority => {
344                        let value = map.next_value()?;
345                        ComputeEventQuery::Priority(value)
346                    }
347                    Variant_::Assignee => {
348                        let value = map.next_value()?;
349                        ComputeEventQuery::Assignee(value)
350                    }
351                    Variant_::EventType => {
352                        let value = map.next_value()?;
353                        ComputeEventQuery::EventType(value)
354                    }
355                    Variant_::CreatedBy => {
356                        let value = map.next_value()?;
357                        ComputeEventQuery::CreatedBy(value)
358                    }
359                    Variant_::Label => {
360                        let value = map.next_value()?;
361                        ComputeEventQuery::Label(value)
362                    }
363                    Variant_::Property => {
364                        let value = map.next_value()?;
365                        ComputeEventQuery::Property(value)
366                    }
367                    Variant_::And => {
368                        let value = map.next_value()?;
369                        ComputeEventQuery::And(value)
370                    }
371                    Variant_::Or => {
372                        let value = map.next_value()?;
373                        ComputeEventQuery::Or(value)
374                    }
375                    Variant_::Not => {
376                        let value = map.next_value()?;
377                        ComputeEventQuery::Not(value)
378                    }
379                    Variant_::Workspace => {
380                        let value = map.next_value()?;
381                        ComputeEventQuery::Workspace(value)
382                    }
383                    Variant_::Procedure => {
384                        let value = map.next_value()?;
385                        ComputeEventQuery::Procedure(value)
386                    }
387                    Variant_::ProcedureExecution => {
388                        let value = map.next_value()?;
389                        ComputeEventQuery::ProcedureExecution(value)
390                    }
391                    Variant_::StepId => {
392                        let value = map.next_value()?;
393                        ComputeEventQuery::StepId(value)
394                    }
395                    Variant_::Unknown(type_) => {
396                        let value = map.next_value()?;
397                        ComputeEventQuery::Unknown(Unknown {
398                            type_: type_.clone(),
399                            value,
400                        })
401                    }
402                };
403                if map.next_key::<UnionTypeField_>()?.is_none() {
404                    return Err(de::Error::missing_field("type"));
405                }
406                let type_variant = map.next_value::<Variant_>()?;
407                if variant != type_variant {
408                    return Err(
409                        de::Error::invalid_value(
410                            de::Unexpected::Str(type_variant.as_str()),
411                            &variant.as_str(),
412                        ),
413                    );
414                }
415                value
416            }
417            None => return Err(de::Error::missing_field("type")),
418        };
419        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
420            return Err(de::Error::invalid_length(3, &"type and value fields"));
421        }
422        Ok(v)
423    }
424}
425#[derive(PartialEq)]
426enum Variant_ {
427    SearchText,
428    After,
429    Before,
430    AdvancedTimeFilter,
431    Asset,
432    Template,
433    Workbook,
434    DataReview,
435    OriginType,
436    DataReviewCheck,
437    DispositionStatus,
438    Priority,
439    Assignee,
440    EventType,
441    CreatedBy,
442    Label,
443    Property,
444    And,
445    Or,
446    Not,
447    Workspace,
448    Procedure,
449    ProcedureExecution,
450    StepId,
451    Unknown(Box<str>),
452}
453impl Variant_ {
454    fn as_str(&self) -> &'static str {
455        match *self {
456            Variant_::SearchText => "searchText",
457            Variant_::After => "after",
458            Variant_::Before => "before",
459            Variant_::AdvancedTimeFilter => "advancedTimeFilter",
460            Variant_::Asset => "asset",
461            Variant_::Template => "template",
462            Variant_::Workbook => "workbook",
463            Variant_::DataReview => "dataReview",
464            Variant_::OriginType => "originType",
465            Variant_::DataReviewCheck => "dataReviewCheck",
466            Variant_::DispositionStatus => "dispositionStatus",
467            Variant_::Priority => "priority",
468            Variant_::Assignee => "assignee",
469            Variant_::EventType => "eventType",
470            Variant_::CreatedBy => "createdBy",
471            Variant_::Label => "label",
472            Variant_::Property => "property",
473            Variant_::And => "and",
474            Variant_::Or => "or",
475            Variant_::Not => "not",
476            Variant_::Workspace => "workspace",
477            Variant_::Procedure => "procedure",
478            Variant_::ProcedureExecution => "procedureExecution",
479            Variant_::StepId => "stepId",
480            Variant_::Unknown(_) => "unknown variant",
481        }
482    }
483}
484impl<'de> de::Deserialize<'de> for Variant_ {
485    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
486    where
487        D: de::Deserializer<'de>,
488    {
489        d.deserialize_str(VariantVisitor_)
490    }
491}
492struct VariantVisitor_;
493impl<'de> de::Visitor<'de> for VariantVisitor_ {
494    type Value = Variant_;
495    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
496        fmt.write_str("string")
497    }
498    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
499    where
500        E: de::Error,
501    {
502        let v = match value {
503            "searchText" => Variant_::SearchText,
504            "after" => Variant_::After,
505            "before" => Variant_::Before,
506            "advancedTimeFilter" => Variant_::AdvancedTimeFilter,
507            "asset" => Variant_::Asset,
508            "template" => Variant_::Template,
509            "workbook" => Variant_::Workbook,
510            "dataReview" => Variant_::DataReview,
511            "originType" => Variant_::OriginType,
512            "dataReviewCheck" => Variant_::DataReviewCheck,
513            "dispositionStatus" => Variant_::DispositionStatus,
514            "priority" => Variant_::Priority,
515            "assignee" => Variant_::Assignee,
516            "eventType" => Variant_::EventType,
517            "createdBy" => Variant_::CreatedBy,
518            "label" => Variant_::Label,
519            "property" => Variant_::Property,
520            "and" => Variant_::And,
521            "or" => Variant_::Or,
522            "not" => Variant_::Not,
523            "workspace" => Variant_::Workspace,
524            "procedure" => Variant_::Procedure,
525            "procedureExecution" => Variant_::ProcedureExecution,
526            "stepId" => Variant_::StepId,
527            value => Variant_::Unknown(value.to_string().into_boxed_str()),
528        };
529        Ok(v)
530    }
531}
532///An unknown variant of the ComputeEventQuery union.
533#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
534pub struct Unknown {
535    type_: Box<str>,
536    value: conjure_object::Any,
537}
538impl Unknown {
539    /// Returns the unknown variant's type name.
540    #[inline]
541    pub fn type_(&self) -> &str {
542        &self.type_
543    }
544}
nominal_api/conjure/objects/scout/rids/api/compute_event_query.rs

nominal_api/conjure/objects/scout/rids/api/
compute_event_query.rs
