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