nominal_api/conjure/objects/scout/compute/api/
negative_value_configuration.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 NegativeValueConfiguration {
7    /// Include negative output values
8    AllowNegativeValues(super::AllowNegativeValues),
9    /// Set negative output values to zero
10    SetNegativeValuesToZero(super::SetNegativeValuesToZero),
11    /// Exclude points with negative output values
12    ExcludeNegativeValues(super::ExcludeNegativeValues),
13    /// An unknown variant.
14    Unknown(Unknown),
15}
16impl ser::Serialize for NegativeValueConfiguration {
17    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
18    where
19        S: ser::Serializer,
20    {
21        let mut map = s.serialize_map(Some(2))?;
22        match self {
23            NegativeValueConfiguration::AllowNegativeValues(value) => {
24                map.serialize_entry(&"type", &"allowNegativeValues")?;
25                map.serialize_entry(&"allowNegativeValues", value)?;
26            }
27            NegativeValueConfiguration::SetNegativeValuesToZero(value) => {
28                map.serialize_entry(&"type", &"setNegativeValuesToZero")?;
29                map.serialize_entry(&"setNegativeValuesToZero", value)?;
30            }
31            NegativeValueConfiguration::ExcludeNegativeValues(value) => {
32                map.serialize_entry(&"type", &"excludeNegativeValues")?;
33                map.serialize_entry(&"excludeNegativeValues", value)?;
34            }
35            NegativeValueConfiguration::Unknown(value) => {
36                map.serialize_entry(&"type", &value.type_)?;
37                map.serialize_entry(&value.type_, &value.value)?;
38            }
39        }
40        map.end()
41    }
42}
43impl<'de> de::Deserialize<'de> for NegativeValueConfiguration {
44    fn deserialize<D>(d: D) -> Result<NegativeValueConfiguration, D::Error>
45    where
46        D: de::Deserializer<'de>,
47    {
48        d.deserialize_map(Visitor_)
49    }
50}
51struct Visitor_;
52impl<'de> de::Visitor<'de> for Visitor_ {
53    type Value = NegativeValueConfiguration;
54    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
55        fmt.write_str("union NegativeValueConfiguration")
56    }
57    fn visit_map<A>(self, mut map: A) -> Result<NegativeValueConfiguration, A::Error>
58    where
59        A: de::MapAccess<'de>,
60    {
61        let v = match map.next_key::<UnionField_<Variant_>>()? {
62            Some(UnionField_::Type) => {
63                let variant = map.next_value()?;
64                let key = map.next_key()?;
65                match (variant, key) {
66                    (
67                        Variant_::AllowNegativeValues,
68                        Some(Variant_::AllowNegativeValues),
69                    ) => {
70                        let value = map.next_value()?;
71                        NegativeValueConfiguration::AllowNegativeValues(value)
72                    }
73                    (
74                        Variant_::SetNegativeValuesToZero,
75                        Some(Variant_::SetNegativeValuesToZero),
76                    ) => {
77                        let value = map.next_value()?;
78                        NegativeValueConfiguration::SetNegativeValuesToZero(value)
79                    }
80                    (
81                        Variant_::ExcludeNegativeValues,
82                        Some(Variant_::ExcludeNegativeValues),
83                    ) => {
84                        let value = map.next_value()?;
85                        NegativeValueConfiguration::ExcludeNegativeValues(value)
86                    }
87                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
88                        if type_ == b {
89                            let value = map.next_value()?;
90                            NegativeValueConfiguration::Unknown(Unknown { type_, value })
91                        } else {
92                            return Err(
93                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
94                            )
95                        }
96                    }
97                    (variant, Some(key)) => {
98                        return Err(
99                            de::Error::invalid_value(
100                                de::Unexpected::Str(key.as_str()),
101                                &variant.as_str(),
102                            ),
103                        );
104                    }
105                    (variant, None) => {
106                        return Err(de::Error::missing_field(variant.as_str()));
107                    }
108                }
109            }
110            Some(UnionField_::Value(variant)) => {
111                let value = match &variant {
112                    Variant_::AllowNegativeValues => {
113                        let value = map.next_value()?;
114                        NegativeValueConfiguration::AllowNegativeValues(value)
115                    }
116                    Variant_::SetNegativeValuesToZero => {
117                        let value = map.next_value()?;
118                        NegativeValueConfiguration::SetNegativeValuesToZero(value)
119                    }
120                    Variant_::ExcludeNegativeValues => {
121                        let value = map.next_value()?;
122                        NegativeValueConfiguration::ExcludeNegativeValues(value)
123                    }
124                    Variant_::Unknown(type_) => {
125                        let value = map.next_value()?;
126                        NegativeValueConfiguration::Unknown(Unknown {
127                            type_: type_.clone(),
128                            value,
129                        })
130                    }
131                };
132                if map.next_key::<UnionTypeField_>()?.is_none() {
133                    return Err(de::Error::missing_field("type"));
134                }
135                let type_variant = map.next_value::<Variant_>()?;
136                if variant != type_variant {
137                    return Err(
138                        de::Error::invalid_value(
139                            de::Unexpected::Str(type_variant.as_str()),
140                            &variant.as_str(),
141                        ),
142                    );
143                }
144                value
145            }
146            None => return Err(de::Error::missing_field("type")),
147        };
148        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
149            return Err(de::Error::invalid_length(3, &"type and value fields"));
150        }
151        Ok(v)
152    }
153}
154#[derive(PartialEq)]
155enum Variant_ {
156    AllowNegativeValues,
157    SetNegativeValuesToZero,
158    ExcludeNegativeValues,
159    Unknown(Box<str>),
160}
161impl Variant_ {
162    fn as_str(&self) -> &'static str {
163        match *self {
164            Variant_::AllowNegativeValues => "allowNegativeValues",
165            Variant_::SetNegativeValuesToZero => "setNegativeValuesToZero",
166            Variant_::ExcludeNegativeValues => "excludeNegativeValues",
167            Variant_::Unknown(_) => "unknown variant",
168        }
169    }
170}
171impl<'de> de::Deserialize<'de> for Variant_ {
172    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
173    where
174        D: de::Deserializer<'de>,
175    {
176        d.deserialize_str(VariantVisitor_)
177    }
178}
179struct VariantVisitor_;
180impl<'de> de::Visitor<'de> for VariantVisitor_ {
181    type Value = Variant_;
182    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
183        fmt.write_str("string")
184    }
185    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
186    where
187        E: de::Error,
188    {
189        let v = match value {
190            "allowNegativeValues" => Variant_::AllowNegativeValues,
191            "setNegativeValuesToZero" => Variant_::SetNegativeValuesToZero,
192            "excludeNegativeValues" => Variant_::ExcludeNegativeValues,
193            value => Variant_::Unknown(value.to_string().into_boxed_str()),
194        };
195        Ok(v)
196    }
197}
198///An unknown variant of the NegativeValueConfiguration union.
199#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
200pub struct Unknown {
201    type_: Box<str>,
202    value: conjure_object::Any,
203}
204impl Unknown {
205    /// Returns the unknown variant's type name.
206    #[inline]
207    pub fn type_(&self) -> &str {
208        &self.type_
209    }
210}
nominal_api/conjure/objects/scout/compute/api/negative_value_configuration.rs

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