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