Skip to main content

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

1#![allow(deprecated)]
2use std::fmt;
3use std::str;
4#[derive(
5    Debug,
6    Clone,
7    PartialEq,
8    Eq,
9    PartialOrd,
10    Ord,
11    Hash,
12    conjure_object::serde::Deserialize,
13    conjure_object::serde::Serialize,
14)]
15#[serde(crate = "conjure_object::serde")]
16pub enum NumericOutputField {
17    #[serde(rename = "MIN")]
18    Min,
19    #[serde(rename = "MAX")]
20    Max,
21    #[serde(rename = "MEAN")]
22    Mean,
23    #[serde(rename = "COUNT")]
24    Count,
25    #[serde(rename = "VARIANCE")]
26    Variance,
27    #[serde(rename = "FIRST_POINT")]
28    FirstPoint,
29    #[serde(rename = "LAST_POINT")]
30    LastPoint,
31    /// An unknown variant.
32    #[serde(untagged)]
33    Unknown(Unknown),
34}
35impl NumericOutputField {
36    /// Returns the string representation of the enum.
37    #[inline]
38    pub fn as_str(&self) -> &str {
39        match self {
40            NumericOutputField::Min => "MIN",
41            NumericOutputField::Max => "MAX",
42            NumericOutputField::Mean => "MEAN",
43            NumericOutputField::Count => "COUNT",
44            NumericOutputField::Variance => "VARIANCE",
45            NumericOutputField::FirstPoint => "FIRST_POINT",
46            NumericOutputField::LastPoint => "LAST_POINT",
47            NumericOutputField::Unknown(v) => &*v,
48        }
49    }
50}
51impl fmt::Display for NumericOutputField {
52    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
53        fmt::Display::fmt(self.as_str(), fmt)
54    }
55}
56impl conjure_object::Plain for NumericOutputField {
57    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
58        conjure_object::Plain::fmt(self.as_str(), fmt)
59    }
60}
61impl str::FromStr for NumericOutputField {
62    type Err = conjure_object::plain::ParseEnumError;
63    #[inline]
64    fn from_str(
65        v: &str,
66    ) -> Result<NumericOutputField, conjure_object::plain::ParseEnumError> {
67        match v {
68            "MIN" => Ok(NumericOutputField::Min),
69            "MAX" => Ok(NumericOutputField::Max),
70            "MEAN" => Ok(NumericOutputField::Mean),
71            "COUNT" => Ok(NumericOutputField::Count),
72            "VARIANCE" => Ok(NumericOutputField::Variance),
73            "FIRST_POINT" => Ok(NumericOutputField::FirstPoint),
74            "LAST_POINT" => Ok(NumericOutputField::LastPoint),
75            v => v.parse().map(|v| NumericOutputField::Unknown(Unknown(v))),
76        }
77    }
78}
79impl conjure_object::FromPlain for NumericOutputField {
80    type Err = conjure_object::plain::ParseEnumError;
81    #[inline]
82    fn from_plain(
83        v: &str,
84    ) -> Result<NumericOutputField, conjure_object::plain::ParseEnumError> {
85        v.parse()
86    }
87}
88///An unknown variant of the NumericOutputField enum.
89#[derive(
90    Debug,
91    Clone,
92    PartialEq,
93    Eq,
94    PartialOrd,
95    Ord,
96    Hash,
97    conjure_object::serde::Deserialize,
98    conjure_object::serde::Serialize,
99)]
100#[serde(crate = "conjure_object::serde", transparent)]
101pub struct Unknown(conjure_object::private::Variant);
102impl std::ops::Deref for Unknown {
103    type Target = str;
104    #[inline]
105    fn deref(&self) -> &str {
106        &self.0
107    }
108}
109impl fmt::Display for Unknown {
110    #[inline]
111    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
112        fmt::Display::fmt(&self.0, fmt)
113    }
114}