1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

// DO NOT EDIT
// This file was @generated by Stone

#![allow(
    clippy::too_many_arguments,
    clippy::large_enum_variant,
    clippy::doc_markdown,
)]

/// Possible platforms on which a user may view content.
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive] // variants may be added in the future
pub enum PlatformType {
    /// The content was viewed on the web.
    Web,
    /// The content was viewed on a desktop client.
    Desktop,
    /// The content was viewed on a mobile iOS client.
    MobileIos,
    /// The content was viewed on a mobile android client.
    MobileAndroid,
    /// The content was viewed from an API client.
    Api,
    /// The content was viewed on an unknown platform.
    Unknown,
    /// The content was viewed on a mobile client. DEPRECATED: Use mobile_ios or mobile_android
    /// instead.
    Mobile,
    /// Catch-all used for unrecognized values returned from the server. Encountering this value
    /// typically indicates that this SDK version is out of date.
    Other,
}

impl<'de> ::serde::de::Deserialize<'de> for PlatformType {
    fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        // union deserializer
        use serde::de::{self, MapAccess, Visitor};
        struct EnumVisitor;
        impl<'de> Visitor<'de> for EnumVisitor {
            type Value = PlatformType;
            fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
                f.write_str("a PlatformType structure")
            }
            fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
                let tag: &str = match map.next_key()? {
                    Some(".tag") => map.next_value()?,
                    _ => return Err(de::Error::missing_field(".tag"))
                };
                let value = match tag {
                    "web" => PlatformType::Web,
                    "desktop" => PlatformType::Desktop,
                    "mobile_ios" => PlatformType::MobileIos,
                    "mobile_android" => PlatformType::MobileAndroid,
                    "api" => PlatformType::Api,
                    "unknown" => PlatformType::Unknown,
                    "mobile" => PlatformType::Mobile,
                    _ => PlatformType::Other,
                };
                crate::eat_json_fields(&mut map)?;
                Ok(value)
            }
        }
        const VARIANTS: &[&str] = &["web",
                                    "desktop",
                                    "mobile_ios",
                                    "mobile_android",
                                    "api",
                                    "unknown",
                                    "mobile",
                                    "other"];
        deserializer.deserialize_struct("PlatformType", VARIANTS, EnumVisitor)
    }
}

impl ::serde::ser::Serialize for PlatformType {
    fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        // union serializer
        use serde::ser::SerializeStruct;
        match *self {
            PlatformType::Web => {
                // unit
                let mut s = serializer.serialize_struct("PlatformType", 1)?;
                s.serialize_field(".tag", "web")?;
                s.end()
            }
            PlatformType::Desktop => {
                // unit
                let mut s = serializer.serialize_struct("PlatformType", 1)?;
                s.serialize_field(".tag", "desktop")?;
                s.end()
            }
            PlatformType::MobileIos => {
                // unit
                let mut s = serializer.serialize_struct("PlatformType", 1)?;
                s.serialize_field(".tag", "mobile_ios")?;
                s.end()
            }
            PlatformType::MobileAndroid => {
                // unit
                let mut s = serializer.serialize_struct("PlatformType", 1)?;
                s.serialize_field(".tag", "mobile_android")?;
                s.end()
            }
            PlatformType::Api => {
                // unit
                let mut s = serializer.serialize_struct("PlatformType", 1)?;
                s.serialize_field(".tag", "api")?;
                s.end()
            }
            PlatformType::Unknown => {
                // unit
                let mut s = serializer.serialize_struct("PlatformType", 1)?;
                s.serialize_field(".tag", "unknown")?;
                s.end()
            }
            PlatformType::Mobile => {
                // unit
                let mut s = serializer.serialize_struct("PlatformType", 1)?;
                s.serialize_field(".tag", "mobile")?;
                s.end()
            }
            PlatformType::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
        }
    }
}