1#![allow(clippy::useless_conversion)]
2use crate::cloud_service::*;
3impl serde::Serialize for RwCloudValidateSourceRequest {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if self.source_type != 0 {
12 len += 1;
13 }
14 if !self.source_config.is_empty() {
15 len += 1;
16 }
17 let mut struct_ser = serializer.serialize_struct("cloud_service.RwCloudValidateSourceRequest", len)?;
18 if self.source_type != 0 {
19 let v = SourceType::try_from(self.source_type)
20 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.source_type)))?;
21 struct_ser.serialize_field("sourceType", &v)?;
22 }
23 if !self.source_config.is_empty() {
24 struct_ser.serialize_field("sourceConfig", &self.source_config)?;
25 }
26 struct_ser.end()
27 }
28}
29impl<'de> serde::Deserialize<'de> for RwCloudValidateSourceRequest {
30 #[allow(deprecated)]
31 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
32 where
33 D: serde::Deserializer<'de>,
34 {
35 const FIELDS: &[&str] = &[
36 "source_type",
37 "sourceType",
38 "source_config",
39 "sourceConfig",
40 ];
41
42 #[allow(clippy::enum_variant_names)]
43 enum GeneratedField {
44 SourceType,
45 SourceConfig,
46 }
47 impl<'de> serde::Deserialize<'de> for GeneratedField {
48 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
49 where
50 D: serde::Deserializer<'de>,
51 {
52 struct GeneratedVisitor;
53
54 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
55 type Value = GeneratedField;
56
57 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
58 write!(formatter, "expected one of: {:?}", &FIELDS)
59 }
60
61 #[allow(unused_variables)]
62 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
63 where
64 E: serde::de::Error,
65 {
66 match value {
67 "sourceType" | "source_type" => Ok(GeneratedField::SourceType),
68 "sourceConfig" | "source_config" => Ok(GeneratedField::SourceConfig),
69 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
70 }
71 }
72 }
73 deserializer.deserialize_identifier(GeneratedVisitor)
74 }
75 }
76 struct GeneratedVisitor;
77 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
78 type Value = RwCloudValidateSourceRequest;
79
80 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
81 formatter.write_str("struct cloud_service.RwCloudValidateSourceRequest")
82 }
83
84 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RwCloudValidateSourceRequest, V::Error>
85 where
86 V: serde::de::MapAccess<'de>,
87 {
88 let mut source_type__ = None;
89 let mut source_config__ = None;
90 while let Some(k) = map_.next_key()? {
91 match k {
92 GeneratedField::SourceType => {
93 if source_type__.is_some() {
94 return Err(serde::de::Error::duplicate_field("sourceType"));
95 }
96 source_type__ = Some(map_.next_value::<SourceType>()? as i32);
97 }
98 GeneratedField::SourceConfig => {
99 if source_config__.is_some() {
100 return Err(serde::de::Error::duplicate_field("sourceConfig"));
101 }
102 source_config__ = Some(
103 map_.next_value::<std::collections::HashMap<_, _>>()?
104 );
105 }
106 }
107 }
108 Ok(RwCloudValidateSourceRequest {
109 source_type: source_type__.unwrap_or_default(),
110 source_config: source_config__.unwrap_or_default(),
111 })
112 }
113 }
114 deserializer.deserialize_struct("cloud_service.RwCloudValidateSourceRequest", FIELDS, GeneratedVisitor)
115 }
116}
117impl serde::Serialize for RwCloudValidateSourceResponse {
118 #[allow(deprecated)]
119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
120 where
121 S: serde::Serializer,
122 {
123 use serde::ser::SerializeStruct;
124 let mut len = 0;
125 if self.ok {
126 len += 1;
127 }
128 if self.error.is_some() {
129 len += 1;
130 }
131 let mut struct_ser = serializer.serialize_struct("cloud_service.RwCloudValidateSourceResponse", len)?;
132 if self.ok {
133 struct_ser.serialize_field("ok", &self.ok)?;
134 }
135 if let Some(v) = self.error.as_ref() {
136 struct_ser.serialize_field("error", v)?;
137 }
138 struct_ser.end()
139 }
140}
141impl<'de> serde::Deserialize<'de> for RwCloudValidateSourceResponse {
142 #[allow(deprecated)]
143 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
144 where
145 D: serde::Deserializer<'de>,
146 {
147 const FIELDS: &[&str] = &[
148 "ok",
149 "error",
150 ];
151
152 #[allow(clippy::enum_variant_names)]
153 enum GeneratedField {
154 Ok,
155 Error,
156 }
157 impl<'de> serde::Deserialize<'de> for GeneratedField {
158 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
159 where
160 D: serde::Deserializer<'de>,
161 {
162 struct GeneratedVisitor;
163
164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
165 type Value = GeneratedField;
166
167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
168 write!(formatter, "expected one of: {:?}", &FIELDS)
169 }
170
171 #[allow(unused_variables)]
172 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
173 where
174 E: serde::de::Error,
175 {
176 match value {
177 "ok" => Ok(GeneratedField::Ok),
178 "error" => Ok(GeneratedField::Error),
179 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
180 }
181 }
182 }
183 deserializer.deserialize_identifier(GeneratedVisitor)
184 }
185 }
186 struct GeneratedVisitor;
187 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
188 type Value = RwCloudValidateSourceResponse;
189
190 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
191 formatter.write_str("struct cloud_service.RwCloudValidateSourceResponse")
192 }
193
194 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RwCloudValidateSourceResponse, V::Error>
195 where
196 V: serde::de::MapAccess<'de>,
197 {
198 let mut ok__ = None;
199 let mut error__ = None;
200 while let Some(k) = map_.next_key()? {
201 match k {
202 GeneratedField::Ok => {
203 if ok__.is_some() {
204 return Err(serde::de::Error::duplicate_field("ok"));
205 }
206 ok__ = Some(map_.next_value()?);
207 }
208 GeneratedField::Error => {
209 if error__.is_some() {
210 return Err(serde::de::Error::duplicate_field("error"));
211 }
212 error__ = map_.next_value()?;
213 }
214 }
215 }
216 Ok(RwCloudValidateSourceResponse {
217 ok: ok__.unwrap_or_default(),
218 error: error__,
219 })
220 }
221 }
222 deserializer.deserialize_struct("cloud_service.RwCloudValidateSourceResponse", FIELDS, GeneratedVisitor)
223 }
224}
225impl serde::Serialize for rw_cloud_validate_source_response::Error {
226 #[allow(deprecated)]
227 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
228 where
229 S: serde::Serializer,
230 {
231 use serde::ser::SerializeStruct;
232 let mut len = 0;
233 if self.error_type != 0 {
234 len += 1;
235 }
236 if !self.error_message.is_empty() {
237 len += 1;
238 }
239 let mut struct_ser = serializer.serialize_struct("cloud_service.RwCloudValidateSourceResponse.Error", len)?;
240 if self.error_type != 0 {
241 let v = rw_cloud_validate_source_response::ErrorType::try_from(self.error_type)
242 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.error_type)))?;
243 struct_ser.serialize_field("errorType", &v)?;
244 }
245 if !self.error_message.is_empty() {
246 struct_ser.serialize_field("errorMessage", &self.error_message)?;
247 }
248 struct_ser.end()
249 }
250}
251impl<'de> serde::Deserialize<'de> for rw_cloud_validate_source_response::Error {
252 #[allow(deprecated)]
253 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
254 where
255 D: serde::Deserializer<'de>,
256 {
257 const FIELDS: &[&str] = &[
258 "error_type",
259 "errorType",
260 "error_message",
261 "errorMessage",
262 ];
263
264 #[allow(clippy::enum_variant_names)]
265 enum GeneratedField {
266 ErrorType,
267 ErrorMessage,
268 }
269 impl<'de> serde::Deserialize<'de> for GeneratedField {
270 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
271 where
272 D: serde::Deserializer<'de>,
273 {
274 struct GeneratedVisitor;
275
276 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
277 type Value = GeneratedField;
278
279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
280 write!(formatter, "expected one of: {:?}", &FIELDS)
281 }
282
283 #[allow(unused_variables)]
284 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
285 where
286 E: serde::de::Error,
287 {
288 match value {
289 "errorType" | "error_type" => Ok(GeneratedField::ErrorType),
290 "errorMessage" | "error_message" => Ok(GeneratedField::ErrorMessage),
291 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
292 }
293 }
294 }
295 deserializer.deserialize_identifier(GeneratedVisitor)
296 }
297 }
298 struct GeneratedVisitor;
299 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
300 type Value = rw_cloud_validate_source_response::Error;
301
302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
303 formatter.write_str("struct cloud_service.RwCloudValidateSourceResponse.Error")
304 }
305
306 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rw_cloud_validate_source_response::Error, V::Error>
307 where
308 V: serde::de::MapAccess<'de>,
309 {
310 let mut error_type__ = None;
311 let mut error_message__ = None;
312 while let Some(k) = map_.next_key()? {
313 match k {
314 GeneratedField::ErrorType => {
315 if error_type__.is_some() {
316 return Err(serde::de::Error::duplicate_field("errorType"));
317 }
318 error_type__ = Some(map_.next_value::<rw_cloud_validate_source_response::ErrorType>()? as i32);
319 }
320 GeneratedField::ErrorMessage => {
321 if error_message__.is_some() {
322 return Err(serde::de::Error::duplicate_field("errorMessage"));
323 }
324 error_message__ = Some(map_.next_value()?);
325 }
326 }
327 }
328 Ok(rw_cloud_validate_source_response::Error {
329 error_type: error_type__.unwrap_or_default(),
330 error_message: error_message__.unwrap_or_default(),
331 })
332 }
333 }
334 deserializer.deserialize_struct("cloud_service.RwCloudValidateSourceResponse.Error", FIELDS, GeneratedVisitor)
335 }
336}
337impl serde::Serialize for rw_cloud_validate_source_response::ErrorType {
338 #[allow(deprecated)]
339 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
340 where
341 S: serde::Serializer,
342 {
343 let variant = match self {
344 Self::Unspecified => "UNSPECIFIED",
345 Self::PrivatelinkConnectionNotFound => "PRIVATELINK_CONNECTION_NOT_FOUND",
346 Self::PrivatelinkUnavailable => "PRIVATELINK_UNAVAILABLE",
347 Self::PrivatelinkResolveErr => "PRIVATELINK_RESOLVE_ERR",
348 Self::KafkaInvalidProperties => "KAFKA_INVALID_PROPERTIES",
349 Self::KafkaTopicNotFound => "KAFKA_TOPIC_NOT_FOUND",
350 Self::KafkaBrokerUnreachable => "KAFKA_BROKER_UNREACHABLE",
351 Self::KafkaOther => "KAFKA_OTHER",
352 Self::AwsClientNotConfigured => "AWS_CLIENT_NOT_CONFIGURED",
353 };
354 serializer.serialize_str(variant)
355 }
356}
357impl<'de> serde::Deserialize<'de> for rw_cloud_validate_source_response::ErrorType {
358 #[allow(deprecated)]
359 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
360 where
361 D: serde::Deserializer<'de>,
362 {
363 const FIELDS: &[&str] = &[
364 "UNSPECIFIED",
365 "PRIVATELINK_CONNECTION_NOT_FOUND",
366 "PRIVATELINK_UNAVAILABLE",
367 "PRIVATELINK_RESOLVE_ERR",
368 "KAFKA_INVALID_PROPERTIES",
369 "KAFKA_TOPIC_NOT_FOUND",
370 "KAFKA_BROKER_UNREACHABLE",
371 "KAFKA_OTHER",
372 "AWS_CLIENT_NOT_CONFIGURED",
373 ];
374
375 struct GeneratedVisitor;
376
377 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
378 type Value = rw_cloud_validate_source_response::ErrorType;
379
380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
381 write!(formatter, "expected one of: {:?}", &FIELDS)
382 }
383
384 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
385 where
386 E: serde::de::Error,
387 {
388 i32::try_from(v)
389 .ok()
390 .and_then(|x| x.try_into().ok())
391 .ok_or_else(|| {
392 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
393 })
394 }
395
396 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
397 where
398 E: serde::de::Error,
399 {
400 i32::try_from(v)
401 .ok()
402 .and_then(|x| x.try_into().ok())
403 .ok_or_else(|| {
404 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
405 })
406 }
407
408 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
409 where
410 E: serde::de::Error,
411 {
412 match value {
413 "UNSPECIFIED" => Ok(rw_cloud_validate_source_response::ErrorType::Unspecified),
414 "PRIVATELINK_CONNECTION_NOT_FOUND" => Ok(rw_cloud_validate_source_response::ErrorType::PrivatelinkConnectionNotFound),
415 "PRIVATELINK_UNAVAILABLE" => Ok(rw_cloud_validate_source_response::ErrorType::PrivatelinkUnavailable),
416 "PRIVATELINK_RESOLVE_ERR" => Ok(rw_cloud_validate_source_response::ErrorType::PrivatelinkResolveErr),
417 "KAFKA_INVALID_PROPERTIES" => Ok(rw_cloud_validate_source_response::ErrorType::KafkaInvalidProperties),
418 "KAFKA_TOPIC_NOT_FOUND" => Ok(rw_cloud_validate_source_response::ErrorType::KafkaTopicNotFound),
419 "KAFKA_BROKER_UNREACHABLE" => Ok(rw_cloud_validate_source_response::ErrorType::KafkaBrokerUnreachable),
420 "KAFKA_OTHER" => Ok(rw_cloud_validate_source_response::ErrorType::KafkaOther),
421 "AWS_CLIENT_NOT_CONFIGURED" => Ok(rw_cloud_validate_source_response::ErrorType::AwsClientNotConfigured),
422 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
423 }
424 }
425 }
426 deserializer.deserialize_any(GeneratedVisitor)
427 }
428}
429impl serde::Serialize for SourceType {
430 #[allow(deprecated)]
431 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
432 where
433 S: serde::Serializer,
434 {
435 let variant = match self {
436 Self::Unspecified => "UNSPECIFIED",
437 Self::Kafka => "KAFKA",
438 };
439 serializer.serialize_str(variant)
440 }
441}
442impl<'de> serde::Deserialize<'de> for SourceType {
443 #[allow(deprecated)]
444 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
445 where
446 D: serde::Deserializer<'de>,
447 {
448 const FIELDS: &[&str] = &[
449 "UNSPECIFIED",
450 "KAFKA",
451 ];
452
453 struct GeneratedVisitor;
454
455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
456 type Value = SourceType;
457
458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
459 write!(formatter, "expected one of: {:?}", &FIELDS)
460 }
461
462 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
463 where
464 E: serde::de::Error,
465 {
466 i32::try_from(v)
467 .ok()
468 .and_then(|x| x.try_into().ok())
469 .ok_or_else(|| {
470 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
471 })
472 }
473
474 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
475 where
476 E: serde::de::Error,
477 {
478 i32::try_from(v)
479 .ok()
480 .and_then(|x| x.try_into().ok())
481 .ok_or_else(|| {
482 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
483 })
484 }
485
486 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
487 where
488 E: serde::de::Error,
489 {
490 match value {
491 "UNSPECIFIED" => Ok(SourceType::Unspecified),
492 "KAFKA" => Ok(SourceType::Kafka),
493 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
494 }
495 }
496 }
497 deserializer.deserialize_any(GeneratedVisitor)
498 }
499}