1#![allow(clippy::useless_conversion)]
2use crate::compute::*;
3impl serde::Serialize for ResizeCacheRequest {
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.meta_cache_capacity != 0 {
12 len += 1;
13 }
14 if self.data_cache_capacity != 0 {
15 len += 1;
16 }
17 let mut struct_ser = serializer.serialize_struct("compute.ResizeCacheRequest", len)?;
18 if self.meta_cache_capacity != 0 {
19 #[allow(clippy::needless_borrow)]
20 #[allow(clippy::needless_borrows_for_generic_args)]
21 struct_ser.serialize_field("metaCacheCapacity", ToString::to_string(&self.meta_cache_capacity).as_str())?;
22 }
23 if self.data_cache_capacity != 0 {
24 #[allow(clippy::needless_borrow)]
25 #[allow(clippy::needless_borrows_for_generic_args)]
26 struct_ser.serialize_field("dataCacheCapacity", ToString::to_string(&self.data_cache_capacity).as_str())?;
27 }
28 struct_ser.end()
29 }
30}
31impl<'de> serde::Deserialize<'de> for ResizeCacheRequest {
32 #[allow(deprecated)]
33 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
34 where
35 D: serde::Deserializer<'de>,
36 {
37 const FIELDS: &[&str] = &[
38 "meta_cache_capacity",
39 "metaCacheCapacity",
40 "data_cache_capacity",
41 "dataCacheCapacity",
42 ];
43
44 #[allow(clippy::enum_variant_names)]
45 enum GeneratedField {
46 MetaCacheCapacity,
47 DataCacheCapacity,
48 }
49 impl<'de> serde::Deserialize<'de> for GeneratedField {
50 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
51 where
52 D: serde::Deserializer<'de>,
53 {
54 struct GeneratedVisitor;
55
56 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
57 type Value = GeneratedField;
58
59 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
60 write!(formatter, "expected one of: {:?}", &FIELDS)
61 }
62
63 #[allow(unused_variables)]
64 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
65 where
66 E: serde::de::Error,
67 {
68 match value {
69 "metaCacheCapacity" | "meta_cache_capacity" => Ok(GeneratedField::MetaCacheCapacity),
70 "dataCacheCapacity" | "data_cache_capacity" => Ok(GeneratedField::DataCacheCapacity),
71 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
72 }
73 }
74 }
75 deserializer.deserialize_identifier(GeneratedVisitor)
76 }
77 }
78 struct GeneratedVisitor;
79 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
80 type Value = ResizeCacheRequest;
81
82 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
83 formatter.write_str("struct compute.ResizeCacheRequest")
84 }
85
86 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResizeCacheRequest, V::Error>
87 where
88 V: serde::de::MapAccess<'de>,
89 {
90 let mut meta_cache_capacity__ = None;
91 let mut data_cache_capacity__ = None;
92 while let Some(k) = map_.next_key()? {
93 match k {
94 GeneratedField::MetaCacheCapacity => {
95 if meta_cache_capacity__.is_some() {
96 return Err(serde::de::Error::duplicate_field("metaCacheCapacity"));
97 }
98 meta_cache_capacity__ =
99 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
100 ;
101 }
102 GeneratedField::DataCacheCapacity => {
103 if data_cache_capacity__.is_some() {
104 return Err(serde::de::Error::duplicate_field("dataCacheCapacity"));
105 }
106 data_cache_capacity__ =
107 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
108 ;
109 }
110 }
111 }
112 Ok(ResizeCacheRequest {
113 meta_cache_capacity: meta_cache_capacity__.unwrap_or_default(),
114 data_cache_capacity: data_cache_capacity__.unwrap_or_default(),
115 })
116 }
117 }
118 deserializer.deserialize_struct("compute.ResizeCacheRequest", FIELDS, GeneratedVisitor)
119 }
120}
121impl serde::Serialize for ResizeCacheResponse {
122 #[allow(deprecated)]
123 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
124 where
125 S: serde::Serializer,
126 {
127 use serde::ser::SerializeStruct;
128 let len = 0;
129 let struct_ser = serializer.serialize_struct("compute.ResizeCacheResponse", len)?;
130 struct_ser.end()
131 }
132}
133impl<'de> serde::Deserialize<'de> for ResizeCacheResponse {
134 #[allow(deprecated)]
135 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
136 where
137 D: serde::Deserializer<'de>,
138 {
139 const FIELDS: &[&str] = &[
140 ];
141
142 #[allow(clippy::enum_variant_names)]
143 enum GeneratedField {
144 }
145 impl<'de> serde::Deserialize<'de> for GeneratedField {
146 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
147 where
148 D: serde::Deserializer<'de>,
149 {
150 struct GeneratedVisitor;
151
152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
153 type Value = GeneratedField;
154
155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
156 write!(formatter, "expected one of: {:?}", &FIELDS)
157 }
158
159 #[allow(unused_variables)]
160 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
161 where
162 E: serde::de::Error,
163 {
164 Err(serde::de::Error::unknown_field(value, FIELDS))
165 }
166 }
167 deserializer.deserialize_identifier(GeneratedVisitor)
168 }
169 }
170 struct GeneratedVisitor;
171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
172 type Value = ResizeCacheResponse;
173
174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
175 formatter.write_str("struct compute.ResizeCacheResponse")
176 }
177
178 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResizeCacheResponse, V::Error>
179 where
180 V: serde::de::MapAccess<'de>,
181 {
182 while map_.next_key::<GeneratedField>()?.is_some() {
183 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
184 }
185 Ok(ResizeCacheResponse {
186 })
187 }
188 }
189 deserializer.deserialize_struct("compute.ResizeCacheResponse", FIELDS, GeneratedVisitor)
190 }
191}
192impl serde::Serialize for ShowConfigRequest {
193 #[allow(deprecated)]
194 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
195 where
196 S: serde::Serializer,
197 {
198 use serde::ser::SerializeStruct;
199 let len = 0;
200 let struct_ser = serializer.serialize_struct("compute.ShowConfigRequest", len)?;
201 struct_ser.end()
202 }
203}
204impl<'de> serde::Deserialize<'de> for ShowConfigRequest {
205 #[allow(deprecated)]
206 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
207 where
208 D: serde::Deserializer<'de>,
209 {
210 const FIELDS: &[&str] = &[
211 ];
212
213 #[allow(clippy::enum_variant_names)]
214 enum GeneratedField {
215 }
216 impl<'de> serde::Deserialize<'de> for GeneratedField {
217 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
218 where
219 D: serde::Deserializer<'de>,
220 {
221 struct GeneratedVisitor;
222
223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
224 type Value = GeneratedField;
225
226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
227 write!(formatter, "expected one of: {:?}", &FIELDS)
228 }
229
230 #[allow(unused_variables)]
231 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
232 where
233 E: serde::de::Error,
234 {
235 Err(serde::de::Error::unknown_field(value, FIELDS))
236 }
237 }
238 deserializer.deserialize_identifier(GeneratedVisitor)
239 }
240 }
241 struct GeneratedVisitor;
242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
243 type Value = ShowConfigRequest;
244
245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
246 formatter.write_str("struct compute.ShowConfigRequest")
247 }
248
249 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ShowConfigRequest, V::Error>
250 where
251 V: serde::de::MapAccess<'de>,
252 {
253 while map_.next_key::<GeneratedField>()?.is_some() {
254 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
255 }
256 Ok(ShowConfigRequest {
257 })
258 }
259 }
260 deserializer.deserialize_struct("compute.ShowConfigRequest", FIELDS, GeneratedVisitor)
261 }
262}
263impl serde::Serialize for ShowConfigResponse {
264 #[allow(deprecated)]
265 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
266 where
267 S: serde::Serializer,
268 {
269 use serde::ser::SerializeStruct;
270 let mut len = 0;
271 if !self.batch_config.is_empty() {
272 len += 1;
273 }
274 if !self.stream_config.is_empty() {
275 len += 1;
276 }
277 let mut struct_ser = serializer.serialize_struct("compute.ShowConfigResponse", len)?;
278 if !self.batch_config.is_empty() {
279 struct_ser.serialize_field("batchConfig", &self.batch_config)?;
280 }
281 if !self.stream_config.is_empty() {
282 struct_ser.serialize_field("streamConfig", &self.stream_config)?;
283 }
284 struct_ser.end()
285 }
286}
287impl<'de> serde::Deserialize<'de> for ShowConfigResponse {
288 #[allow(deprecated)]
289 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
290 where
291 D: serde::Deserializer<'de>,
292 {
293 const FIELDS: &[&str] = &[
294 "batch_config",
295 "batchConfig",
296 "stream_config",
297 "streamConfig",
298 ];
299
300 #[allow(clippy::enum_variant_names)]
301 enum GeneratedField {
302 BatchConfig,
303 StreamConfig,
304 }
305 impl<'de> serde::Deserialize<'de> for GeneratedField {
306 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
307 where
308 D: serde::Deserializer<'de>,
309 {
310 struct GeneratedVisitor;
311
312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
313 type Value = GeneratedField;
314
315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
316 write!(formatter, "expected one of: {:?}", &FIELDS)
317 }
318
319 #[allow(unused_variables)]
320 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
321 where
322 E: serde::de::Error,
323 {
324 match value {
325 "batchConfig" | "batch_config" => Ok(GeneratedField::BatchConfig),
326 "streamConfig" | "stream_config" => Ok(GeneratedField::StreamConfig),
327 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
328 }
329 }
330 }
331 deserializer.deserialize_identifier(GeneratedVisitor)
332 }
333 }
334 struct GeneratedVisitor;
335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
336 type Value = ShowConfigResponse;
337
338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
339 formatter.write_str("struct compute.ShowConfigResponse")
340 }
341
342 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ShowConfigResponse, V::Error>
343 where
344 V: serde::de::MapAccess<'de>,
345 {
346 let mut batch_config__ = None;
347 let mut stream_config__ = None;
348 while let Some(k) = map_.next_key()? {
349 match k {
350 GeneratedField::BatchConfig => {
351 if batch_config__.is_some() {
352 return Err(serde::de::Error::duplicate_field("batchConfig"));
353 }
354 batch_config__ = Some(map_.next_value()?);
355 }
356 GeneratedField::StreamConfig => {
357 if stream_config__.is_some() {
358 return Err(serde::de::Error::duplicate_field("streamConfig"));
359 }
360 stream_config__ = Some(map_.next_value()?);
361 }
362 }
363 }
364 Ok(ShowConfigResponse {
365 batch_config: batch_config__.unwrap_or_default(),
366 stream_config: stream_config__.unwrap_or_default(),
367 })
368 }
369 }
370 deserializer.deserialize_struct("compute.ShowConfigResponse", FIELDS, GeneratedVisitor)
371 }
372}