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