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