risingwave_pb/
serverless_backfill_controller.serde.rs

1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::serverless_backfill_controller::*;
4impl serde::Serialize for ProvisionRequest {
5    #[allow(deprecated)]
6    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7    where
8        S: serde::Serializer,
9    {
10        use serde::ser::SerializeStruct;
11        let len = 0;
12        let struct_ser = serializer.serialize_struct("serverless_backfill_controller.ProvisionRequest", len)?;
13        struct_ser.end()
14    }
15}
16impl<'de> serde::Deserialize<'de> for ProvisionRequest {
17    #[allow(deprecated)]
18    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19    where
20        D: serde::Deserializer<'de>,
21    {
22        const FIELDS: &[&str] = &[
23        ];
24
25        #[allow(clippy::enum_variant_names)]
26        enum GeneratedField {
27        }
28        impl<'de> serde::Deserialize<'de> for GeneratedField {
29            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
30            where
31                D: serde::Deserializer<'de>,
32            {
33                struct GeneratedVisitor;
34
35                impl serde::de::Visitor<'_> for GeneratedVisitor {
36                    type Value = GeneratedField;
37
38                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
39                        write!(formatter, "expected one of: {:?}", &FIELDS)
40                    }
41
42                    #[allow(unused_variables)]
43                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
44                    where
45                        E: serde::de::Error,
46                    {
47                            Err(serde::de::Error::unknown_field(value, FIELDS))
48                    }
49                }
50                deserializer.deserialize_identifier(GeneratedVisitor)
51            }
52        }
53        struct GeneratedVisitor;
54        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
55            type Value = ProvisionRequest;
56
57            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
58                formatter.write_str("struct serverless_backfill_controller.ProvisionRequest")
59            }
60
61            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProvisionRequest, V::Error>
62                where
63                    V: serde::de::MapAccess<'de>,
64            {
65                while map_.next_key::<GeneratedField>()?.is_some() {
66                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
67                }
68                Ok(ProvisionRequest {
69                })
70            }
71        }
72        deserializer.deserialize_struct("serverless_backfill_controller.ProvisionRequest", FIELDS, GeneratedVisitor)
73    }
74}
75impl serde::Serialize for ProvisionResponse {
76    #[allow(deprecated)]
77    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
78    where
79        S: serde::Serializer,
80    {
81        use serde::ser::SerializeStruct;
82        let mut len = 0;
83        if !self.resource_group.is_empty() {
84            len += 1;
85        }
86        let mut struct_ser = serializer.serialize_struct("serverless_backfill_controller.ProvisionResponse", len)?;
87        if !self.resource_group.is_empty() {
88            struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
89        }
90        struct_ser.end()
91    }
92}
93impl<'de> serde::Deserialize<'de> for ProvisionResponse {
94    #[allow(deprecated)]
95    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
96    where
97        D: serde::Deserializer<'de>,
98    {
99        const FIELDS: &[&str] = &[
100            "resource_group",
101            "resourceGroup",
102        ];
103
104        #[allow(clippy::enum_variant_names)]
105        enum GeneratedField {
106            ResourceGroup,
107        }
108        impl<'de> serde::Deserialize<'de> for GeneratedField {
109            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
110            where
111                D: serde::Deserializer<'de>,
112            {
113                struct GeneratedVisitor;
114
115                impl serde::de::Visitor<'_> for GeneratedVisitor {
116                    type Value = GeneratedField;
117
118                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
119                        write!(formatter, "expected one of: {:?}", &FIELDS)
120                    }
121
122                    #[allow(unused_variables)]
123                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
124                    where
125                        E: serde::de::Error,
126                    {
127                        match value {
128                            "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
129                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
130                        }
131                    }
132                }
133                deserializer.deserialize_identifier(GeneratedVisitor)
134            }
135        }
136        struct GeneratedVisitor;
137        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
138            type Value = ProvisionResponse;
139
140            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
141                formatter.write_str("struct serverless_backfill_controller.ProvisionResponse")
142            }
143
144            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProvisionResponse, V::Error>
145                where
146                    V: serde::de::MapAccess<'de>,
147            {
148                let mut resource_group__ = None;
149                while let Some(k) = map_.next_key()? {
150                    match k {
151                        GeneratedField::ResourceGroup => {
152                            if resource_group__.is_some() {
153                                return Err(serde::de::Error::duplicate_field("resourceGroup"));
154                            }
155                            resource_group__ = Some(map_.next_value()?);
156                        }
157                    }
158                }
159                Ok(ProvisionResponse {
160                    resource_group: resource_group__.unwrap_or_default(),
161                })
162            }
163        }
164        deserializer.deserialize_struct("serverless_backfill_controller.ProvisionResponse", FIELDS, GeneratedVisitor)
165    }
166}
risingwave_pb/serverless_backfill_controller.serde.rs

risingwave_pb/
serverless_backfill_controller.serde.rs
