risingwave_pb/
backup_service.serde.rs

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

risingwave_pb/
backup_service.serde.rs
