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