risingwave_pb/
backup_service.serde.rs

1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::backup_service::*;
4impl serde::Serialize for BackupJobStatus {
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        let variant = match self {
11            Self::Unspecified => "UNSPECIFIED",
12            Self::Running => "RUNNING",
13            Self::Succeeded => "SUCCEEDED",
14            Self::NotFound => "NOT_FOUND",
15            Self::Failed => "FAILED",
16        };
17        serializer.serialize_str(variant)
18    }
19}
20impl<'de> serde::Deserialize<'de> for BackupJobStatus {
21    #[allow(deprecated)]
22    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
23    where
24        D: serde::Deserializer<'de>,
25    {
26        const FIELDS: &[&str] = &[
27            "UNSPECIFIED",
28            "RUNNING",
29            "SUCCEEDED",
30            "NOT_FOUND",
31            "FAILED",
32        ];
33
34        struct GeneratedVisitor;
35
36        impl serde::de::Visitor<'_> for GeneratedVisitor {
37            type Value = BackupJobStatus;
38
39            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
40                write!(formatter, "expected one of: {:?}", &FIELDS)
41            }
42
43            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
44            where
45                E: serde::de::Error,
46            {
47                i32::try_from(v)
48                    .ok()
49                    .and_then(|x| x.try_into().ok())
50                    .ok_or_else(|| {
51                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
52                    })
53            }
54
55            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
56            where
57                E: serde::de::Error,
58            {
59                i32::try_from(v)
60                    .ok()
61                    .and_then(|x| x.try_into().ok())
62                    .ok_or_else(|| {
63                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
64                    })
65            }
66
67            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
68            where
69                E: serde::de::Error,
70            {
71                match value {
72                    "UNSPECIFIED" => Ok(BackupJobStatus::Unspecified),
73                    "RUNNING" => Ok(BackupJobStatus::Running),
74                    "SUCCEEDED" => Ok(BackupJobStatus::Succeeded),
75                    "NOT_FOUND" => Ok(BackupJobStatus::NotFound),
76                    "FAILED" => Ok(BackupJobStatus::Failed),
77                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
78                }
79            }
80        }
81        deserializer.deserialize_any(GeneratedVisitor)
82    }
83}
84impl serde::Serialize for BackupMetaRequest {
85    #[allow(deprecated)]
86    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
87    where
88        S: serde::Serializer,
89    {
90        use serde::ser::SerializeStruct;
91        let mut len = 0;
92        if self.remarks.is_some() {
93            len += 1;
94        }
95        let mut struct_ser = serializer.serialize_struct("backup_service.BackupMetaRequest", len)?;
96        if let Some(v) = self.remarks.as_ref() {
97            struct_ser.serialize_field("remarks", v)?;
98        }
99        struct_ser.end()
100    }
101}
102impl<'de> serde::Deserialize<'de> for BackupMetaRequest {
103    #[allow(deprecated)]
104    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
105    where
106        D: serde::Deserializer<'de>,
107    {
108        const FIELDS: &[&str] = &[
109            "remarks",
110        ];
111
112        #[allow(clippy::enum_variant_names)]
113        enum GeneratedField {
114            Remarks,
115        }
116        impl<'de> serde::Deserialize<'de> for GeneratedField {
117            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
118            where
119                D: serde::Deserializer<'de>,
120            {
121                struct GeneratedVisitor;
122
123                impl serde::de::Visitor<'_> for GeneratedVisitor {
124                    type Value = GeneratedField;
125
126                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
127                        write!(formatter, "expected one of: {:?}", &FIELDS)
128                    }
129
130                    #[allow(unused_variables)]
131                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
132                    where
133                        E: serde::de::Error,
134                    {
135                        match value {
136                            "remarks" => Ok(GeneratedField::Remarks),
137                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
138                        }
139                    }
140                }
141                deserializer.deserialize_identifier(GeneratedVisitor)
142            }
143        }
144        struct GeneratedVisitor;
145        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
146            type Value = BackupMetaRequest;
147
148            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
149                formatter.write_str("struct backup_service.BackupMetaRequest")
150            }
151
152            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackupMetaRequest, V::Error>
153                where
154                    V: serde::de::MapAccess<'de>,
155            {
156                let mut remarks__ = None;
157                while let Some(k) = map_.next_key()? {
158                    match k {
159                        GeneratedField::Remarks => {
160                            if remarks__.is_some() {
161                                return Err(serde::de::Error::duplicate_field("remarks"));
162                            }
163                            remarks__ = map_.next_value()?;
164                        }
165                    }
166                }
167                Ok(BackupMetaRequest {
168                    remarks: remarks__,
169                })
170            }
171        }
172        deserializer.deserialize_struct("backup_service.BackupMetaRequest", FIELDS, GeneratedVisitor)
173    }
174}
175impl serde::Serialize for BackupMetaResponse {
176    #[allow(deprecated)]
177    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
178    where
179        S: serde::Serializer,
180    {
181        use serde::ser::SerializeStruct;
182        let mut len = 0;
183        if self.job_id != 0 {
184            len += 1;
185        }
186        let mut struct_ser = serializer.serialize_struct("backup_service.BackupMetaResponse", len)?;
187        if self.job_id != 0 {
188            #[allow(clippy::needless_borrow)]
189            #[allow(clippy::needless_borrows_for_generic_args)]
190            struct_ser.serialize_field("jobId", ToString::to_string(&self.job_id).as_str())?;
191        }
192        struct_ser.end()
193    }
194}
195impl<'de> serde::Deserialize<'de> for BackupMetaResponse {
196    #[allow(deprecated)]
197    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
198    where
199        D: serde::Deserializer<'de>,
200    {
201        const FIELDS: &[&str] = &[
202            "job_id",
203            "jobId",
204        ];
205
206        #[allow(clippy::enum_variant_names)]
207        enum GeneratedField {
208            JobId,
209        }
210        impl<'de> serde::Deserialize<'de> for GeneratedField {
211            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
212            where
213                D: serde::Deserializer<'de>,
214            {
215                struct GeneratedVisitor;
216
217                impl serde::de::Visitor<'_> for GeneratedVisitor {
218                    type Value = GeneratedField;
219
220                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
221                        write!(formatter, "expected one of: {:?}", &FIELDS)
222                    }
223
224                    #[allow(unused_variables)]
225                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
226                    where
227                        E: serde::de::Error,
228                    {
229                        match value {
230                            "jobId" | "job_id" => Ok(GeneratedField::JobId),
231                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
232                        }
233                    }
234                }
235                deserializer.deserialize_identifier(GeneratedVisitor)
236            }
237        }
238        struct GeneratedVisitor;
239        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
240            type Value = BackupMetaResponse;
241
242            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
243                formatter.write_str("struct backup_service.BackupMetaResponse")
244            }
245
246            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackupMetaResponse, V::Error>
247                where
248                    V: serde::de::MapAccess<'de>,
249            {
250                let mut job_id__ = None;
251                while let Some(k) = map_.next_key()? {
252                    match k {
253                        GeneratedField::JobId => {
254                            if job_id__.is_some() {
255                                return Err(serde::de::Error::duplicate_field("jobId"));
256                            }
257                            job_id__ = 
258                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
259                            ;
260                        }
261                    }
262                }
263                Ok(BackupMetaResponse {
264                    job_id: job_id__.unwrap_or_default(),
265                })
266            }
267        }
268        deserializer.deserialize_struct("backup_service.BackupMetaResponse", FIELDS, GeneratedVisitor)
269    }
270}
271impl serde::Serialize for DeleteMetaSnapshotRequest {
272    #[allow(deprecated)]
273    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
274    where
275        S: serde::Serializer,
276    {
277        use serde::ser::SerializeStruct;
278        let mut len = 0;
279        if !self.snapshot_ids.is_empty() {
280            len += 1;
281        }
282        let mut struct_ser = serializer.serialize_struct("backup_service.DeleteMetaSnapshotRequest", len)?;
283        if !self.snapshot_ids.is_empty() {
284            struct_ser.serialize_field("snapshotIds", &self.snapshot_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
285        }
286        struct_ser.end()
287    }
288}
289impl<'de> serde::Deserialize<'de> for DeleteMetaSnapshotRequest {
290    #[allow(deprecated)]
291    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
292    where
293        D: serde::Deserializer<'de>,
294    {
295        const FIELDS: &[&str] = &[
296            "snapshot_ids",
297            "snapshotIds",
298        ];
299
300        #[allow(clippy::enum_variant_names)]
301        enum GeneratedField {
302            SnapshotIds,
303        }
304        impl<'de> serde::Deserialize<'de> for GeneratedField {
305            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
306            where
307                D: serde::Deserializer<'de>,
308            {
309                struct GeneratedVisitor;
310
311                impl serde::de::Visitor<'_> for GeneratedVisitor {
312                    type Value = GeneratedField;
313
314                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
315                        write!(formatter, "expected one of: {:?}", &FIELDS)
316                    }
317
318                    #[allow(unused_variables)]
319                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
320                    where
321                        E: serde::de::Error,
322                    {
323                        match value {
324                            "snapshotIds" | "snapshot_ids" => Ok(GeneratedField::SnapshotIds),
325                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
326                        }
327                    }
328                }
329                deserializer.deserialize_identifier(GeneratedVisitor)
330            }
331        }
332        struct GeneratedVisitor;
333        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
334            type Value = DeleteMetaSnapshotRequest;
335
336            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
337                formatter.write_str("struct backup_service.DeleteMetaSnapshotRequest")
338            }
339
340            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteMetaSnapshotRequest, V::Error>
341                where
342                    V: serde::de::MapAccess<'de>,
343            {
344                let mut snapshot_ids__ = None;
345                while let Some(k) = map_.next_key()? {
346                    match k {
347                        GeneratedField::SnapshotIds => {
348                            if snapshot_ids__.is_some() {
349                                return Err(serde::de::Error::duplicate_field("snapshotIds"));
350                            }
351                            snapshot_ids__ = 
352                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
353                                    .into_iter().map(|x| x.0).collect())
354                            ;
355                        }
356                    }
357                }
358                Ok(DeleteMetaSnapshotRequest {
359                    snapshot_ids: snapshot_ids__.unwrap_or_default(),
360                })
361            }
362        }
363        deserializer.deserialize_struct("backup_service.DeleteMetaSnapshotRequest", FIELDS, GeneratedVisitor)
364    }
365}
366impl serde::Serialize for DeleteMetaSnapshotResponse {
367    #[allow(deprecated)]
368    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
369    where
370        S: serde::Serializer,
371    {
372        use serde::ser::SerializeStruct;
373        let len = 0;
374        let struct_ser = serializer.serialize_struct("backup_service.DeleteMetaSnapshotResponse", len)?;
375        struct_ser.end()
376    }
377}
378impl<'de> serde::Deserialize<'de> for DeleteMetaSnapshotResponse {
379    #[allow(deprecated)]
380    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
381    where
382        D: serde::Deserializer<'de>,
383    {
384        const FIELDS: &[&str] = &[
385        ];
386
387        #[allow(clippy::enum_variant_names)]
388        enum GeneratedField {
389        }
390        impl<'de> serde::Deserialize<'de> for GeneratedField {
391            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
392            where
393                D: serde::Deserializer<'de>,
394            {
395                struct GeneratedVisitor;
396
397                impl serde::de::Visitor<'_> for GeneratedVisitor {
398                    type Value = GeneratedField;
399
400                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
401                        write!(formatter, "expected one of: {:?}", &FIELDS)
402                    }
403
404                    #[allow(unused_variables)]
405                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
406                    where
407                        E: serde::de::Error,
408                    {
409                            Err(serde::de::Error::unknown_field(value, FIELDS))
410                    }
411                }
412                deserializer.deserialize_identifier(GeneratedVisitor)
413            }
414        }
415        struct GeneratedVisitor;
416        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
417            type Value = DeleteMetaSnapshotResponse;
418
419            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
420                formatter.write_str("struct backup_service.DeleteMetaSnapshotResponse")
421            }
422
423            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteMetaSnapshotResponse, V::Error>
424                where
425                    V: serde::de::MapAccess<'de>,
426            {
427                while map_.next_key::<GeneratedField>()?.is_some() {
428                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
429                }
430                Ok(DeleteMetaSnapshotResponse {
431                })
432            }
433        }
434        deserializer.deserialize_struct("backup_service.DeleteMetaSnapshotResponse", FIELDS, GeneratedVisitor)
435    }
436}
437impl serde::Serialize for GetBackupJobStatusRequest {
438    #[allow(deprecated)]
439    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
440    where
441        S: serde::Serializer,
442    {
443        use serde::ser::SerializeStruct;
444        let mut len = 0;
445        if self.job_id != 0 {
446            len += 1;
447        }
448        let mut struct_ser = serializer.serialize_struct("backup_service.GetBackupJobStatusRequest", len)?;
449        if self.job_id != 0 {
450            #[allow(clippy::needless_borrow)]
451            #[allow(clippy::needless_borrows_for_generic_args)]
452            struct_ser.serialize_field("jobId", ToString::to_string(&self.job_id).as_str())?;
453        }
454        struct_ser.end()
455    }
456}
457impl<'de> serde::Deserialize<'de> for GetBackupJobStatusRequest {
458    #[allow(deprecated)]
459    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
460    where
461        D: serde::Deserializer<'de>,
462    {
463        const FIELDS: &[&str] = &[
464            "job_id",
465            "jobId",
466        ];
467
468        #[allow(clippy::enum_variant_names)]
469        enum GeneratedField {
470            JobId,
471        }
472        impl<'de> serde::Deserialize<'de> for GeneratedField {
473            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
474            where
475                D: serde::Deserializer<'de>,
476            {
477                struct GeneratedVisitor;
478
479                impl serde::de::Visitor<'_> for GeneratedVisitor {
480                    type Value = GeneratedField;
481
482                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
483                        write!(formatter, "expected one of: {:?}", &FIELDS)
484                    }
485
486                    #[allow(unused_variables)]
487                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
488                    where
489                        E: serde::de::Error,
490                    {
491                        match value {
492                            "jobId" | "job_id" => Ok(GeneratedField::JobId),
493                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
494                        }
495                    }
496                }
497                deserializer.deserialize_identifier(GeneratedVisitor)
498            }
499        }
500        struct GeneratedVisitor;
501        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
502            type Value = GetBackupJobStatusRequest;
503
504            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
505                formatter.write_str("struct backup_service.GetBackupJobStatusRequest")
506            }
507
508            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetBackupJobStatusRequest, V::Error>
509                where
510                    V: serde::de::MapAccess<'de>,
511            {
512                let mut job_id__ = None;
513                while let Some(k) = map_.next_key()? {
514                    match k {
515                        GeneratedField::JobId => {
516                            if job_id__.is_some() {
517                                return Err(serde::de::Error::duplicate_field("jobId"));
518                            }
519                            job_id__ = 
520                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
521                            ;
522                        }
523                    }
524                }
525                Ok(GetBackupJobStatusRequest {
526                    job_id: job_id__.unwrap_or_default(),
527                })
528            }
529        }
530        deserializer.deserialize_struct("backup_service.GetBackupJobStatusRequest", FIELDS, GeneratedVisitor)
531    }
532}
533impl serde::Serialize for GetBackupJobStatusResponse {
534    #[allow(deprecated)]
535    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
536    where
537        S: serde::Serializer,
538    {
539        use serde::ser::SerializeStruct;
540        let mut len = 0;
541        if self.job_id != 0 {
542            len += 1;
543        }
544        if self.job_status != 0 {
545            len += 1;
546        }
547        if !self.message.is_empty() {
548            len += 1;
549        }
550        let mut struct_ser = serializer.serialize_struct("backup_service.GetBackupJobStatusResponse", len)?;
551        if self.job_id != 0 {
552            #[allow(clippy::needless_borrow)]
553            #[allow(clippy::needless_borrows_for_generic_args)]
554            struct_ser.serialize_field("jobId", ToString::to_string(&self.job_id).as_str())?;
555        }
556        if self.job_status != 0 {
557            let v = BackupJobStatus::try_from(self.job_status)
558                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_status)))?;
559            struct_ser.serialize_field("jobStatus", &v)?;
560        }
561        if !self.message.is_empty() {
562            struct_ser.serialize_field("message", &self.message)?;
563        }
564        struct_ser.end()
565    }
566}
567impl<'de> serde::Deserialize<'de> for GetBackupJobStatusResponse {
568    #[allow(deprecated)]
569    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
570    where
571        D: serde::Deserializer<'de>,
572    {
573        const FIELDS: &[&str] = &[
574            "job_id",
575            "jobId",
576            "job_status",
577            "jobStatus",
578            "message",
579        ];
580
581        #[allow(clippy::enum_variant_names)]
582        enum GeneratedField {
583            JobId,
584            JobStatus,
585            Message,
586        }
587        impl<'de> serde::Deserialize<'de> for GeneratedField {
588            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
589            where
590                D: serde::Deserializer<'de>,
591            {
592                struct GeneratedVisitor;
593
594                impl serde::de::Visitor<'_> for GeneratedVisitor {
595                    type Value = GeneratedField;
596
597                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
598                        write!(formatter, "expected one of: {:?}", &FIELDS)
599                    }
600
601                    #[allow(unused_variables)]
602                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
603                    where
604                        E: serde::de::Error,
605                    {
606                        match value {
607                            "jobId" | "job_id" => Ok(GeneratedField::JobId),
608                            "jobStatus" | "job_status" => Ok(GeneratedField::JobStatus),
609                            "message" => Ok(GeneratedField::Message),
610                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
611                        }
612                    }
613                }
614                deserializer.deserialize_identifier(GeneratedVisitor)
615            }
616        }
617        struct GeneratedVisitor;
618        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
619            type Value = GetBackupJobStatusResponse;
620
621            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
622                formatter.write_str("struct backup_service.GetBackupJobStatusResponse")
623            }
624
625            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetBackupJobStatusResponse, V::Error>
626                where
627                    V: serde::de::MapAccess<'de>,
628            {
629                let mut job_id__ = None;
630                let mut job_status__ = None;
631                let mut message__ = None;
632                while let Some(k) = map_.next_key()? {
633                    match k {
634                        GeneratedField::JobId => {
635                            if job_id__.is_some() {
636                                return Err(serde::de::Error::duplicate_field("jobId"));
637                            }
638                            job_id__ = 
639                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
640                            ;
641                        }
642                        GeneratedField::JobStatus => {
643                            if job_status__.is_some() {
644                                return Err(serde::de::Error::duplicate_field("jobStatus"));
645                            }
646                            job_status__ = Some(map_.next_value::<BackupJobStatus>()? as i32);
647                        }
648                        GeneratedField::Message => {
649                            if message__.is_some() {
650                                return Err(serde::de::Error::duplicate_field("message"));
651                            }
652                            message__ = Some(map_.next_value()?);
653                        }
654                    }
655                }
656                Ok(GetBackupJobStatusResponse {
657                    job_id: job_id__.unwrap_or_default(),
658                    job_status: job_status__.unwrap_or_default(),
659                    message: message__.unwrap_or_default(),
660                })
661            }
662        }
663        deserializer.deserialize_struct("backup_service.GetBackupJobStatusResponse", FIELDS, GeneratedVisitor)
664    }
665}
666impl serde::Serialize for GetMetaSnapshotManifestRequest {
667    #[allow(deprecated)]
668    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
669    where
670        S: serde::Serializer,
671    {
672        use serde::ser::SerializeStruct;
673        let len = 0;
674        let struct_ser = serializer.serialize_struct("backup_service.GetMetaSnapshotManifestRequest", len)?;
675        struct_ser.end()
676    }
677}
678impl<'de> serde::Deserialize<'de> for GetMetaSnapshotManifestRequest {
679    #[allow(deprecated)]
680    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
681    where
682        D: serde::Deserializer<'de>,
683    {
684        const FIELDS: &[&str] = &[
685        ];
686
687        #[allow(clippy::enum_variant_names)]
688        enum GeneratedField {
689        }
690        impl<'de> serde::Deserialize<'de> for GeneratedField {
691            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
692            where
693                D: serde::Deserializer<'de>,
694            {
695                struct GeneratedVisitor;
696
697                impl serde::de::Visitor<'_> for GeneratedVisitor {
698                    type Value = GeneratedField;
699
700                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
701                        write!(formatter, "expected one of: {:?}", &FIELDS)
702                    }
703
704                    #[allow(unused_variables)]
705                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
706                    where
707                        E: serde::de::Error,
708                    {
709                            Err(serde::de::Error::unknown_field(value, FIELDS))
710                    }
711                }
712                deserializer.deserialize_identifier(GeneratedVisitor)
713            }
714        }
715        struct GeneratedVisitor;
716        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
717            type Value = GetMetaSnapshotManifestRequest;
718
719            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
720                formatter.write_str("struct backup_service.GetMetaSnapshotManifestRequest")
721            }
722
723            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaSnapshotManifestRequest, V::Error>
724                where
725                    V: serde::de::MapAccess<'de>,
726            {
727                while map_.next_key::<GeneratedField>()?.is_some() {
728                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
729                }
730                Ok(GetMetaSnapshotManifestRequest {
731                })
732            }
733        }
734        deserializer.deserialize_struct("backup_service.GetMetaSnapshotManifestRequest", FIELDS, GeneratedVisitor)
735    }
736}
737impl serde::Serialize for GetMetaSnapshotManifestResponse {
738    #[allow(deprecated)]
739    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
740    where
741        S: serde::Serializer,
742    {
743        use serde::ser::SerializeStruct;
744        let mut len = 0;
745        if self.manifest.is_some() {
746            len += 1;
747        }
748        let mut struct_ser = serializer.serialize_struct("backup_service.GetMetaSnapshotManifestResponse", len)?;
749        if let Some(v) = self.manifest.as_ref() {
750            struct_ser.serialize_field("manifest", v)?;
751        }
752        struct_ser.end()
753    }
754}
755impl<'de> serde::Deserialize<'de> for GetMetaSnapshotManifestResponse {
756    #[allow(deprecated)]
757    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
758    where
759        D: serde::Deserializer<'de>,
760    {
761        const FIELDS: &[&str] = &[
762            "manifest",
763        ];
764
765        #[allow(clippy::enum_variant_names)]
766        enum GeneratedField {
767            Manifest,
768        }
769        impl<'de> serde::Deserialize<'de> for GeneratedField {
770            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
771            where
772                D: serde::Deserializer<'de>,
773            {
774                struct GeneratedVisitor;
775
776                impl serde::de::Visitor<'_> for GeneratedVisitor {
777                    type Value = GeneratedField;
778
779                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
780                        write!(formatter, "expected one of: {:?}", &FIELDS)
781                    }
782
783                    #[allow(unused_variables)]
784                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
785                    where
786                        E: serde::de::Error,
787                    {
788                        match value {
789                            "manifest" => Ok(GeneratedField::Manifest),
790                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
791                        }
792                    }
793                }
794                deserializer.deserialize_identifier(GeneratedVisitor)
795            }
796        }
797        struct GeneratedVisitor;
798        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
799            type Value = GetMetaSnapshotManifestResponse;
800
801            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
802                formatter.write_str("struct backup_service.GetMetaSnapshotManifestResponse")
803            }
804
805            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaSnapshotManifestResponse, V::Error>
806                where
807                    V: serde::de::MapAccess<'de>,
808            {
809                let mut manifest__ = None;
810                while let Some(k) = map_.next_key()? {
811                    match k {
812                        GeneratedField::Manifest => {
813                            if manifest__.is_some() {
814                                return Err(serde::de::Error::duplicate_field("manifest"));
815                            }
816                            manifest__ = map_.next_value()?;
817                        }
818                    }
819                }
820                Ok(GetMetaSnapshotManifestResponse {
821                    manifest: manifest__,
822                })
823            }
824        }
825        deserializer.deserialize_struct("backup_service.GetMetaSnapshotManifestResponse", FIELDS, GeneratedVisitor)
826    }
827}
828impl serde::Serialize for MetaBackupManifestId {
829    #[allow(deprecated)]
830    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
831    where
832        S: serde::Serializer,
833    {
834        use serde::ser::SerializeStruct;
835        let mut len = 0;
836        if self.id != 0 {
837            len += 1;
838        }
839        let mut struct_ser = serializer.serialize_struct("backup_service.MetaBackupManifestId", len)?;
840        if self.id != 0 {
841            #[allow(clippy::needless_borrow)]
842            #[allow(clippy::needless_borrows_for_generic_args)]
843            struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
844        }
845        struct_ser.end()
846    }
847}
848impl<'de> serde::Deserialize<'de> for MetaBackupManifestId {
849    #[allow(deprecated)]
850    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
851    where
852        D: serde::Deserializer<'de>,
853    {
854        const FIELDS: &[&str] = &[
855            "id",
856        ];
857
858        #[allow(clippy::enum_variant_names)]
859        enum GeneratedField {
860            Id,
861        }
862        impl<'de> serde::Deserialize<'de> for GeneratedField {
863            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
864            where
865                D: serde::Deserializer<'de>,
866            {
867                struct GeneratedVisitor;
868
869                impl serde::de::Visitor<'_> for GeneratedVisitor {
870                    type Value = GeneratedField;
871
872                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
873                        write!(formatter, "expected one of: {:?}", &FIELDS)
874                    }
875
876                    #[allow(unused_variables)]
877                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
878                    where
879                        E: serde::de::Error,
880                    {
881                        match value {
882                            "id" => Ok(GeneratedField::Id),
883                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
884                        }
885                    }
886                }
887                deserializer.deserialize_identifier(GeneratedVisitor)
888            }
889        }
890        struct GeneratedVisitor;
891        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
892            type Value = MetaBackupManifestId;
893
894            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
895                formatter.write_str("struct backup_service.MetaBackupManifestId")
896            }
897
898            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaBackupManifestId, V::Error>
899                where
900                    V: serde::de::MapAccess<'de>,
901            {
902                let mut id__ = None;
903                while let Some(k) = map_.next_key()? {
904                    match k {
905                        GeneratedField::Id => {
906                            if id__.is_some() {
907                                return Err(serde::de::Error::duplicate_field("id"));
908                            }
909                            id__ = 
910                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
911                            ;
912                        }
913                    }
914                }
915                Ok(MetaBackupManifestId {
916                    id: id__.unwrap_or_default(),
917                })
918            }
919        }
920        deserializer.deserialize_struct("backup_service.MetaBackupManifestId", FIELDS, GeneratedVisitor)
921    }
922}
923impl serde::Serialize for MetaSnapshotManifest {
924    #[allow(deprecated)]
925    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
926    where
927        S: serde::Serializer,
928    {
929        use serde::ser::SerializeStruct;
930        let mut len = 0;
931        if self.manifest_id != 0 {
932            len += 1;
933        }
934        if !self.snapshot_metadata.is_empty() {
935            len += 1;
936        }
937        let mut struct_ser = serializer.serialize_struct("backup_service.MetaSnapshotManifest", len)?;
938        if self.manifest_id != 0 {
939            #[allow(clippy::needless_borrow)]
940            #[allow(clippy::needless_borrows_for_generic_args)]
941            struct_ser.serialize_field("manifestId", ToString::to_string(&self.manifest_id).as_str())?;
942        }
943        if !self.snapshot_metadata.is_empty() {
944            struct_ser.serialize_field("snapshotMetadata", &self.snapshot_metadata)?;
945        }
946        struct_ser.end()
947    }
948}
949impl<'de> serde::Deserialize<'de> for MetaSnapshotManifest {
950    #[allow(deprecated)]
951    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
952    where
953        D: serde::Deserializer<'de>,
954    {
955        const FIELDS: &[&str] = &[
956            "manifest_id",
957            "manifestId",
958            "snapshot_metadata",
959            "snapshotMetadata",
960        ];
961
962        #[allow(clippy::enum_variant_names)]
963        enum GeneratedField {
964            ManifestId,
965            SnapshotMetadata,
966        }
967        impl<'de> serde::Deserialize<'de> for GeneratedField {
968            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
969            where
970                D: serde::Deserializer<'de>,
971            {
972                struct GeneratedVisitor;
973
974                impl serde::de::Visitor<'_> for GeneratedVisitor {
975                    type Value = GeneratedField;
976
977                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
978                        write!(formatter, "expected one of: {:?}", &FIELDS)
979                    }
980
981                    #[allow(unused_variables)]
982                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
983                    where
984                        E: serde::de::Error,
985                    {
986                        match value {
987                            "manifestId" | "manifest_id" => Ok(GeneratedField::ManifestId),
988                            "snapshotMetadata" | "snapshot_metadata" => Ok(GeneratedField::SnapshotMetadata),
989                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
990                        }
991                    }
992                }
993                deserializer.deserialize_identifier(GeneratedVisitor)
994            }
995        }
996        struct GeneratedVisitor;
997        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
998            type Value = MetaSnapshotManifest;
999
1000            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1001                formatter.write_str("struct backup_service.MetaSnapshotManifest")
1002            }
1003
1004            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshotManifest, V::Error>
1005                where
1006                    V: serde::de::MapAccess<'de>,
1007            {
1008                let mut manifest_id__ = None;
1009                let mut snapshot_metadata__ = None;
1010                while let Some(k) = map_.next_key()? {
1011                    match k {
1012                        GeneratedField::ManifestId => {
1013                            if manifest_id__.is_some() {
1014                                return Err(serde::de::Error::duplicate_field("manifestId"));
1015                            }
1016                            manifest_id__ = 
1017                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1018                            ;
1019                        }
1020                        GeneratedField::SnapshotMetadata => {
1021                            if snapshot_metadata__.is_some() {
1022                                return Err(serde::de::Error::duplicate_field("snapshotMetadata"));
1023                            }
1024                            snapshot_metadata__ = Some(map_.next_value()?);
1025                        }
1026                    }
1027                }
1028                Ok(MetaSnapshotManifest {
1029                    manifest_id: manifest_id__.unwrap_or_default(),
1030                    snapshot_metadata: snapshot_metadata__.unwrap_or_default(),
1031                })
1032            }
1033        }
1034        deserializer.deserialize_struct("backup_service.MetaSnapshotManifest", FIELDS, GeneratedVisitor)
1035    }
1036}
1037impl serde::Serialize for MetaSnapshotMetadata {
1038    #[allow(deprecated)]
1039    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1040    where
1041        S: serde::Serializer,
1042    {
1043        use serde::ser::SerializeStruct;
1044        let mut len = 0;
1045        if self.id != 0 {
1046            len += 1;
1047        }
1048        if self.hummock_version_id != 0 {
1049            len += 1;
1050        }
1051        if self.format_version.is_some() {
1052            len += 1;
1053        }
1054        if self.remarks.is_some() {
1055            len += 1;
1056        }
1057        if self.rw_version.is_some() {
1058            len += 1;
1059        }
1060        if !self.state_table_info.is_empty() {
1061            len += 1;
1062        }
1063        let mut struct_ser = serializer.serialize_struct("backup_service.MetaSnapshotMetadata", len)?;
1064        if self.id != 0 {
1065            #[allow(clippy::needless_borrow)]
1066            #[allow(clippy::needless_borrows_for_generic_args)]
1067            struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
1068        }
1069        if self.hummock_version_id != 0 {
1070            #[allow(clippy::needless_borrow)]
1071            #[allow(clippy::needless_borrows_for_generic_args)]
1072            struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
1073        }
1074        if let Some(v) = self.format_version.as_ref() {
1075            struct_ser.serialize_field("formatVersion", v)?;
1076        }
1077        if let Some(v) = self.remarks.as_ref() {
1078            struct_ser.serialize_field("remarks", v)?;
1079        }
1080        if let Some(v) = self.rw_version.as_ref() {
1081            struct_ser.serialize_field("rwVersion", v)?;
1082        }
1083        if !self.state_table_info.is_empty() {
1084            struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
1085        }
1086        struct_ser.end()
1087    }
1088}
1089impl<'de> serde::Deserialize<'de> for MetaSnapshotMetadata {
1090    #[allow(deprecated)]
1091    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1092    where
1093        D: serde::Deserializer<'de>,
1094    {
1095        const FIELDS: &[&str] = &[
1096            "id",
1097            "hummock_version_id",
1098            "hummockVersionId",
1099            "format_version",
1100            "formatVersion",
1101            "remarks",
1102            "rw_version",
1103            "rwVersion",
1104            "state_table_info",
1105            "stateTableInfo",
1106        ];
1107
1108        #[allow(clippy::enum_variant_names)]
1109        enum GeneratedField {
1110            Id,
1111            HummockVersionId,
1112            FormatVersion,
1113            Remarks,
1114            RwVersion,
1115            StateTableInfo,
1116        }
1117        impl<'de> serde::Deserialize<'de> for GeneratedField {
1118            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1119            where
1120                D: serde::Deserializer<'de>,
1121            {
1122                struct GeneratedVisitor;
1123
1124                impl serde::de::Visitor<'_> for GeneratedVisitor {
1125                    type Value = GeneratedField;
1126
1127                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1128                        write!(formatter, "expected one of: {:?}", &FIELDS)
1129                    }
1130
1131                    #[allow(unused_variables)]
1132                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1133                    where
1134                        E: serde::de::Error,
1135                    {
1136                        match value {
1137                            "id" => Ok(GeneratedField::Id),
1138                            "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
1139                            "formatVersion" | "format_version" => Ok(GeneratedField::FormatVersion),
1140                            "remarks" => Ok(GeneratedField::Remarks),
1141                            "rwVersion" | "rw_version" => Ok(GeneratedField::RwVersion),
1142                            "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
1143                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1144                        }
1145                    }
1146                }
1147                deserializer.deserialize_identifier(GeneratedVisitor)
1148            }
1149        }
1150        struct GeneratedVisitor;
1151        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1152            type Value = MetaSnapshotMetadata;
1153
1154            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1155                formatter.write_str("struct backup_service.MetaSnapshotMetadata")
1156            }
1157
1158            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshotMetadata, V::Error>
1159                where
1160                    V: serde::de::MapAccess<'de>,
1161            {
1162                let mut id__ = None;
1163                let mut hummock_version_id__ = None;
1164                let mut format_version__ = None;
1165                let mut remarks__ = None;
1166                let mut rw_version__ = None;
1167                let mut state_table_info__ = None;
1168                while let Some(k) = map_.next_key()? {
1169                    match k {
1170                        GeneratedField::Id => {
1171                            if id__.is_some() {
1172                                return Err(serde::de::Error::duplicate_field("id"));
1173                            }
1174                            id__ = 
1175                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1176                            ;
1177                        }
1178                        GeneratedField::HummockVersionId => {
1179                            if hummock_version_id__.is_some() {
1180                                return Err(serde::de::Error::duplicate_field("hummockVersionId"));
1181                            }
1182                            hummock_version_id__ = 
1183                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1184                            ;
1185                        }
1186                        GeneratedField::FormatVersion => {
1187                            if format_version__.is_some() {
1188                                return Err(serde::de::Error::duplicate_field("formatVersion"));
1189                            }
1190                            format_version__ = 
1191                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1192                            ;
1193                        }
1194                        GeneratedField::Remarks => {
1195                            if remarks__.is_some() {
1196                                return Err(serde::de::Error::duplicate_field("remarks"));
1197                            }
1198                            remarks__ = map_.next_value()?;
1199                        }
1200                        GeneratedField::RwVersion => {
1201                            if rw_version__.is_some() {
1202                                return Err(serde::de::Error::duplicate_field("rwVersion"));
1203                            }
1204                            rw_version__ = map_.next_value()?;
1205                        }
1206                        GeneratedField::StateTableInfo => {
1207                            if state_table_info__.is_some() {
1208                                return Err(serde::de::Error::duplicate_field("stateTableInfo"));
1209                            }
1210                            state_table_info__ = Some(
1211                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1212                                    .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1213                            );
1214                        }
1215                    }
1216                }
1217                Ok(MetaSnapshotMetadata {
1218                    id: id__.unwrap_or_default(),
1219                    hummock_version_id: hummock_version_id__.unwrap_or_default(),
1220                    format_version: format_version__,
1221                    remarks: remarks__,
1222                    rw_version: rw_version__,
1223                    state_table_info: state_table_info__.unwrap_or_default(),
1224                })
1225            }
1226        }
1227        deserializer.deserialize_struct("backup_service.MetaSnapshotMetadata", FIELDS, GeneratedVisitor)
1228    }
1229}
risingwave_pb/backup_service.serde.rs

risingwave_pb/
backup_service.serde.rs
