risingwave_pb/
cloud_service.serde.rs

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

risingwave_pb/
cloud_service.serde.rs
