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

nominal_api/conjure/objects/storage/writer/api/
arrays_values.rs
