1#![allow(clippy::useless_conversion)]
2use crate::task_service::*;
3impl serde::Serialize for CancelTaskRequest {
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.task_id.is_some() {
12 len += 1;
13 }
14 let mut struct_ser = serializer.serialize_struct("task_service.CancelTaskRequest", len)?;
15 if let Some(v) = self.task_id.as_ref() {
16 struct_ser.serialize_field("taskId", v)?;
17 }
18 struct_ser.end()
19 }
20}
21impl<'de> serde::Deserialize<'de> for CancelTaskRequest {
22 #[allow(deprecated)]
23 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
24 where
25 D: serde::Deserializer<'de>,
26 {
27 const FIELDS: &[&str] = &[
28 "task_id",
29 "taskId",
30 ];
31
32 #[allow(clippy::enum_variant_names)]
33 enum GeneratedField {
34 TaskId,
35 }
36 impl<'de> serde::Deserialize<'de> for GeneratedField {
37 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
38 where
39 D: serde::Deserializer<'de>,
40 {
41 struct GeneratedVisitor;
42
43 impl serde::de::Visitor<'_> for GeneratedVisitor {
44 type Value = GeneratedField;
45
46 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
47 write!(formatter, "expected one of: {:?}", &FIELDS)
48 }
49
50 #[allow(unused_variables)]
51 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
52 where
53 E: serde::de::Error,
54 {
55 match value {
56 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
57 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
58 }
59 }
60 }
61 deserializer.deserialize_identifier(GeneratedVisitor)
62 }
63 }
64 struct GeneratedVisitor;
65 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
66 type Value = CancelTaskRequest;
67
68 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
69 formatter.write_str("struct task_service.CancelTaskRequest")
70 }
71
72 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelTaskRequest, V::Error>
73 where
74 V: serde::de::MapAccess<'de>,
75 {
76 let mut task_id__ = None;
77 while let Some(k) = map_.next_key()? {
78 match k {
79 GeneratedField::TaskId => {
80 if task_id__.is_some() {
81 return Err(serde::de::Error::duplicate_field("taskId"));
82 }
83 task_id__ = map_.next_value()?;
84 }
85 }
86 }
87 Ok(CancelTaskRequest {
88 task_id: task_id__,
89 })
90 }
91 }
92 deserializer.deserialize_struct("task_service.CancelTaskRequest", FIELDS, GeneratedVisitor)
93 }
94}
95impl serde::Serialize for CancelTaskResponse {
96 #[allow(deprecated)]
97 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
98 where
99 S: serde::Serializer,
100 {
101 use serde::ser::SerializeStruct;
102 let mut len = 0;
103 if self.status.is_some() {
104 len += 1;
105 }
106 let mut struct_ser = serializer.serialize_struct("task_service.CancelTaskResponse", len)?;
107 if let Some(v) = self.status.as_ref() {
108 struct_ser.serialize_field("status", v)?;
109 }
110 struct_ser.end()
111 }
112}
113impl<'de> serde::Deserialize<'de> for CancelTaskResponse {
114 #[allow(deprecated)]
115 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
116 where
117 D: serde::Deserializer<'de>,
118 {
119 const FIELDS: &[&str] = &[
120 "status",
121 ];
122
123 #[allow(clippy::enum_variant_names)]
124 enum GeneratedField {
125 Status,
126 }
127 impl<'de> serde::Deserialize<'de> for GeneratedField {
128 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
129 where
130 D: serde::Deserializer<'de>,
131 {
132 struct GeneratedVisitor;
133
134 impl serde::de::Visitor<'_> for GeneratedVisitor {
135 type Value = GeneratedField;
136
137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
138 write!(formatter, "expected one of: {:?}", &FIELDS)
139 }
140
141 #[allow(unused_variables)]
142 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
143 where
144 E: serde::de::Error,
145 {
146 match value {
147 "status" => Ok(GeneratedField::Status),
148 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
149 }
150 }
151 }
152 deserializer.deserialize_identifier(GeneratedVisitor)
153 }
154 }
155 struct GeneratedVisitor;
156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
157 type Value = CancelTaskResponse;
158
159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
160 formatter.write_str("struct task_service.CancelTaskResponse")
161 }
162
163 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelTaskResponse, V::Error>
164 where
165 V: serde::de::MapAccess<'de>,
166 {
167 let mut status__ = None;
168 while let Some(k) = map_.next_key()? {
169 match k {
170 GeneratedField::Status => {
171 if status__.is_some() {
172 return Err(serde::de::Error::duplicate_field("status"));
173 }
174 status__ = map_.next_value()?;
175 }
176 }
177 }
178 Ok(CancelTaskResponse {
179 status: status__,
180 })
181 }
182 }
183 deserializer.deserialize_struct("task_service.CancelTaskResponse", FIELDS, GeneratedVisitor)
184 }
185}
186impl serde::Serialize for CreateTaskRequest {
187 #[allow(deprecated)]
188 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
189 where
190 S: serde::Serializer,
191 {
192 use serde::ser::SerializeStruct;
193 let mut len = 0;
194 if self.task_id.is_some() {
195 len += 1;
196 }
197 if self.plan.is_some() {
198 len += 1;
199 }
200 if !self.tracing_context.is_empty() {
201 len += 1;
202 }
203 if self.expr_context.is_some() {
204 len += 1;
205 }
206 let mut struct_ser = serializer.serialize_struct("task_service.CreateTaskRequest", len)?;
207 if let Some(v) = self.task_id.as_ref() {
208 struct_ser.serialize_field("taskId", v)?;
209 }
210 if let Some(v) = self.plan.as_ref() {
211 struct_ser.serialize_field("plan", v)?;
212 }
213 if !self.tracing_context.is_empty() {
214 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
215 }
216 if let Some(v) = self.expr_context.as_ref() {
217 struct_ser.serialize_field("exprContext", v)?;
218 }
219 struct_ser.end()
220 }
221}
222impl<'de> serde::Deserialize<'de> for CreateTaskRequest {
223 #[allow(deprecated)]
224 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
225 where
226 D: serde::Deserializer<'de>,
227 {
228 const FIELDS: &[&str] = &[
229 "task_id",
230 "taskId",
231 "plan",
232 "tracing_context",
233 "tracingContext",
234 "expr_context",
235 "exprContext",
236 ];
237
238 #[allow(clippy::enum_variant_names)]
239 enum GeneratedField {
240 TaskId,
241 Plan,
242 TracingContext,
243 ExprContext,
244 }
245 impl<'de> serde::Deserialize<'de> for GeneratedField {
246 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
247 where
248 D: serde::Deserializer<'de>,
249 {
250 struct GeneratedVisitor;
251
252 impl serde::de::Visitor<'_> for GeneratedVisitor {
253 type Value = GeneratedField;
254
255 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
256 write!(formatter, "expected one of: {:?}", &FIELDS)
257 }
258
259 #[allow(unused_variables)]
260 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
261 where
262 E: serde::de::Error,
263 {
264 match value {
265 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
266 "plan" => Ok(GeneratedField::Plan),
267 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
268 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
269 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
270 }
271 }
272 }
273 deserializer.deserialize_identifier(GeneratedVisitor)
274 }
275 }
276 struct GeneratedVisitor;
277 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
278 type Value = CreateTaskRequest;
279
280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
281 formatter.write_str("struct task_service.CreateTaskRequest")
282 }
283
284 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTaskRequest, V::Error>
285 where
286 V: serde::de::MapAccess<'de>,
287 {
288 let mut task_id__ = None;
289 let mut plan__ = None;
290 let mut tracing_context__ = None;
291 let mut expr_context__ = None;
292 while let Some(k) = map_.next_key()? {
293 match k {
294 GeneratedField::TaskId => {
295 if task_id__.is_some() {
296 return Err(serde::de::Error::duplicate_field("taskId"));
297 }
298 task_id__ = map_.next_value()?;
299 }
300 GeneratedField::Plan => {
301 if plan__.is_some() {
302 return Err(serde::de::Error::duplicate_field("plan"));
303 }
304 plan__ = map_.next_value()?;
305 }
306 GeneratedField::TracingContext => {
307 if tracing_context__.is_some() {
308 return Err(serde::de::Error::duplicate_field("tracingContext"));
309 }
310 tracing_context__ = Some(
311 map_.next_value::<std::collections::HashMap<_, _>>()?
312 );
313 }
314 GeneratedField::ExprContext => {
315 if expr_context__.is_some() {
316 return Err(serde::de::Error::duplicate_field("exprContext"));
317 }
318 expr_context__ = map_.next_value()?;
319 }
320 }
321 }
322 Ok(CreateTaskRequest {
323 task_id: task_id__,
324 plan: plan__,
325 tracing_context: tracing_context__.unwrap_or_default(),
326 expr_context: expr_context__,
327 })
328 }
329 }
330 deserializer.deserialize_struct("task_service.CreateTaskRequest", FIELDS, GeneratedVisitor)
331 }
332}
333impl serde::Serialize for ExecuteRequest {
334 #[allow(deprecated)]
335 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
336 where
337 S: serde::Serializer,
338 {
339 use serde::ser::SerializeStruct;
340 let mut len = 0;
341 if self.task_id.is_some() {
342 len += 1;
343 }
344 if self.plan.is_some() {
345 len += 1;
346 }
347 if !self.tracing_context.is_empty() {
348 len += 1;
349 }
350 if self.expr_context.is_some() {
351 len += 1;
352 }
353 let mut struct_ser = serializer.serialize_struct("task_service.ExecuteRequest", len)?;
354 if let Some(v) = self.task_id.as_ref() {
355 struct_ser.serialize_field("taskId", v)?;
356 }
357 if let Some(v) = self.plan.as_ref() {
358 struct_ser.serialize_field("plan", v)?;
359 }
360 if !self.tracing_context.is_empty() {
361 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
362 }
363 if let Some(v) = self.expr_context.as_ref() {
364 struct_ser.serialize_field("exprContext", v)?;
365 }
366 struct_ser.end()
367 }
368}
369impl<'de> serde::Deserialize<'de> for ExecuteRequest {
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 "task_id",
377 "taskId",
378 "plan",
379 "tracing_context",
380 "tracingContext",
381 "expr_context",
382 "exprContext",
383 ];
384
385 #[allow(clippy::enum_variant_names)]
386 enum GeneratedField {
387 TaskId,
388 Plan,
389 TracingContext,
390 ExprContext,
391 }
392 impl<'de> serde::Deserialize<'de> for GeneratedField {
393 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
394 where
395 D: serde::Deserializer<'de>,
396 {
397 struct GeneratedVisitor;
398
399 impl serde::de::Visitor<'_> for GeneratedVisitor {
400 type Value = GeneratedField;
401
402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
403 write!(formatter, "expected one of: {:?}", &FIELDS)
404 }
405
406 #[allow(unused_variables)]
407 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
408 where
409 E: serde::de::Error,
410 {
411 match value {
412 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
413 "plan" => Ok(GeneratedField::Plan),
414 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
415 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
416 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
417 }
418 }
419 }
420 deserializer.deserialize_identifier(GeneratedVisitor)
421 }
422 }
423 struct GeneratedVisitor;
424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
425 type Value = ExecuteRequest;
426
427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
428 formatter.write_str("struct task_service.ExecuteRequest")
429 }
430
431 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExecuteRequest, V::Error>
432 where
433 V: serde::de::MapAccess<'de>,
434 {
435 let mut task_id__ = None;
436 let mut plan__ = None;
437 let mut tracing_context__ = None;
438 let mut expr_context__ = None;
439 while let Some(k) = map_.next_key()? {
440 match k {
441 GeneratedField::TaskId => {
442 if task_id__.is_some() {
443 return Err(serde::de::Error::duplicate_field("taskId"));
444 }
445 task_id__ = map_.next_value()?;
446 }
447 GeneratedField::Plan => {
448 if plan__.is_some() {
449 return Err(serde::de::Error::duplicate_field("plan"));
450 }
451 plan__ = map_.next_value()?;
452 }
453 GeneratedField::TracingContext => {
454 if tracing_context__.is_some() {
455 return Err(serde::de::Error::duplicate_field("tracingContext"));
456 }
457 tracing_context__ = Some(
458 map_.next_value::<std::collections::HashMap<_, _>>()?
459 );
460 }
461 GeneratedField::ExprContext => {
462 if expr_context__.is_some() {
463 return Err(serde::de::Error::duplicate_field("exprContext"));
464 }
465 expr_context__ = map_.next_value()?;
466 }
467 }
468 }
469 Ok(ExecuteRequest {
470 task_id: task_id__,
471 plan: plan__,
472 tracing_context: tracing_context__.unwrap_or_default(),
473 expr_context: expr_context__,
474 })
475 }
476 }
477 deserializer.deserialize_struct("task_service.ExecuteRequest", FIELDS, GeneratedVisitor)
478 }
479}
480impl serde::Serialize for FastInsertRequest {
481 #[allow(deprecated)]
482 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
483 where
484 S: serde::Serializer,
485 {
486 use serde::ser::SerializeStruct;
487 let mut len = 0;
488 if self.table_id != 0 {
489 len += 1;
490 }
491 if self.table_version_id != 0 {
492 len += 1;
493 }
494 if !self.column_indices.is_empty() {
495 len += 1;
496 }
497 if self.data_chunk.is_some() {
498 len += 1;
499 }
500 if self.row_id_index.is_some() {
501 len += 1;
502 }
503 if self.request_id != 0 {
504 len += 1;
505 }
506 if self.wait_for_persistence {
507 len += 1;
508 }
509 let mut struct_ser = serializer.serialize_struct("task_service.FastInsertRequest", len)?;
510 if self.table_id != 0 {
511 struct_ser.serialize_field("tableId", &self.table_id)?;
512 }
513 if self.table_version_id != 0 {
514 #[allow(clippy::needless_borrow)]
515 #[allow(clippy::needless_borrows_for_generic_args)]
516 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
517 }
518 if !self.column_indices.is_empty() {
519 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
520 }
521 if let Some(v) = self.data_chunk.as_ref() {
522 struct_ser.serialize_field("dataChunk", v)?;
523 }
524 if let Some(v) = self.row_id_index.as_ref() {
525 struct_ser.serialize_field("rowIdIndex", v)?;
526 }
527 if self.request_id != 0 {
528 struct_ser.serialize_field("requestId", &self.request_id)?;
529 }
530 if self.wait_for_persistence {
531 struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
532 }
533 struct_ser.end()
534 }
535}
536impl<'de> serde::Deserialize<'de> for FastInsertRequest {
537 #[allow(deprecated)]
538 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
539 where
540 D: serde::Deserializer<'de>,
541 {
542 const FIELDS: &[&str] = &[
543 "table_id",
544 "tableId",
545 "table_version_id",
546 "tableVersionId",
547 "column_indices",
548 "columnIndices",
549 "data_chunk",
550 "dataChunk",
551 "row_id_index",
552 "rowIdIndex",
553 "request_id",
554 "requestId",
555 "wait_for_persistence",
556 "waitForPersistence",
557 ];
558
559 #[allow(clippy::enum_variant_names)]
560 enum GeneratedField {
561 TableId,
562 TableVersionId,
563 ColumnIndices,
564 DataChunk,
565 RowIdIndex,
566 RequestId,
567 WaitForPersistence,
568 }
569 impl<'de> serde::Deserialize<'de> for GeneratedField {
570 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
571 where
572 D: serde::Deserializer<'de>,
573 {
574 struct GeneratedVisitor;
575
576 impl serde::de::Visitor<'_> for GeneratedVisitor {
577 type Value = GeneratedField;
578
579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
580 write!(formatter, "expected one of: {:?}", &FIELDS)
581 }
582
583 #[allow(unused_variables)]
584 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
585 where
586 E: serde::de::Error,
587 {
588 match value {
589 "tableId" | "table_id" => Ok(GeneratedField::TableId),
590 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
591 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
592 "dataChunk" | "data_chunk" => Ok(GeneratedField::DataChunk),
593 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
594 "requestId" | "request_id" => Ok(GeneratedField::RequestId),
595 "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
596 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
597 }
598 }
599 }
600 deserializer.deserialize_identifier(GeneratedVisitor)
601 }
602 }
603 struct GeneratedVisitor;
604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
605 type Value = FastInsertRequest;
606
607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
608 formatter.write_str("struct task_service.FastInsertRequest")
609 }
610
611 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FastInsertRequest, V::Error>
612 where
613 V: serde::de::MapAccess<'de>,
614 {
615 let mut table_id__ = None;
616 let mut table_version_id__ = None;
617 let mut column_indices__ = None;
618 let mut data_chunk__ = None;
619 let mut row_id_index__ = None;
620 let mut request_id__ = None;
621 let mut wait_for_persistence__ = None;
622 while let Some(k) = map_.next_key()? {
623 match k {
624 GeneratedField::TableId => {
625 if table_id__.is_some() {
626 return Err(serde::de::Error::duplicate_field("tableId"));
627 }
628 table_id__ =
629 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
630 ;
631 }
632 GeneratedField::TableVersionId => {
633 if table_version_id__.is_some() {
634 return Err(serde::de::Error::duplicate_field("tableVersionId"));
635 }
636 table_version_id__ =
637 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
638 ;
639 }
640 GeneratedField::ColumnIndices => {
641 if column_indices__.is_some() {
642 return Err(serde::de::Error::duplicate_field("columnIndices"));
643 }
644 column_indices__ =
645 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
646 .into_iter().map(|x| x.0).collect())
647 ;
648 }
649 GeneratedField::DataChunk => {
650 if data_chunk__.is_some() {
651 return Err(serde::de::Error::duplicate_field("dataChunk"));
652 }
653 data_chunk__ = map_.next_value()?;
654 }
655 GeneratedField::RowIdIndex => {
656 if row_id_index__.is_some() {
657 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
658 }
659 row_id_index__ =
660 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
661 ;
662 }
663 GeneratedField::RequestId => {
664 if request_id__.is_some() {
665 return Err(serde::de::Error::duplicate_field("requestId"));
666 }
667 request_id__ =
668 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
669 ;
670 }
671 GeneratedField::WaitForPersistence => {
672 if wait_for_persistence__.is_some() {
673 return Err(serde::de::Error::duplicate_field("waitForPersistence"));
674 }
675 wait_for_persistence__ = Some(map_.next_value()?);
676 }
677 }
678 }
679 Ok(FastInsertRequest {
680 table_id: table_id__.unwrap_or_default(),
681 table_version_id: table_version_id__.unwrap_or_default(),
682 column_indices: column_indices__.unwrap_or_default(),
683 data_chunk: data_chunk__,
684 row_id_index: row_id_index__,
685 request_id: request_id__.unwrap_or_default(),
686 wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
687 })
688 }
689 }
690 deserializer.deserialize_struct("task_service.FastInsertRequest", FIELDS, GeneratedVisitor)
691 }
692}
693impl serde::Serialize for FastInsertResponse {
694 #[allow(deprecated)]
695 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
696 where
697 S: serde::Serializer,
698 {
699 use serde::ser::SerializeStruct;
700 let mut len = 0;
701 if self.status != 0 {
702 len += 1;
703 }
704 if !self.error_message.is_empty() {
705 len += 1;
706 }
707 let mut struct_ser = serializer.serialize_struct("task_service.FastInsertResponse", len)?;
708 if self.status != 0 {
709 let v = fast_insert_response::Status::try_from(self.status)
710 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
711 struct_ser.serialize_field("status", &v)?;
712 }
713 if !self.error_message.is_empty() {
714 struct_ser.serialize_field("errorMessage", &self.error_message)?;
715 }
716 struct_ser.end()
717 }
718}
719impl<'de> serde::Deserialize<'de> for FastInsertResponse {
720 #[allow(deprecated)]
721 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
722 where
723 D: serde::Deserializer<'de>,
724 {
725 const FIELDS: &[&str] = &[
726 "status",
727 "error_message",
728 "errorMessage",
729 ];
730
731 #[allow(clippy::enum_variant_names)]
732 enum GeneratedField {
733 Status,
734 ErrorMessage,
735 }
736 impl<'de> serde::Deserialize<'de> for GeneratedField {
737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
738 where
739 D: serde::Deserializer<'de>,
740 {
741 struct GeneratedVisitor;
742
743 impl serde::de::Visitor<'_> for GeneratedVisitor {
744 type Value = GeneratedField;
745
746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
747 write!(formatter, "expected one of: {:?}", &FIELDS)
748 }
749
750 #[allow(unused_variables)]
751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
752 where
753 E: serde::de::Error,
754 {
755 match value {
756 "status" => Ok(GeneratedField::Status),
757 "errorMessage" | "error_message" => Ok(GeneratedField::ErrorMessage),
758 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
759 }
760 }
761 }
762 deserializer.deserialize_identifier(GeneratedVisitor)
763 }
764 }
765 struct GeneratedVisitor;
766 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
767 type Value = FastInsertResponse;
768
769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
770 formatter.write_str("struct task_service.FastInsertResponse")
771 }
772
773 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FastInsertResponse, V::Error>
774 where
775 V: serde::de::MapAccess<'de>,
776 {
777 let mut status__ = None;
778 let mut error_message__ = None;
779 while let Some(k) = map_.next_key()? {
780 match k {
781 GeneratedField::Status => {
782 if status__.is_some() {
783 return Err(serde::de::Error::duplicate_field("status"));
784 }
785 status__ = Some(map_.next_value::<fast_insert_response::Status>()? as i32);
786 }
787 GeneratedField::ErrorMessage => {
788 if error_message__.is_some() {
789 return Err(serde::de::Error::duplicate_field("errorMessage"));
790 }
791 error_message__ = Some(map_.next_value()?);
792 }
793 }
794 }
795 Ok(FastInsertResponse {
796 status: status__.unwrap_or_default(),
797 error_message: error_message__.unwrap_or_default(),
798 })
799 }
800 }
801 deserializer.deserialize_struct("task_service.FastInsertResponse", FIELDS, GeneratedVisitor)
802 }
803}
804impl serde::Serialize for fast_insert_response::Status {
805 #[allow(deprecated)]
806 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
807 where
808 S: serde::Serializer,
809 {
810 let variant = match self {
811 Self::Unspecified => "UNSPECIFIED",
812 Self::Succeeded => "SUCCEEDED",
813 Self::DmlFailed => "DML_FAILED",
814 };
815 serializer.serialize_str(variant)
816 }
817}
818impl<'de> serde::Deserialize<'de> for fast_insert_response::Status {
819 #[allow(deprecated)]
820 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
821 where
822 D: serde::Deserializer<'de>,
823 {
824 const FIELDS: &[&str] = &[
825 "UNSPECIFIED",
826 "SUCCEEDED",
827 "DML_FAILED",
828 ];
829
830 struct GeneratedVisitor;
831
832 impl serde::de::Visitor<'_> for GeneratedVisitor {
833 type Value = fast_insert_response::Status;
834
835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
836 write!(formatter, "expected one of: {:?}", &FIELDS)
837 }
838
839 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
840 where
841 E: serde::de::Error,
842 {
843 i32::try_from(v)
844 .ok()
845 .and_then(|x| x.try_into().ok())
846 .ok_or_else(|| {
847 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
848 })
849 }
850
851 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
852 where
853 E: serde::de::Error,
854 {
855 i32::try_from(v)
856 .ok()
857 .and_then(|x| x.try_into().ok())
858 .ok_or_else(|| {
859 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
860 })
861 }
862
863 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
864 where
865 E: serde::de::Error,
866 {
867 match value {
868 "UNSPECIFIED" => Ok(fast_insert_response::Status::Unspecified),
869 "SUCCEEDED" => Ok(fast_insert_response::Status::Succeeded),
870 "DML_FAILED" => Ok(fast_insert_response::Status::DmlFailed),
871 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
872 }
873 }
874 }
875 deserializer.deserialize_any(GeneratedVisitor)
876 }
877}
878impl serde::Serialize for GetDataRequest {
879 #[allow(deprecated)]
880 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
881 where
882 S: serde::Serializer,
883 {
884 use serde::ser::SerializeStruct;
885 let mut len = 0;
886 if self.task_output_id.is_some() {
887 len += 1;
888 }
889 let mut struct_ser = serializer.serialize_struct("task_service.GetDataRequest", len)?;
890 if let Some(v) = self.task_output_id.as_ref() {
891 struct_ser.serialize_field("taskOutputId", v)?;
892 }
893 struct_ser.end()
894 }
895}
896impl<'de> serde::Deserialize<'de> for GetDataRequest {
897 #[allow(deprecated)]
898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
899 where
900 D: serde::Deserializer<'de>,
901 {
902 const FIELDS: &[&str] = &[
903 "task_output_id",
904 "taskOutputId",
905 ];
906
907 #[allow(clippy::enum_variant_names)]
908 enum GeneratedField {
909 TaskOutputId,
910 }
911 impl<'de> serde::Deserialize<'de> for GeneratedField {
912 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
913 where
914 D: serde::Deserializer<'de>,
915 {
916 struct GeneratedVisitor;
917
918 impl serde::de::Visitor<'_> for GeneratedVisitor {
919 type Value = GeneratedField;
920
921 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
922 write!(formatter, "expected one of: {:?}", &FIELDS)
923 }
924
925 #[allow(unused_variables)]
926 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
927 where
928 E: serde::de::Error,
929 {
930 match value {
931 "taskOutputId" | "task_output_id" => Ok(GeneratedField::TaskOutputId),
932 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
933 }
934 }
935 }
936 deserializer.deserialize_identifier(GeneratedVisitor)
937 }
938 }
939 struct GeneratedVisitor;
940 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
941 type Value = GetDataRequest;
942
943 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
944 formatter.write_str("struct task_service.GetDataRequest")
945 }
946
947 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDataRequest, V::Error>
948 where
949 V: serde::de::MapAccess<'de>,
950 {
951 let mut task_output_id__ = None;
952 while let Some(k) = map_.next_key()? {
953 match k {
954 GeneratedField::TaskOutputId => {
955 if task_output_id__.is_some() {
956 return Err(serde::de::Error::duplicate_field("taskOutputId"));
957 }
958 task_output_id__ = map_.next_value()?;
959 }
960 }
961 }
962 Ok(GetDataRequest {
963 task_output_id: task_output_id__,
964 })
965 }
966 }
967 deserializer.deserialize_struct("task_service.GetDataRequest", FIELDS, GeneratedVisitor)
968 }
969}
970impl serde::Serialize for GetDataResponse {
971 #[allow(deprecated)]
972 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
973 where
974 S: serde::Serializer,
975 {
976 use serde::ser::SerializeStruct;
977 let mut len = 0;
978 if self.record_batch.is_some() {
979 len += 1;
980 }
981 let mut struct_ser = serializer.serialize_struct("task_service.GetDataResponse", len)?;
982 if let Some(v) = self.record_batch.as_ref() {
983 struct_ser.serialize_field("recordBatch", v)?;
984 }
985 struct_ser.end()
986 }
987}
988impl<'de> serde::Deserialize<'de> for GetDataResponse {
989 #[allow(deprecated)]
990 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
991 where
992 D: serde::Deserializer<'de>,
993 {
994 const FIELDS: &[&str] = &[
995 "record_batch",
996 "recordBatch",
997 ];
998
999 #[allow(clippy::enum_variant_names)]
1000 enum GeneratedField {
1001 RecordBatch,
1002 }
1003 impl<'de> serde::Deserialize<'de> for GeneratedField {
1004 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1005 where
1006 D: serde::Deserializer<'de>,
1007 {
1008 struct GeneratedVisitor;
1009
1010 impl serde::de::Visitor<'_> for GeneratedVisitor {
1011 type Value = GeneratedField;
1012
1013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1014 write!(formatter, "expected one of: {:?}", &FIELDS)
1015 }
1016
1017 #[allow(unused_variables)]
1018 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1019 where
1020 E: serde::de::Error,
1021 {
1022 match value {
1023 "recordBatch" | "record_batch" => Ok(GeneratedField::RecordBatch),
1024 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1025 }
1026 }
1027 }
1028 deserializer.deserialize_identifier(GeneratedVisitor)
1029 }
1030 }
1031 struct GeneratedVisitor;
1032 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1033 type Value = GetDataResponse;
1034
1035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1036 formatter.write_str("struct task_service.GetDataResponse")
1037 }
1038
1039 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDataResponse, V::Error>
1040 where
1041 V: serde::de::MapAccess<'de>,
1042 {
1043 let mut record_batch__ = None;
1044 while let Some(k) = map_.next_key()? {
1045 match k {
1046 GeneratedField::RecordBatch => {
1047 if record_batch__.is_some() {
1048 return Err(serde::de::Error::duplicate_field("recordBatch"));
1049 }
1050 record_batch__ = map_.next_value()?;
1051 }
1052 }
1053 }
1054 Ok(GetDataResponse {
1055 record_batch: record_batch__,
1056 })
1057 }
1058 }
1059 deserializer.deserialize_struct("task_service.GetDataResponse", FIELDS, GeneratedVisitor)
1060 }
1061}
1062impl serde::Serialize for GetStreamRequest {
1063 #[allow(deprecated)]
1064 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1065 where
1066 S: serde::Serializer,
1067 {
1068 use serde::ser::SerializeStruct;
1069 let mut len = 0;
1070 if self.value.is_some() {
1071 len += 1;
1072 }
1073 let mut struct_ser = serializer.serialize_struct("task_service.GetStreamRequest", len)?;
1074 if let Some(v) = self.value.as_ref() {
1075 match v {
1076 get_stream_request::Value::Get(v) => {
1077 struct_ser.serialize_field("get", v)?;
1078 }
1079 get_stream_request::Value::AddPermits(v) => {
1080 struct_ser.serialize_field("addPermits", v)?;
1081 }
1082 }
1083 }
1084 struct_ser.end()
1085 }
1086}
1087impl<'de> serde::Deserialize<'de> for GetStreamRequest {
1088 #[allow(deprecated)]
1089 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1090 where
1091 D: serde::Deserializer<'de>,
1092 {
1093 const FIELDS: &[&str] = &[
1094 "get",
1095 "add_permits",
1096 "addPermits",
1097 ];
1098
1099 #[allow(clippy::enum_variant_names)]
1100 enum GeneratedField {
1101 Get,
1102 AddPermits,
1103 }
1104 impl<'de> serde::Deserialize<'de> for GeneratedField {
1105 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1106 where
1107 D: serde::Deserializer<'de>,
1108 {
1109 struct GeneratedVisitor;
1110
1111 impl serde::de::Visitor<'_> for GeneratedVisitor {
1112 type Value = GeneratedField;
1113
1114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1115 write!(formatter, "expected one of: {:?}", &FIELDS)
1116 }
1117
1118 #[allow(unused_variables)]
1119 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1120 where
1121 E: serde::de::Error,
1122 {
1123 match value {
1124 "get" => Ok(GeneratedField::Get),
1125 "addPermits" | "add_permits" => Ok(GeneratedField::AddPermits),
1126 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1127 }
1128 }
1129 }
1130 deserializer.deserialize_identifier(GeneratedVisitor)
1131 }
1132 }
1133 struct GeneratedVisitor;
1134 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1135 type Value = GetStreamRequest;
1136
1137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1138 formatter.write_str("struct task_service.GetStreamRequest")
1139 }
1140
1141 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamRequest, V::Error>
1142 where
1143 V: serde::de::MapAccess<'de>,
1144 {
1145 let mut value__ = None;
1146 while let Some(k) = map_.next_key()? {
1147 match k {
1148 GeneratedField::Get => {
1149 if value__.is_some() {
1150 return Err(serde::de::Error::duplicate_field("get"));
1151 }
1152 value__ = map_.next_value::<::std::option::Option<_>>()?.map(get_stream_request::Value::Get)
1153;
1154 }
1155 GeneratedField::AddPermits => {
1156 if value__.is_some() {
1157 return Err(serde::de::Error::duplicate_field("addPermits"));
1158 }
1159 value__ = map_.next_value::<::std::option::Option<_>>()?.map(get_stream_request::Value::AddPermits)
1160;
1161 }
1162 }
1163 }
1164 Ok(GetStreamRequest {
1165 value: value__,
1166 })
1167 }
1168 }
1169 deserializer.deserialize_struct("task_service.GetStreamRequest", FIELDS, GeneratedVisitor)
1170 }
1171}
1172impl serde::Serialize for get_stream_request::Get {
1173 #[allow(deprecated)]
1174 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1175 where
1176 S: serde::Serializer,
1177 {
1178 use serde::ser::SerializeStruct;
1179 let mut len = 0;
1180 if self.up_actor_id != 0 {
1181 len += 1;
1182 }
1183 if self.down_actor_id != 0 {
1184 len += 1;
1185 }
1186 if self.up_fragment_id != 0 {
1187 len += 1;
1188 }
1189 if self.down_fragment_id != 0 {
1190 len += 1;
1191 }
1192 if self.up_partial_graph_id != 0 {
1193 len += 1;
1194 }
1195 if !self.term_id.is_empty() {
1196 len += 1;
1197 }
1198 let mut struct_ser = serializer.serialize_struct("task_service.GetStreamRequest.Get", len)?;
1199 if self.up_actor_id != 0 {
1200 struct_ser.serialize_field("upActorId", &self.up_actor_id)?;
1201 }
1202 if self.down_actor_id != 0 {
1203 struct_ser.serialize_field("downActorId", &self.down_actor_id)?;
1204 }
1205 if self.up_fragment_id != 0 {
1206 struct_ser.serialize_field("upFragmentId", &self.up_fragment_id)?;
1207 }
1208 if self.down_fragment_id != 0 {
1209 struct_ser.serialize_field("downFragmentId", &self.down_fragment_id)?;
1210 }
1211 if self.up_partial_graph_id != 0 {
1212 #[allow(clippy::needless_borrow)]
1213 #[allow(clippy::needless_borrows_for_generic_args)]
1214 struct_ser.serialize_field("upPartialGraphId", ToString::to_string(&self.up_partial_graph_id).as_str())?;
1215 }
1216 if !self.term_id.is_empty() {
1217 struct_ser.serialize_field("termId", &self.term_id)?;
1218 }
1219 struct_ser.end()
1220 }
1221}
1222impl<'de> serde::Deserialize<'de> for get_stream_request::Get {
1223 #[allow(deprecated)]
1224 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1225 where
1226 D: serde::Deserializer<'de>,
1227 {
1228 const FIELDS: &[&str] = &[
1229 "up_actor_id",
1230 "upActorId",
1231 "down_actor_id",
1232 "downActorId",
1233 "up_fragment_id",
1234 "upFragmentId",
1235 "down_fragment_id",
1236 "downFragmentId",
1237 "up_partial_graph_id",
1238 "upPartialGraphId",
1239 "term_id",
1240 "termId",
1241 ];
1242
1243 #[allow(clippy::enum_variant_names)]
1244 enum GeneratedField {
1245 UpActorId,
1246 DownActorId,
1247 UpFragmentId,
1248 DownFragmentId,
1249 UpPartialGraphId,
1250 TermId,
1251 }
1252 impl<'de> serde::Deserialize<'de> for GeneratedField {
1253 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1254 where
1255 D: serde::Deserializer<'de>,
1256 {
1257 struct GeneratedVisitor;
1258
1259 impl serde::de::Visitor<'_> for GeneratedVisitor {
1260 type Value = GeneratedField;
1261
1262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1263 write!(formatter, "expected one of: {:?}", &FIELDS)
1264 }
1265
1266 #[allow(unused_variables)]
1267 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1268 where
1269 E: serde::de::Error,
1270 {
1271 match value {
1272 "upActorId" | "up_actor_id" => Ok(GeneratedField::UpActorId),
1273 "downActorId" | "down_actor_id" => Ok(GeneratedField::DownActorId),
1274 "upFragmentId" | "up_fragment_id" => Ok(GeneratedField::UpFragmentId),
1275 "downFragmentId" | "down_fragment_id" => Ok(GeneratedField::DownFragmentId),
1276 "upPartialGraphId" | "up_partial_graph_id" => Ok(GeneratedField::UpPartialGraphId),
1277 "termId" | "term_id" => Ok(GeneratedField::TermId),
1278 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1279 }
1280 }
1281 }
1282 deserializer.deserialize_identifier(GeneratedVisitor)
1283 }
1284 }
1285 struct GeneratedVisitor;
1286 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1287 type Value = get_stream_request::Get;
1288
1289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1290 formatter.write_str("struct task_service.GetStreamRequest.Get")
1291 }
1292
1293 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_stream_request::Get, V::Error>
1294 where
1295 V: serde::de::MapAccess<'de>,
1296 {
1297 let mut up_actor_id__ = None;
1298 let mut down_actor_id__ = None;
1299 let mut up_fragment_id__ = None;
1300 let mut down_fragment_id__ = None;
1301 let mut up_partial_graph_id__ = None;
1302 let mut term_id__ = None;
1303 while let Some(k) = map_.next_key()? {
1304 match k {
1305 GeneratedField::UpActorId => {
1306 if up_actor_id__.is_some() {
1307 return Err(serde::de::Error::duplicate_field("upActorId"));
1308 }
1309 up_actor_id__ =
1310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1311 ;
1312 }
1313 GeneratedField::DownActorId => {
1314 if down_actor_id__.is_some() {
1315 return Err(serde::de::Error::duplicate_field("downActorId"));
1316 }
1317 down_actor_id__ =
1318 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1319 ;
1320 }
1321 GeneratedField::UpFragmentId => {
1322 if up_fragment_id__.is_some() {
1323 return Err(serde::de::Error::duplicate_field("upFragmentId"));
1324 }
1325 up_fragment_id__ =
1326 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1327 ;
1328 }
1329 GeneratedField::DownFragmentId => {
1330 if down_fragment_id__.is_some() {
1331 return Err(serde::de::Error::duplicate_field("downFragmentId"));
1332 }
1333 down_fragment_id__ =
1334 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1335 ;
1336 }
1337 GeneratedField::UpPartialGraphId => {
1338 if up_partial_graph_id__.is_some() {
1339 return Err(serde::de::Error::duplicate_field("upPartialGraphId"));
1340 }
1341 up_partial_graph_id__ =
1342 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1343 ;
1344 }
1345 GeneratedField::TermId => {
1346 if term_id__.is_some() {
1347 return Err(serde::de::Error::duplicate_field("termId"));
1348 }
1349 term_id__ = Some(map_.next_value()?);
1350 }
1351 }
1352 }
1353 Ok(get_stream_request::Get {
1354 up_actor_id: up_actor_id__.unwrap_or_default(),
1355 down_actor_id: down_actor_id__.unwrap_or_default(),
1356 up_fragment_id: up_fragment_id__.unwrap_or_default(),
1357 down_fragment_id: down_fragment_id__.unwrap_or_default(),
1358 up_partial_graph_id: up_partial_graph_id__.unwrap_or_default(),
1359 term_id: term_id__.unwrap_or_default(),
1360 })
1361 }
1362 }
1363 deserializer.deserialize_struct("task_service.GetStreamRequest.Get", FIELDS, GeneratedVisitor)
1364 }
1365}
1366impl serde::Serialize for GetStreamResponse {
1367 #[allow(deprecated)]
1368 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1369 where
1370 S: serde::Serializer,
1371 {
1372 use serde::ser::SerializeStruct;
1373 let mut len = 0;
1374 if self.message.is_some() {
1375 len += 1;
1376 }
1377 if self.permits.is_some() {
1378 len += 1;
1379 }
1380 let mut struct_ser = serializer.serialize_struct("task_service.GetStreamResponse", len)?;
1381 if let Some(v) = self.message.as_ref() {
1382 struct_ser.serialize_field("message", v)?;
1383 }
1384 if let Some(v) = self.permits.as_ref() {
1385 struct_ser.serialize_field("permits", v)?;
1386 }
1387 struct_ser.end()
1388 }
1389}
1390impl<'de> serde::Deserialize<'de> for GetStreamResponse {
1391 #[allow(deprecated)]
1392 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1393 where
1394 D: serde::Deserializer<'de>,
1395 {
1396 const FIELDS: &[&str] = &[
1397 "message",
1398 "permits",
1399 ];
1400
1401 #[allow(clippy::enum_variant_names)]
1402 enum GeneratedField {
1403 Message,
1404 Permits,
1405 }
1406 impl<'de> serde::Deserialize<'de> for GeneratedField {
1407 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1408 where
1409 D: serde::Deserializer<'de>,
1410 {
1411 struct GeneratedVisitor;
1412
1413 impl serde::de::Visitor<'_> for GeneratedVisitor {
1414 type Value = GeneratedField;
1415
1416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1417 write!(formatter, "expected one of: {:?}", &FIELDS)
1418 }
1419
1420 #[allow(unused_variables)]
1421 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1422 where
1423 E: serde::de::Error,
1424 {
1425 match value {
1426 "message" => Ok(GeneratedField::Message),
1427 "permits" => Ok(GeneratedField::Permits),
1428 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1429 }
1430 }
1431 }
1432 deserializer.deserialize_identifier(GeneratedVisitor)
1433 }
1434 }
1435 struct GeneratedVisitor;
1436 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1437 type Value = GetStreamResponse;
1438
1439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1440 formatter.write_str("struct task_service.GetStreamResponse")
1441 }
1442
1443 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamResponse, V::Error>
1444 where
1445 V: serde::de::MapAccess<'de>,
1446 {
1447 let mut message__ = None;
1448 let mut permits__ = None;
1449 while let Some(k) = map_.next_key()? {
1450 match k {
1451 GeneratedField::Message => {
1452 if message__.is_some() {
1453 return Err(serde::de::Error::duplicate_field("message"));
1454 }
1455 message__ = map_.next_value()?;
1456 }
1457 GeneratedField::Permits => {
1458 if permits__.is_some() {
1459 return Err(serde::de::Error::duplicate_field("permits"));
1460 }
1461 permits__ = map_.next_value()?;
1462 }
1463 }
1464 }
1465 Ok(GetStreamResponse {
1466 message: message__,
1467 permits: permits__,
1468 })
1469 }
1470 }
1471 deserializer.deserialize_struct("task_service.GetStreamResponse", FIELDS, GeneratedVisitor)
1472 }
1473}
1474impl serde::Serialize for GetTaskInfoRequest {
1475 #[allow(deprecated)]
1476 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1477 where
1478 S: serde::Serializer,
1479 {
1480 use serde::ser::SerializeStruct;
1481 let mut len = 0;
1482 if self.task_id.is_some() {
1483 len += 1;
1484 }
1485 let mut struct_ser = serializer.serialize_struct("task_service.GetTaskInfoRequest", len)?;
1486 if let Some(v) = self.task_id.as_ref() {
1487 struct_ser.serialize_field("taskId", v)?;
1488 }
1489 struct_ser.end()
1490 }
1491}
1492impl<'de> serde::Deserialize<'de> for GetTaskInfoRequest {
1493 #[allow(deprecated)]
1494 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1495 where
1496 D: serde::Deserializer<'de>,
1497 {
1498 const FIELDS: &[&str] = &[
1499 "task_id",
1500 "taskId",
1501 ];
1502
1503 #[allow(clippy::enum_variant_names)]
1504 enum GeneratedField {
1505 TaskId,
1506 }
1507 impl<'de> serde::Deserialize<'de> for GeneratedField {
1508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1509 where
1510 D: serde::Deserializer<'de>,
1511 {
1512 struct GeneratedVisitor;
1513
1514 impl serde::de::Visitor<'_> for GeneratedVisitor {
1515 type Value = GeneratedField;
1516
1517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1518 write!(formatter, "expected one of: {:?}", &FIELDS)
1519 }
1520
1521 #[allow(unused_variables)]
1522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1523 where
1524 E: serde::de::Error,
1525 {
1526 match value {
1527 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1528 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1529 }
1530 }
1531 }
1532 deserializer.deserialize_identifier(GeneratedVisitor)
1533 }
1534 }
1535 struct GeneratedVisitor;
1536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1537 type Value = GetTaskInfoRequest;
1538
1539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1540 formatter.write_str("struct task_service.GetTaskInfoRequest")
1541 }
1542
1543 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTaskInfoRequest, V::Error>
1544 where
1545 V: serde::de::MapAccess<'de>,
1546 {
1547 let mut task_id__ = None;
1548 while let Some(k) = map_.next_key()? {
1549 match k {
1550 GeneratedField::TaskId => {
1551 if task_id__.is_some() {
1552 return Err(serde::de::Error::duplicate_field("taskId"));
1553 }
1554 task_id__ = map_.next_value()?;
1555 }
1556 }
1557 }
1558 Ok(GetTaskInfoRequest {
1559 task_id: task_id__,
1560 })
1561 }
1562 }
1563 deserializer.deserialize_struct("task_service.GetTaskInfoRequest", FIELDS, GeneratedVisitor)
1564 }
1565}
1566impl serde::Serialize for Permits {
1567 #[allow(deprecated)]
1568 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1569 where
1570 S: serde::Serializer,
1571 {
1572 use serde::ser::SerializeStruct;
1573 let mut len = 0;
1574 if self.value.is_some() {
1575 len += 1;
1576 }
1577 let mut struct_ser = serializer.serialize_struct("task_service.Permits", len)?;
1578 if let Some(v) = self.value.as_ref() {
1579 match v {
1580 permits::Value::Record(v) => {
1581 struct_ser.serialize_field("record", v)?;
1582 }
1583 permits::Value::Barrier(v) => {
1584 struct_ser.serialize_field("barrier", v)?;
1585 }
1586 }
1587 }
1588 struct_ser.end()
1589 }
1590}
1591impl<'de> serde::Deserialize<'de> for Permits {
1592 #[allow(deprecated)]
1593 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1594 where
1595 D: serde::Deserializer<'de>,
1596 {
1597 const FIELDS: &[&str] = &[
1598 "record",
1599 "barrier",
1600 ];
1601
1602 #[allow(clippy::enum_variant_names)]
1603 enum GeneratedField {
1604 Record,
1605 Barrier,
1606 }
1607 impl<'de> serde::Deserialize<'de> for GeneratedField {
1608 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1609 where
1610 D: serde::Deserializer<'de>,
1611 {
1612 struct GeneratedVisitor;
1613
1614 impl serde::de::Visitor<'_> for GeneratedVisitor {
1615 type Value = GeneratedField;
1616
1617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1618 write!(formatter, "expected one of: {:?}", &FIELDS)
1619 }
1620
1621 #[allow(unused_variables)]
1622 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1623 where
1624 E: serde::de::Error,
1625 {
1626 match value {
1627 "record" => Ok(GeneratedField::Record),
1628 "barrier" => Ok(GeneratedField::Barrier),
1629 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1630 }
1631 }
1632 }
1633 deserializer.deserialize_identifier(GeneratedVisitor)
1634 }
1635 }
1636 struct GeneratedVisitor;
1637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1638 type Value = Permits;
1639
1640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1641 formatter.write_str("struct task_service.Permits")
1642 }
1643
1644 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Permits, V::Error>
1645 where
1646 V: serde::de::MapAccess<'de>,
1647 {
1648 let mut value__ = None;
1649 while let Some(k) = map_.next_key()? {
1650 match k {
1651 GeneratedField::Record => {
1652 if value__.is_some() {
1653 return Err(serde::de::Error::duplicate_field("record"));
1654 }
1655 value__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| permits::Value::Record(x.0));
1656 }
1657 GeneratedField::Barrier => {
1658 if value__.is_some() {
1659 return Err(serde::de::Error::duplicate_field("barrier"));
1660 }
1661 value__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| permits::Value::Barrier(x.0));
1662 }
1663 }
1664 }
1665 Ok(Permits {
1666 value: value__,
1667 })
1668 }
1669 }
1670 deserializer.deserialize_struct("task_service.Permits", FIELDS, GeneratedVisitor)
1671 }
1672}
1673impl serde::Serialize for TaskId {
1674 #[allow(deprecated)]
1675 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1676 where
1677 S: serde::Serializer,
1678 {
1679 use serde::ser::SerializeStruct;
1680 let mut len = 0;
1681 if !self.query_id.is_empty() {
1682 len += 1;
1683 }
1684 if self.stage_id != 0 {
1685 len += 1;
1686 }
1687 if self.task_id != 0 {
1688 len += 1;
1689 }
1690 let mut struct_ser = serializer.serialize_struct("task_service.TaskId", len)?;
1691 if !self.query_id.is_empty() {
1692 struct_ser.serialize_field("queryId", &self.query_id)?;
1693 }
1694 if self.stage_id != 0 {
1695 struct_ser.serialize_field("stageId", &self.stage_id)?;
1696 }
1697 if self.task_id != 0 {
1698 struct_ser.serialize_field("taskId", &self.task_id)?;
1699 }
1700 struct_ser.end()
1701 }
1702}
1703impl<'de> serde::Deserialize<'de> for TaskId {
1704 #[allow(deprecated)]
1705 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1706 where
1707 D: serde::Deserializer<'de>,
1708 {
1709 const FIELDS: &[&str] = &[
1710 "query_id",
1711 "queryId",
1712 "stage_id",
1713 "stageId",
1714 "task_id",
1715 "taskId",
1716 ];
1717
1718 #[allow(clippy::enum_variant_names)]
1719 enum GeneratedField {
1720 QueryId,
1721 StageId,
1722 TaskId,
1723 }
1724 impl<'de> serde::Deserialize<'de> for GeneratedField {
1725 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1726 where
1727 D: serde::Deserializer<'de>,
1728 {
1729 struct GeneratedVisitor;
1730
1731 impl serde::de::Visitor<'_> for GeneratedVisitor {
1732 type Value = GeneratedField;
1733
1734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1735 write!(formatter, "expected one of: {:?}", &FIELDS)
1736 }
1737
1738 #[allow(unused_variables)]
1739 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1740 where
1741 E: serde::de::Error,
1742 {
1743 match value {
1744 "queryId" | "query_id" => Ok(GeneratedField::QueryId),
1745 "stageId" | "stage_id" => Ok(GeneratedField::StageId),
1746 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1747 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1748 }
1749 }
1750 }
1751 deserializer.deserialize_identifier(GeneratedVisitor)
1752 }
1753 }
1754 struct GeneratedVisitor;
1755 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1756 type Value = TaskId;
1757
1758 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1759 formatter.write_str("struct task_service.TaskId")
1760 }
1761
1762 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
1763 where
1764 V: serde::de::MapAccess<'de>,
1765 {
1766 let mut query_id__ = None;
1767 let mut stage_id__ = None;
1768 let mut task_id__ = None;
1769 while let Some(k) = map_.next_key()? {
1770 match k {
1771 GeneratedField::QueryId => {
1772 if query_id__.is_some() {
1773 return Err(serde::de::Error::duplicate_field("queryId"));
1774 }
1775 query_id__ = Some(map_.next_value()?);
1776 }
1777 GeneratedField::StageId => {
1778 if stage_id__.is_some() {
1779 return Err(serde::de::Error::duplicate_field("stageId"));
1780 }
1781 stage_id__ =
1782 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1783 ;
1784 }
1785 GeneratedField::TaskId => {
1786 if task_id__.is_some() {
1787 return Err(serde::de::Error::duplicate_field("taskId"));
1788 }
1789 task_id__ =
1790 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1791 ;
1792 }
1793 }
1794 }
1795 Ok(TaskId {
1796 query_id: query_id__.unwrap_or_default(),
1797 stage_id: stage_id__.unwrap_or_default(),
1798 task_id: task_id__.unwrap_or_default(),
1799 })
1800 }
1801 }
1802 deserializer.deserialize_struct("task_service.TaskId", FIELDS, GeneratedVisitor)
1803 }
1804}
1805impl serde::Serialize for TaskInfoResponse {
1806 #[allow(deprecated)]
1807 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1808 where
1809 S: serde::Serializer,
1810 {
1811 use serde::ser::SerializeStruct;
1812 let mut len = 0;
1813 if self.task_id.is_some() {
1814 len += 1;
1815 }
1816 if self.task_status != 0 {
1817 len += 1;
1818 }
1819 if !self.error_message.is_empty() {
1820 len += 1;
1821 }
1822 let mut struct_ser = serializer.serialize_struct("task_service.TaskInfoResponse", len)?;
1823 if let Some(v) = self.task_id.as_ref() {
1824 struct_ser.serialize_field("taskId", v)?;
1825 }
1826 if self.task_status != 0 {
1827 let v = task_info_response::TaskStatus::try_from(self.task_status)
1828 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
1829 struct_ser.serialize_field("taskStatus", &v)?;
1830 }
1831 if !self.error_message.is_empty() {
1832 struct_ser.serialize_field("errorMessage", &self.error_message)?;
1833 }
1834 struct_ser.end()
1835 }
1836}
1837impl<'de> serde::Deserialize<'de> for TaskInfoResponse {
1838 #[allow(deprecated)]
1839 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1840 where
1841 D: serde::Deserializer<'de>,
1842 {
1843 const FIELDS: &[&str] = &[
1844 "task_id",
1845 "taskId",
1846 "task_status",
1847 "taskStatus",
1848 "error_message",
1849 "errorMessage",
1850 ];
1851
1852 #[allow(clippy::enum_variant_names)]
1853 enum GeneratedField {
1854 TaskId,
1855 TaskStatus,
1856 ErrorMessage,
1857 }
1858 impl<'de> serde::Deserialize<'de> for GeneratedField {
1859 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1860 where
1861 D: serde::Deserializer<'de>,
1862 {
1863 struct GeneratedVisitor;
1864
1865 impl serde::de::Visitor<'_> for GeneratedVisitor {
1866 type Value = GeneratedField;
1867
1868 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1869 write!(formatter, "expected one of: {:?}", &FIELDS)
1870 }
1871
1872 #[allow(unused_variables)]
1873 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1874 where
1875 E: serde::de::Error,
1876 {
1877 match value {
1878 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1879 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
1880 "errorMessage" | "error_message" => Ok(GeneratedField::ErrorMessage),
1881 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1882 }
1883 }
1884 }
1885 deserializer.deserialize_identifier(GeneratedVisitor)
1886 }
1887 }
1888 struct GeneratedVisitor;
1889 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1890 type Value = TaskInfoResponse;
1891
1892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1893 formatter.write_str("struct task_service.TaskInfoResponse")
1894 }
1895
1896 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskInfoResponse, V::Error>
1897 where
1898 V: serde::de::MapAccess<'de>,
1899 {
1900 let mut task_id__ = None;
1901 let mut task_status__ = None;
1902 let mut error_message__ = None;
1903 while let Some(k) = map_.next_key()? {
1904 match k {
1905 GeneratedField::TaskId => {
1906 if task_id__.is_some() {
1907 return Err(serde::de::Error::duplicate_field("taskId"));
1908 }
1909 task_id__ = map_.next_value()?;
1910 }
1911 GeneratedField::TaskStatus => {
1912 if task_status__.is_some() {
1913 return Err(serde::de::Error::duplicate_field("taskStatus"));
1914 }
1915 task_status__ = Some(map_.next_value::<task_info_response::TaskStatus>()? as i32);
1916 }
1917 GeneratedField::ErrorMessage => {
1918 if error_message__.is_some() {
1919 return Err(serde::de::Error::duplicate_field("errorMessage"));
1920 }
1921 error_message__ = Some(map_.next_value()?);
1922 }
1923 }
1924 }
1925 Ok(TaskInfoResponse {
1926 task_id: task_id__,
1927 task_status: task_status__.unwrap_or_default(),
1928 error_message: error_message__.unwrap_or_default(),
1929 })
1930 }
1931 }
1932 deserializer.deserialize_struct("task_service.TaskInfoResponse", FIELDS, GeneratedVisitor)
1933 }
1934}
1935impl serde::Serialize for task_info_response::TaskStatus {
1936 #[allow(deprecated)]
1937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1938 where
1939 S: serde::Serializer,
1940 {
1941 let variant = match self {
1942 Self::Unspecified => "UNSPECIFIED",
1943 Self::Pending => "PENDING",
1944 Self::Running => "RUNNING",
1945 Self::Finished => "FINISHED",
1946 Self::Failed => "FAILED",
1947 Self::Aborted => "ABORTED",
1948 Self::Cancelled => "CANCELLED",
1949 Self::Ping => "PING",
1950 };
1951 serializer.serialize_str(variant)
1952 }
1953}
1954impl<'de> serde::Deserialize<'de> for task_info_response::TaskStatus {
1955 #[allow(deprecated)]
1956 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1957 where
1958 D: serde::Deserializer<'de>,
1959 {
1960 const FIELDS: &[&str] = &[
1961 "UNSPECIFIED",
1962 "PENDING",
1963 "RUNNING",
1964 "FINISHED",
1965 "FAILED",
1966 "ABORTED",
1967 "CANCELLED",
1968 "PING",
1969 ];
1970
1971 struct GeneratedVisitor;
1972
1973 impl serde::de::Visitor<'_> for GeneratedVisitor {
1974 type Value = task_info_response::TaskStatus;
1975
1976 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1977 write!(formatter, "expected one of: {:?}", &FIELDS)
1978 }
1979
1980 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1981 where
1982 E: serde::de::Error,
1983 {
1984 i32::try_from(v)
1985 .ok()
1986 .and_then(|x| x.try_into().ok())
1987 .ok_or_else(|| {
1988 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1989 })
1990 }
1991
1992 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1993 where
1994 E: serde::de::Error,
1995 {
1996 i32::try_from(v)
1997 .ok()
1998 .and_then(|x| x.try_into().ok())
1999 .ok_or_else(|| {
2000 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2001 })
2002 }
2003
2004 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2005 where
2006 E: serde::de::Error,
2007 {
2008 match value {
2009 "UNSPECIFIED" => Ok(task_info_response::TaskStatus::Unspecified),
2010 "PENDING" => Ok(task_info_response::TaskStatus::Pending),
2011 "RUNNING" => Ok(task_info_response::TaskStatus::Running),
2012 "FINISHED" => Ok(task_info_response::TaskStatus::Finished),
2013 "FAILED" => Ok(task_info_response::TaskStatus::Failed),
2014 "ABORTED" => Ok(task_info_response::TaskStatus::Aborted),
2015 "CANCELLED" => Ok(task_info_response::TaskStatus::Cancelled),
2016 "PING" => Ok(task_info_response::TaskStatus::Ping),
2017 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2018 }
2019 }
2020 }
2021 deserializer.deserialize_any(GeneratedVisitor)
2022 }
2023}