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

nominal_api/conjure/objects/scout/video/api/
scale_parameter.rs
