1crate::ix!();
2
3#[cfg(not(feature = "serde_abbreviation"))]
9impl Serialize for AsiaRegion {
10 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
11 where S: Serializer {
12 use serde::ser::SerializeMap;
13
14 let (country_str, region_str_option): (&str, Option<String>) = match self {
15 AsiaRegion::China(r) => ("China" , Some(r.to_string())),
16 AsiaRegion::India(r) => ("India" , Some(r.to_string())),
17 AsiaRegion::Japan(r) => ("Japan" , Some(r.to_string())),
18 AsiaRegion::Indonesia(r) => ("Indonesia" , Some(r.to_string())),
19 AsiaRegion::RussianFederation(r) => ("Russian Federation" , Some(r.to_string())),
20 AsiaRegion::MalaysiaSingaporeBrunei => ("Malaysia, Singapore, and Brunei" , None),
21 AsiaRegion::IsraelAndPalestine => ("Israel and Palestine" , None),
22 AsiaRegion::GccStates => ("GCC States" , None),
23 AsiaRegion::Afghanistan => ("Afghanistan" , None),
24 AsiaRegion::Armenia => ("Armenia" , None),
25 AsiaRegion::Azerbaijan => ("Azerbaijan" , None),
26 AsiaRegion::Bangladesh => ("Bangladesh" , None),
27 AsiaRegion::Bhutan => ("Bhutan" , None),
28 AsiaRegion::Cambodia => ("Cambodia" , None),
29 AsiaRegion::EastTimor => ("East Timor" , None),
30 AsiaRegion::Iran => ("Iran" , None),
31 AsiaRegion::Iraq => ("Iraq" , None),
32 AsiaRegion::Jordan => ("Jordan" , None),
33 AsiaRegion::Kazakhstan => ("Kazakhstan" , None),
34 AsiaRegion::Kyrgyzstan => ("Kyrgyzstan" , None),
35 AsiaRegion::Laos => ("Laos" , None),
36 AsiaRegion::Lebanon => ("Lebanon" , None),
37 AsiaRegion::Maldives => ("Maldives" , None),
38 AsiaRegion::Mongolia => ("Mongolia" , None),
39 AsiaRegion::Myanmar => ("Myanmar" , None),
40 AsiaRegion::Nepal => ("Nepal" , None),
41 AsiaRegion::NorthKorea => ("North Korea" , None),
42 AsiaRegion::Pakistan => ("Pakistan" , None),
43 AsiaRegion::Philippines => ("Philippines" , None),
44 AsiaRegion::SouthKorea => ("South Korea" , None),
45 AsiaRegion::SriLanka => ("Sri Lanka" , None),
46 AsiaRegion::Syria => ("Syria" , None),
47 AsiaRegion::Taiwan => ("Taiwan" , None),
48 AsiaRegion::Tajikistan => ("Tajikistan" , None),
49 AsiaRegion::Thailand => ("Thailand" , None),
50 AsiaRegion::Turkmenistan => ("Turkmenistan" , None),
51 AsiaRegion::Uzbekistan => ("Uzbekistan" , None),
52 AsiaRegion::Vietnam => ("Vietnam" , None),
53 AsiaRegion::Yemen => ("Yemen" , None),
54 };
55
56 let mut map = serializer.serialize_map(Some(
57 if region_str_option.is_some() { 2 } else { 1 }
58 ))?;
59 map.serialize_entry("country", country_str)?;
60 if let Some(r) = region_str_option {
61 map.serialize_entry("region", &r)?;
62 }
63 map.end()
64 }
65}
66
67#[cfg(feature = "serde_abbreviation")]
68impl Serialize for AsiaRegion {
69 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
70 where S: Serializer {
71 serializer.serialize_str(self.abbreviation())
72 }
73}
74
75impl<'de> Deserialize<'de> for AsiaRegion {
76 fn deserialize<D>(deserializer: D) -> Result<AsiaRegion, D::Error>
77 where D: Deserializer<'de> {
78 struct AsiaRegionVisitor;
79
80 impl<'de> serde::de::Visitor<'de> for AsiaRegionVisitor {
81 type Value = AsiaRegion;
82
83 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
84 formatter.write_str("a map with 'country' and optionally 'region'")
85 }
86
87 fn visit_map<A>(self, mut map: A) -> Result<AsiaRegion, A::Error>
88 where A: serde::de::MapAccess<'de> {
89 let mut country: Option<String> = None;
90 let mut region: Option<String> = None;
91
92 while let Some(key) = map.next_key::<String>()? {
93 match key.as_str() {
94 "country" => {
95 country = Some(map.next_value()?);
96 },
97 "region" => {
98 region = Some(map.next_value()?);
99 },
100 _ => {
101 let _: serde_json::Value = map.next_value()?;
102 }
103 }
104 }
105
106 let c = match country {
107 Some(c) => c,
108 None => return Err(DeError::missing_field("country"))
109 };
110
111 if c == "China" {
113 if let Some(r) = region {
114 let cr = r.parse::<ChinaRegion>().map_err(DeError::custom)?;
115 return Ok(AsiaRegion::China(cr));
116 } else {
117 return Ok(AsiaRegion::China(ChinaRegion::default()));
118 }
119 } else if c == "India" {
120 if let Some(r) = region {
121 let ir = r.parse::<IndiaRegion>().map_err(DeError::custom)?;
122 return Ok(AsiaRegion::India(ir));
123 } else {
124 return Ok(AsiaRegion::India(IndiaRegion::default()));
125 }
126 } else if c == "Japan" {
127 if let Some(r) = region {
128 let jr = r.parse::<JapanRegion>().map_err(DeError::custom)?;
129 return Ok(AsiaRegion::Japan(jr));
130 } else {
131 return Ok(AsiaRegion::Japan(JapanRegion::default()));
132 }
133 } else if c == "Indonesia" {
134 if let Some(r) = region {
135 let ir = r.parse::<IndonesiaRegion>().map_err(DeError::custom)?;
136 return Ok(AsiaRegion::Indonesia(ir));
137 } else {
138 return Ok(AsiaRegion::Indonesia(IndonesiaRegion::default()));
139 }
140 } else if c == "Russian Federation" {
141 if let Some(r) = region {
142 let rr = r.parse::<RussianFederationRegion>().map_err(DeError::custom)?;
143 return Ok(AsiaRegion::RussianFederation(rr));
144 } else {
145 return Ok(AsiaRegion::RussianFederation(RussianFederationRegion::default()));
146 }
147 }
148
149 match c.as_str() {
151 "Afghanistan" => Ok(AsiaRegion::Afghanistan),
152 "Armenia" => Ok(AsiaRegion::Armenia),
153 "Azerbaijan" => Ok(AsiaRegion::Azerbaijan),
154 "Bangladesh" => Ok(AsiaRegion::Bangladesh),
155 "Bhutan" => Ok(AsiaRegion::Bhutan),
156 "Cambodia" => Ok(AsiaRegion::Cambodia),
157 "East Timor" => Ok(AsiaRegion::EastTimor),
158 "GCC States" => Ok(AsiaRegion::GccStates),
159 "Iran" => Ok(AsiaRegion::Iran),
160 "Iraq" => Ok(AsiaRegion::Iraq),
161 "Israel and Palestine" => Ok(AsiaRegion::IsraelAndPalestine),
162 "Jordan" => Ok(AsiaRegion::Jordan),
163 "Kazakhstan" => Ok(AsiaRegion::Kazakhstan),
164 "Kyrgyzstan" => Ok(AsiaRegion::Kyrgyzstan),
165 "Laos" => Ok(AsiaRegion::Laos),
166 "Lebanon" => Ok(AsiaRegion::Lebanon),
167 "Malaysia, Singapore, and Brunei" => Ok(AsiaRegion::MalaysiaSingaporeBrunei),
168 "Maldives" => Ok(AsiaRegion::Maldives),
169 "Mongolia" => Ok(AsiaRegion::Mongolia),
170 "Myanmar" => Ok(AsiaRegion::Myanmar),
171 "Nepal" => Ok(AsiaRegion::Nepal),
172 "North Korea" => Ok(AsiaRegion::NorthKorea),
173 "Pakistan" => Ok(AsiaRegion::Pakistan),
174 "Philippines" => Ok(AsiaRegion::Philippines),
175 "South Korea" => Ok(AsiaRegion::SouthKorea),
176 "Sri Lanka" => Ok(AsiaRegion::SriLanka),
177 "Syria" => Ok(AsiaRegion::Syria),
178 "Taiwan" => Ok(AsiaRegion::Taiwan),
179 "Tajikistan" => Ok(AsiaRegion::Tajikistan),
180 "Thailand" => Ok(AsiaRegion::Thailand),
181 "Turkmenistan" => Ok(AsiaRegion::Turkmenistan),
182 "Uzbekistan" => Ok(AsiaRegion::Uzbekistan),
183 "Vietnam" => Ok(AsiaRegion::Vietnam),
184 "Yemen" => Ok(AsiaRegion::Yemen),
185 _ => Err(DeError::unknown_variant(&c, AsiaRegion::VARIANTS)),
186 }
187 }
188 }
189
190 deserializer.deserialize_map(AsiaRegionVisitor)
191 }
192}
193