risingwave_pb/
secret.serde.rs

1#![allow(clippy::useless_conversion)]
2use crate::secret::*;
3impl serde::Serialize for Secret {
4    #[allow(deprecated)]
5    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6    where
7        S: serde::Serializer,
8    {
9        use serde::ser::SerializeStruct;
10        let mut len = 0;
11        if self.secret_backend.is_some() {
12            len += 1;
13        }
14        let mut struct_ser = serializer.serialize_struct("secret.Secret", len)?;
15        if let Some(v) = self.secret_backend.as_ref() {
16            match v {
17                secret::SecretBackend::Meta(v) => {
18                    struct_ser.serialize_field("meta", v)?;
19                }
20                secret::SecretBackend::HashicorpVault(v) => {
21                    struct_ser.serialize_field("hashicorpVault", v)?;
22                }
23            }
24        }
25        struct_ser.end()
26    }
27}
28impl<'de> serde::Deserialize<'de> for Secret {
29    #[allow(deprecated)]
30    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
31    where
32        D: serde::Deserializer<'de>,
33    {
34        const FIELDS: &[&str] = &[
35            "meta",
36            "hashicorp_vault",
37            "hashicorpVault",
38        ];
39
40        #[allow(clippy::enum_variant_names)]
41        enum GeneratedField {
42            Meta,
43            HashicorpVault,
44        }
45        impl<'de> serde::Deserialize<'de> for GeneratedField {
46            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
47            where
48                D: serde::Deserializer<'de>,
49            {
50                struct GeneratedVisitor;
51
52                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
53                    type Value = GeneratedField;
54
55                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56                        write!(formatter, "expected one of: {:?}", &FIELDS)
57                    }
58
59                    #[allow(unused_variables)]
60                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
61                    where
62                        E: serde::de::Error,
63                    {
64                        match value {
65                            "meta" => Ok(GeneratedField::Meta),
66                            "hashicorpVault" | "hashicorp_vault" => Ok(GeneratedField::HashicorpVault),
67                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
68                        }
69                    }
70                }
71                deserializer.deserialize_identifier(GeneratedVisitor)
72            }
73        }
74        struct GeneratedVisitor;
75        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
76            type Value = Secret;
77
78            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
79                formatter.write_str("struct secret.Secret")
80            }
81
82            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Secret, V::Error>
83                where
84                    V: serde::de::MapAccess<'de>,
85            {
86                let mut secret_backend__ = None;
87                while let Some(k) = map_.next_key()? {
88                    match k {
89                        GeneratedField::Meta => {
90                            if secret_backend__.is_some() {
91                                return Err(serde::de::Error::duplicate_field("meta"));
92                            }
93                            secret_backend__ = map_.next_value::<::std::option::Option<_>>()?.map(secret::SecretBackend::Meta)
94;
95                        }
96                        GeneratedField::HashicorpVault => {
97                            if secret_backend__.is_some() {
98                                return Err(serde::de::Error::duplicate_field("hashicorpVault"));
99                            }
100                            secret_backend__ = map_.next_value::<::std::option::Option<_>>()?.map(secret::SecretBackend::HashicorpVault)
101;
102                        }
103                    }
104                }
105                Ok(Secret {
106                    secret_backend: secret_backend__,
107                })
108            }
109        }
110        deserializer.deserialize_struct("secret.Secret", FIELDS, GeneratedVisitor)
111    }
112}
113impl serde::Serialize for SecretHashicorpVaultBackend {
114    #[allow(deprecated)]
115    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
116    where
117        S: serde::Serializer,
118    {
119        use serde::ser::SerializeStruct;
120        let mut len = 0;
121        if !self.addr.is_empty() {
122            len += 1;
123        }
124        if !self.path.is_empty() {
125            len += 1;
126        }
127        if !self.field.is_empty() {
128            len += 1;
129        }
130        if self.tls_skip_verify {
131            len += 1;
132        }
133        if self.auth.is_some() {
134            len += 1;
135        }
136        let mut struct_ser = serializer.serialize_struct("secret.SecretHashicorpVaultBackend", len)?;
137        if !self.addr.is_empty() {
138            struct_ser.serialize_field("addr", &self.addr)?;
139        }
140        if !self.path.is_empty() {
141            struct_ser.serialize_field("path", &self.path)?;
142        }
143        if !self.field.is_empty() {
144            struct_ser.serialize_field("field", &self.field)?;
145        }
146        if self.tls_skip_verify {
147            struct_ser.serialize_field("tlsSkipVerify", &self.tls_skip_verify)?;
148        }
149        if let Some(v) = self.auth.as_ref() {
150            match v {
151                secret_hashicorp_vault_backend::Auth::TokenAuth(v) => {
152                    struct_ser.serialize_field("tokenAuth", v)?;
153                }
154                secret_hashicorp_vault_backend::Auth::ApproleAuth(v) => {
155                    struct_ser.serialize_field("approleAuth", v)?;
156                }
157            }
158        }
159        struct_ser.end()
160    }
161}
162impl<'de> serde::Deserialize<'de> for SecretHashicorpVaultBackend {
163    #[allow(deprecated)]
164    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
165    where
166        D: serde::Deserializer<'de>,
167    {
168        const FIELDS: &[&str] = &[
169            "addr",
170            "path",
171            "field",
172            "tls_skip_verify",
173            "tlsSkipVerify",
174            "token_auth",
175            "tokenAuth",
176            "approle_auth",
177            "approleAuth",
178        ];
179
180        #[allow(clippy::enum_variant_names)]
181        enum GeneratedField {
182            Addr,
183            Path,
184            Field,
185            TlsSkipVerify,
186            TokenAuth,
187            ApproleAuth,
188        }
189        impl<'de> serde::Deserialize<'de> for GeneratedField {
190            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
191            where
192                D: serde::Deserializer<'de>,
193            {
194                struct GeneratedVisitor;
195
196                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
197                    type Value = GeneratedField;
198
199                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
200                        write!(formatter, "expected one of: {:?}", &FIELDS)
201                    }
202
203                    #[allow(unused_variables)]
204                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
205                    where
206                        E: serde::de::Error,
207                    {
208                        match value {
209                            "addr" => Ok(GeneratedField::Addr),
210                            "path" => Ok(GeneratedField::Path),
211                            "field" => Ok(GeneratedField::Field),
212                            "tlsSkipVerify" | "tls_skip_verify" => Ok(GeneratedField::TlsSkipVerify),
213                            "tokenAuth" | "token_auth" => Ok(GeneratedField::TokenAuth),
214                            "approleAuth" | "approle_auth" => Ok(GeneratedField::ApproleAuth),
215                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
216                        }
217                    }
218                }
219                deserializer.deserialize_identifier(GeneratedVisitor)
220            }
221        }
222        struct GeneratedVisitor;
223        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
224            type Value = SecretHashicorpVaultBackend;
225
226            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
227                formatter.write_str("struct secret.SecretHashicorpVaultBackend")
228            }
229
230            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SecretHashicorpVaultBackend, V::Error>
231                where
232                    V: serde::de::MapAccess<'de>,
233            {
234                let mut addr__ = None;
235                let mut path__ = None;
236                let mut field__ = None;
237                let mut tls_skip_verify__ = None;
238                let mut auth__ = None;
239                while let Some(k) = map_.next_key()? {
240                    match k {
241                        GeneratedField::Addr => {
242                            if addr__.is_some() {
243                                return Err(serde::de::Error::duplicate_field("addr"));
244                            }
245                            addr__ = Some(map_.next_value()?);
246                        }
247                        GeneratedField::Path => {
248                            if path__.is_some() {
249                                return Err(serde::de::Error::duplicate_field("path"));
250                            }
251                            path__ = Some(map_.next_value()?);
252                        }
253                        GeneratedField::Field => {
254                            if field__.is_some() {
255                                return Err(serde::de::Error::duplicate_field("field"));
256                            }
257                            field__ = Some(map_.next_value()?);
258                        }
259                        GeneratedField::TlsSkipVerify => {
260                            if tls_skip_verify__.is_some() {
261                                return Err(serde::de::Error::duplicate_field("tlsSkipVerify"));
262                            }
263                            tls_skip_verify__ = Some(map_.next_value()?);
264                        }
265                        GeneratedField::TokenAuth => {
266                            if auth__.is_some() {
267                                return Err(serde::de::Error::duplicate_field("tokenAuth"));
268                            }
269                            auth__ = map_.next_value::<::std::option::Option<_>>()?.map(secret_hashicorp_vault_backend::Auth::TokenAuth)
270;
271                        }
272                        GeneratedField::ApproleAuth => {
273                            if auth__.is_some() {
274                                return Err(serde::de::Error::duplicate_field("approleAuth"));
275                            }
276                            auth__ = map_.next_value::<::std::option::Option<_>>()?.map(secret_hashicorp_vault_backend::Auth::ApproleAuth)
277;
278                        }
279                    }
280                }
281                Ok(SecretHashicorpVaultBackend {
282                    addr: addr__.unwrap_or_default(),
283                    path: path__.unwrap_or_default(),
284                    field: field__.unwrap_or_default(),
285                    tls_skip_verify: tls_skip_verify__.unwrap_or_default(),
286                    auth: auth__,
287                })
288            }
289        }
290        deserializer.deserialize_struct("secret.SecretHashicorpVaultBackend", FIELDS, GeneratedVisitor)
291    }
292}
293impl serde::Serialize for SecretMetaBackend {
294    #[allow(deprecated)]
295    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
296    where
297        S: serde::Serializer,
298    {
299        use serde::ser::SerializeStruct;
300        let mut len = 0;
301        if !self.value.is_empty() {
302            len += 1;
303        }
304        let mut struct_ser = serializer.serialize_struct("secret.SecretMetaBackend", len)?;
305        if !self.value.is_empty() {
306            #[allow(clippy::needless_borrow)]
307            #[allow(clippy::needless_borrows_for_generic_args)]
308            struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
309        }
310        struct_ser.end()
311    }
312}
313impl<'de> serde::Deserialize<'de> for SecretMetaBackend {
314    #[allow(deprecated)]
315    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
316    where
317        D: serde::Deserializer<'de>,
318    {
319        const FIELDS: &[&str] = &[
320            "value",
321        ];
322
323        #[allow(clippy::enum_variant_names)]
324        enum GeneratedField {
325            Value,
326        }
327        impl<'de> serde::Deserialize<'de> for GeneratedField {
328            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
329            where
330                D: serde::Deserializer<'de>,
331            {
332                struct GeneratedVisitor;
333
334                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
335                    type Value = GeneratedField;
336
337                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
338                        write!(formatter, "expected one of: {:?}", &FIELDS)
339                    }
340
341                    #[allow(unused_variables)]
342                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
343                    where
344                        E: serde::de::Error,
345                    {
346                        match value {
347                            "value" => Ok(GeneratedField::Value),
348                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
349                        }
350                    }
351                }
352                deserializer.deserialize_identifier(GeneratedVisitor)
353            }
354        }
355        struct GeneratedVisitor;
356        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
357            type Value = SecretMetaBackend;
358
359            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
360                formatter.write_str("struct secret.SecretMetaBackend")
361            }
362
363            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SecretMetaBackend, V::Error>
364                where
365                    V: serde::de::MapAccess<'de>,
366            {
367                let mut value__ = None;
368                while let Some(k) = map_.next_key()? {
369                    match k {
370                        GeneratedField::Value => {
371                            if value__.is_some() {
372                                return Err(serde::de::Error::duplicate_field("value"));
373                            }
374                            value__ = 
375                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
376                            ;
377                        }
378                    }
379                }
380                Ok(SecretMetaBackend {
381                    value: value__.unwrap_or_default(),
382                })
383            }
384        }
385        deserializer.deserialize_struct("secret.SecretMetaBackend", FIELDS, GeneratedVisitor)
386    }
387}
388impl serde::Serialize for SecretRef {
389    #[allow(deprecated)]
390    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
391    where
392        S: serde::Serializer,
393    {
394        use serde::ser::SerializeStruct;
395        let mut len = 0;
396        if self.secret_id != 0 {
397            len += 1;
398        }
399        if self.ref_as != 0 {
400            len += 1;
401        }
402        let mut struct_ser = serializer.serialize_struct("secret.SecretRef", len)?;
403        if self.secret_id != 0 {
404            struct_ser.serialize_field("secretId", &self.secret_id)?;
405        }
406        if self.ref_as != 0 {
407            let v = secret_ref::RefAsType::try_from(self.ref_as)
408                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.ref_as)))?;
409            struct_ser.serialize_field("refAs", &v)?;
410        }
411        struct_ser.end()
412    }
413}
414impl<'de> serde::Deserialize<'de> for SecretRef {
415    #[allow(deprecated)]
416    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
417    where
418        D: serde::Deserializer<'de>,
419    {
420        const FIELDS: &[&str] = &[
421            "secret_id",
422            "secretId",
423            "ref_as",
424            "refAs",
425        ];
426
427        #[allow(clippy::enum_variant_names)]
428        enum GeneratedField {
429            SecretId,
430            RefAs,
431        }
432        impl<'de> serde::Deserialize<'de> for GeneratedField {
433            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
434            where
435                D: serde::Deserializer<'de>,
436            {
437                struct GeneratedVisitor;
438
439                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
440                    type Value = GeneratedField;
441
442                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
443                        write!(formatter, "expected one of: {:?}", &FIELDS)
444                    }
445
446                    #[allow(unused_variables)]
447                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
448                    where
449                        E: serde::de::Error,
450                    {
451                        match value {
452                            "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
453                            "refAs" | "ref_as" => Ok(GeneratedField::RefAs),
454                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
455                        }
456                    }
457                }
458                deserializer.deserialize_identifier(GeneratedVisitor)
459            }
460        }
461        struct GeneratedVisitor;
462        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
463            type Value = SecretRef;
464
465            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
466                formatter.write_str("struct secret.SecretRef")
467            }
468
469            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SecretRef, V::Error>
470                where
471                    V: serde::de::MapAccess<'de>,
472            {
473                let mut secret_id__ = None;
474                let mut ref_as__ = None;
475                while let Some(k) = map_.next_key()? {
476                    match k {
477                        GeneratedField::SecretId => {
478                            if secret_id__.is_some() {
479                                return Err(serde::de::Error::duplicate_field("secretId"));
480                            }
481                            secret_id__ = 
482                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
483                            ;
484                        }
485                        GeneratedField::RefAs => {
486                            if ref_as__.is_some() {
487                                return Err(serde::de::Error::duplicate_field("refAs"));
488                            }
489                            ref_as__ = Some(map_.next_value::<secret_ref::RefAsType>()? as i32);
490                        }
491                    }
492                }
493                Ok(SecretRef {
494                    secret_id: secret_id__.unwrap_or_default(),
495                    ref_as: ref_as__.unwrap_or_default(),
496                })
497            }
498        }
499        deserializer.deserialize_struct("secret.SecretRef", FIELDS, GeneratedVisitor)
500    }
501}
502impl serde::Serialize for secret_ref::RefAsType {
503    #[allow(deprecated)]
504    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
505    where
506        S: serde::Serializer,
507    {
508        let variant = match self {
509            Self::Unspecified => "UNSPECIFIED",
510            Self::Text => "TEXT",
511            Self::File => "FILE",
512        };
513        serializer.serialize_str(variant)
514    }
515}
516impl<'de> serde::Deserialize<'de> for secret_ref::RefAsType {
517    #[allow(deprecated)]
518    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
519    where
520        D: serde::Deserializer<'de>,
521    {
522        const FIELDS: &[&str] = &[
523            "UNSPECIFIED",
524            "TEXT",
525            "FILE",
526        ];
527
528        struct GeneratedVisitor;
529
530        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
531            type Value = secret_ref::RefAsType;
532
533            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
534                write!(formatter, "expected one of: {:?}", &FIELDS)
535            }
536
537            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
538            where
539                E: serde::de::Error,
540            {
541                i32::try_from(v)
542                    .ok()
543                    .and_then(|x| x.try_into().ok())
544                    .ok_or_else(|| {
545                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
546                    })
547            }
548
549            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
550            where
551                E: serde::de::Error,
552            {
553                i32::try_from(v)
554                    .ok()
555                    .and_then(|x| x.try_into().ok())
556                    .ok_or_else(|| {
557                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
558                    })
559            }
560
561            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
562            where
563                E: serde::de::Error,
564            {
565                match value {
566                    "UNSPECIFIED" => Ok(secret_ref::RefAsType::Unspecified),
567                    "TEXT" => Ok(secret_ref::RefAsType::Text),
568                    "FILE" => Ok(secret_ref::RefAsType::File),
569                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
570                }
571            }
572        }
573        deserializer.deserialize_any(GeneratedVisitor)
574    }
575}
576impl serde::Serialize for VaultAppRoleAuth {
577    #[allow(deprecated)]
578    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
579    where
580        S: serde::Serializer,
581    {
582        use serde::ser::SerializeStruct;
583        let mut len = 0;
584        if !self.role_id.is_empty() {
585            len += 1;
586        }
587        if !self.secret_id.is_empty() {
588            len += 1;
589        }
590        let mut struct_ser = serializer.serialize_struct("secret.VaultAppRoleAuth", len)?;
591        if !self.role_id.is_empty() {
592            struct_ser.serialize_field("roleId", &self.role_id)?;
593        }
594        if !self.secret_id.is_empty() {
595            struct_ser.serialize_field("secretId", &self.secret_id)?;
596        }
597        struct_ser.end()
598    }
599}
600impl<'de> serde::Deserialize<'de> for VaultAppRoleAuth {
601    #[allow(deprecated)]
602    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
603    where
604        D: serde::Deserializer<'de>,
605    {
606        const FIELDS: &[&str] = &[
607            "role_id",
608            "roleId",
609            "secret_id",
610            "secretId",
611        ];
612
613        #[allow(clippy::enum_variant_names)]
614        enum GeneratedField {
615            RoleId,
616            SecretId,
617        }
618        impl<'de> serde::Deserialize<'de> for GeneratedField {
619            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
620            where
621                D: serde::Deserializer<'de>,
622            {
623                struct GeneratedVisitor;
624
625                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
626                    type Value = GeneratedField;
627
628                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
629                        write!(formatter, "expected one of: {:?}", &FIELDS)
630                    }
631
632                    #[allow(unused_variables)]
633                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
634                    where
635                        E: serde::de::Error,
636                    {
637                        match value {
638                            "roleId" | "role_id" => Ok(GeneratedField::RoleId),
639                            "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
640                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
641                        }
642                    }
643                }
644                deserializer.deserialize_identifier(GeneratedVisitor)
645            }
646        }
647        struct GeneratedVisitor;
648        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
649            type Value = VaultAppRoleAuth;
650
651            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
652                formatter.write_str("struct secret.VaultAppRoleAuth")
653            }
654
655            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VaultAppRoleAuth, V::Error>
656                where
657                    V: serde::de::MapAccess<'de>,
658            {
659                let mut role_id__ = None;
660                let mut secret_id__ = None;
661                while let Some(k) = map_.next_key()? {
662                    match k {
663                        GeneratedField::RoleId => {
664                            if role_id__.is_some() {
665                                return Err(serde::de::Error::duplicate_field("roleId"));
666                            }
667                            role_id__ = Some(map_.next_value()?);
668                        }
669                        GeneratedField::SecretId => {
670                            if secret_id__.is_some() {
671                                return Err(serde::de::Error::duplicate_field("secretId"));
672                            }
673                            secret_id__ = Some(map_.next_value()?);
674                        }
675                    }
676                }
677                Ok(VaultAppRoleAuth {
678                    role_id: role_id__.unwrap_or_default(),
679                    secret_id: secret_id__.unwrap_or_default(),
680                })
681            }
682        }
683        deserializer.deserialize_struct("secret.VaultAppRoleAuth", FIELDS, GeneratedVisitor)
684    }
685}
686impl serde::Serialize for VaultTokenAuth {
687    #[allow(deprecated)]
688    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
689    where
690        S: serde::Serializer,
691    {
692        use serde::ser::SerializeStruct;
693        let mut len = 0;
694        if !self.token.is_empty() {
695            len += 1;
696        }
697        let mut struct_ser = serializer.serialize_struct("secret.VaultTokenAuth", len)?;
698        if !self.token.is_empty() {
699            struct_ser.serialize_field("token", &self.token)?;
700        }
701        struct_ser.end()
702    }
703}
704impl<'de> serde::Deserialize<'de> for VaultTokenAuth {
705    #[allow(deprecated)]
706    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
707    where
708        D: serde::Deserializer<'de>,
709    {
710        const FIELDS: &[&str] = &[
711            "token",
712        ];
713
714        #[allow(clippy::enum_variant_names)]
715        enum GeneratedField {
716            Token,
717        }
718        impl<'de> serde::Deserialize<'de> for GeneratedField {
719            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
720            where
721                D: serde::Deserializer<'de>,
722            {
723                struct GeneratedVisitor;
724
725                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
726                    type Value = GeneratedField;
727
728                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
729                        write!(formatter, "expected one of: {:?}", &FIELDS)
730                    }
731
732                    #[allow(unused_variables)]
733                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
734                    where
735                        E: serde::de::Error,
736                    {
737                        match value {
738                            "token" => Ok(GeneratedField::Token),
739                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
740                        }
741                    }
742                }
743                deserializer.deserialize_identifier(GeneratedVisitor)
744            }
745        }
746        struct GeneratedVisitor;
747        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
748            type Value = VaultTokenAuth;
749
750            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
751                formatter.write_str("struct secret.VaultTokenAuth")
752            }
753
754            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VaultTokenAuth, V::Error>
755                where
756                    V: serde::de::MapAccess<'de>,
757            {
758                let mut token__ = None;
759                while let Some(k) = map_.next_key()? {
760                    match k {
761                        GeneratedField::Token => {
762                            if token__.is_some() {
763                                return Err(serde::de::Error::duplicate_field("token"));
764                            }
765                            token__ = Some(map_.next_value()?);
766                        }
767                    }
768                }
769                Ok(VaultTokenAuth {
770                    token: token__.unwrap_or_default(),
771                })
772            }
773        }
774        deserializer.deserialize_struct("secret.VaultTokenAuth", FIELDS, GeneratedVisitor)
775    }
776}
risingwave_pb/secret.serde.rs

risingwave_pb/
secret.serde.rs
