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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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.database_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.database_id != 0 {
1212 struct_ser.serialize_field("databaseId", &self.database_id)?;
1213 }
1214 if !self.term_id.is_empty() {
1215 struct_ser.serialize_field("termId", &self.term_id)?;
1216 }
1217 struct_ser.end()
1218 }
1219}
1220impl<'de> serde::Deserialize<'de> for get_stream_request::Get {
1221 #[allow(deprecated)]
1222 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1223 where
1224 D: serde::Deserializer<'de>,
1225 {
1226 const FIELDS: &[&str] = &[
1227 "up_actor_id",
1228 "upActorId",
1229 "down_actor_id",
1230 "downActorId",
1231 "up_fragment_id",
1232 "upFragmentId",
1233 "down_fragment_id",
1234 "downFragmentId",
1235 "database_id",
1236 "databaseId",
1237 "term_id",
1238 "termId",
1239 ];
1240
1241 #[allow(clippy::enum_variant_names)]
1242 enum GeneratedField {
1243 UpActorId,
1244 DownActorId,
1245 UpFragmentId,
1246 DownFragmentId,
1247 DatabaseId,
1248 TermId,
1249 }
1250 impl<'de> serde::Deserialize<'de> for GeneratedField {
1251 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1252 where
1253 D: serde::Deserializer<'de>,
1254 {
1255 struct GeneratedVisitor;
1256
1257 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1258 type Value = GeneratedField;
1259
1260 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1261 write!(formatter, "expected one of: {:?}", &FIELDS)
1262 }
1263
1264 #[allow(unused_variables)]
1265 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1266 where
1267 E: serde::de::Error,
1268 {
1269 match value {
1270 "upActorId" | "up_actor_id" => Ok(GeneratedField::UpActorId),
1271 "downActorId" | "down_actor_id" => Ok(GeneratedField::DownActorId),
1272 "upFragmentId" | "up_fragment_id" => Ok(GeneratedField::UpFragmentId),
1273 "downFragmentId" | "down_fragment_id" => Ok(GeneratedField::DownFragmentId),
1274 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1275 "termId" | "term_id" => Ok(GeneratedField::TermId),
1276 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1277 }
1278 }
1279 }
1280 deserializer.deserialize_identifier(GeneratedVisitor)
1281 }
1282 }
1283 struct GeneratedVisitor;
1284 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1285 type Value = get_stream_request::Get;
1286
1287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1288 formatter.write_str("struct task_service.GetStreamRequest.Get")
1289 }
1290
1291 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_stream_request::Get, V::Error>
1292 where
1293 V: serde::de::MapAccess<'de>,
1294 {
1295 let mut up_actor_id__ = None;
1296 let mut down_actor_id__ = None;
1297 let mut up_fragment_id__ = None;
1298 let mut down_fragment_id__ = None;
1299 let mut database_id__ = None;
1300 let mut term_id__ = None;
1301 while let Some(k) = map_.next_key()? {
1302 match k {
1303 GeneratedField::UpActorId => {
1304 if up_actor_id__.is_some() {
1305 return Err(serde::de::Error::duplicate_field("upActorId"));
1306 }
1307 up_actor_id__ =
1308 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1309 ;
1310 }
1311 GeneratedField::DownActorId => {
1312 if down_actor_id__.is_some() {
1313 return Err(serde::de::Error::duplicate_field("downActorId"));
1314 }
1315 down_actor_id__ =
1316 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1317 ;
1318 }
1319 GeneratedField::UpFragmentId => {
1320 if up_fragment_id__.is_some() {
1321 return Err(serde::de::Error::duplicate_field("upFragmentId"));
1322 }
1323 up_fragment_id__ =
1324 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1325 ;
1326 }
1327 GeneratedField::DownFragmentId => {
1328 if down_fragment_id__.is_some() {
1329 return Err(serde::de::Error::duplicate_field("downFragmentId"));
1330 }
1331 down_fragment_id__ =
1332 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1333 ;
1334 }
1335 GeneratedField::DatabaseId => {
1336 if database_id__.is_some() {
1337 return Err(serde::de::Error::duplicate_field("databaseId"));
1338 }
1339 database_id__ =
1340 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1341 ;
1342 }
1343 GeneratedField::TermId => {
1344 if term_id__.is_some() {
1345 return Err(serde::de::Error::duplicate_field("termId"));
1346 }
1347 term_id__ = Some(map_.next_value()?);
1348 }
1349 }
1350 }
1351 Ok(get_stream_request::Get {
1352 up_actor_id: up_actor_id__.unwrap_or_default(),
1353 down_actor_id: down_actor_id__.unwrap_or_default(),
1354 up_fragment_id: up_fragment_id__.unwrap_or_default(),
1355 down_fragment_id: down_fragment_id__.unwrap_or_default(),
1356 database_id: database_id__.unwrap_or_default(),
1357 term_id: term_id__.unwrap_or_default(),
1358 })
1359 }
1360 }
1361 deserializer.deserialize_struct("task_service.GetStreamRequest.Get", FIELDS, GeneratedVisitor)
1362 }
1363}
1364impl serde::Serialize for GetStreamResponse {
1365 #[allow(deprecated)]
1366 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1367 where
1368 S: serde::Serializer,
1369 {
1370 use serde::ser::SerializeStruct;
1371 let mut len = 0;
1372 if self.message.is_some() {
1373 len += 1;
1374 }
1375 if self.permits.is_some() {
1376 len += 1;
1377 }
1378 let mut struct_ser = serializer.serialize_struct("task_service.GetStreamResponse", len)?;
1379 if let Some(v) = self.message.as_ref() {
1380 struct_ser.serialize_field("message", v)?;
1381 }
1382 if let Some(v) = self.permits.as_ref() {
1383 struct_ser.serialize_field("permits", v)?;
1384 }
1385 struct_ser.end()
1386 }
1387}
1388impl<'de> serde::Deserialize<'de> for GetStreamResponse {
1389 #[allow(deprecated)]
1390 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1391 where
1392 D: serde::Deserializer<'de>,
1393 {
1394 const FIELDS: &[&str] = &[
1395 "message",
1396 "permits",
1397 ];
1398
1399 #[allow(clippy::enum_variant_names)]
1400 enum GeneratedField {
1401 Message,
1402 Permits,
1403 }
1404 impl<'de> serde::Deserialize<'de> for GeneratedField {
1405 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1406 where
1407 D: serde::Deserializer<'de>,
1408 {
1409 struct GeneratedVisitor;
1410
1411 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1412 type Value = GeneratedField;
1413
1414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1415 write!(formatter, "expected one of: {:?}", &FIELDS)
1416 }
1417
1418 #[allow(unused_variables)]
1419 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1420 where
1421 E: serde::de::Error,
1422 {
1423 match value {
1424 "message" => Ok(GeneratedField::Message),
1425 "permits" => Ok(GeneratedField::Permits),
1426 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1427 }
1428 }
1429 }
1430 deserializer.deserialize_identifier(GeneratedVisitor)
1431 }
1432 }
1433 struct GeneratedVisitor;
1434 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1435 type Value = GetStreamResponse;
1436
1437 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1438 formatter.write_str("struct task_service.GetStreamResponse")
1439 }
1440
1441 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamResponse, V::Error>
1442 where
1443 V: serde::de::MapAccess<'de>,
1444 {
1445 let mut message__ = None;
1446 let mut permits__ = None;
1447 while let Some(k) = map_.next_key()? {
1448 match k {
1449 GeneratedField::Message => {
1450 if message__.is_some() {
1451 return Err(serde::de::Error::duplicate_field("message"));
1452 }
1453 message__ = map_.next_value()?;
1454 }
1455 GeneratedField::Permits => {
1456 if permits__.is_some() {
1457 return Err(serde::de::Error::duplicate_field("permits"));
1458 }
1459 permits__ = map_.next_value()?;
1460 }
1461 }
1462 }
1463 Ok(GetStreamResponse {
1464 message: message__,
1465 permits: permits__,
1466 })
1467 }
1468 }
1469 deserializer.deserialize_struct("task_service.GetStreamResponse", FIELDS, GeneratedVisitor)
1470 }
1471}
1472impl serde::Serialize for GetTaskInfoRequest {
1473 #[allow(deprecated)]
1474 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1475 where
1476 S: serde::Serializer,
1477 {
1478 use serde::ser::SerializeStruct;
1479 let mut len = 0;
1480 if self.task_id.is_some() {
1481 len += 1;
1482 }
1483 let mut struct_ser = serializer.serialize_struct("task_service.GetTaskInfoRequest", len)?;
1484 if let Some(v) = self.task_id.as_ref() {
1485 struct_ser.serialize_field("taskId", v)?;
1486 }
1487 struct_ser.end()
1488 }
1489}
1490impl<'de> serde::Deserialize<'de> for GetTaskInfoRequest {
1491 #[allow(deprecated)]
1492 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1493 where
1494 D: serde::Deserializer<'de>,
1495 {
1496 const FIELDS: &[&str] = &[
1497 "task_id",
1498 "taskId",
1499 ];
1500
1501 #[allow(clippy::enum_variant_names)]
1502 enum GeneratedField {
1503 TaskId,
1504 }
1505 impl<'de> serde::Deserialize<'de> for GeneratedField {
1506 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1507 where
1508 D: serde::Deserializer<'de>,
1509 {
1510 struct GeneratedVisitor;
1511
1512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1513 type Value = GeneratedField;
1514
1515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1516 write!(formatter, "expected one of: {:?}", &FIELDS)
1517 }
1518
1519 #[allow(unused_variables)]
1520 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1521 where
1522 E: serde::de::Error,
1523 {
1524 match value {
1525 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1526 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1527 }
1528 }
1529 }
1530 deserializer.deserialize_identifier(GeneratedVisitor)
1531 }
1532 }
1533 struct GeneratedVisitor;
1534 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1535 type Value = GetTaskInfoRequest;
1536
1537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1538 formatter.write_str("struct task_service.GetTaskInfoRequest")
1539 }
1540
1541 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTaskInfoRequest, V::Error>
1542 where
1543 V: serde::de::MapAccess<'de>,
1544 {
1545 let mut task_id__ = None;
1546 while let Some(k) = map_.next_key()? {
1547 match k {
1548 GeneratedField::TaskId => {
1549 if task_id__.is_some() {
1550 return Err(serde::de::Error::duplicate_field("taskId"));
1551 }
1552 task_id__ = map_.next_value()?;
1553 }
1554 }
1555 }
1556 Ok(GetTaskInfoRequest {
1557 task_id: task_id__,
1558 })
1559 }
1560 }
1561 deserializer.deserialize_struct("task_service.GetTaskInfoRequest", FIELDS, GeneratedVisitor)
1562 }
1563}
1564impl serde::Serialize for Permits {
1565 #[allow(deprecated)]
1566 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1567 where
1568 S: serde::Serializer,
1569 {
1570 use serde::ser::SerializeStruct;
1571 let mut len = 0;
1572 if self.value.is_some() {
1573 len += 1;
1574 }
1575 let mut struct_ser = serializer.serialize_struct("task_service.Permits", len)?;
1576 if let Some(v) = self.value.as_ref() {
1577 match v {
1578 permits::Value::Record(v) => {
1579 struct_ser.serialize_field("record", v)?;
1580 }
1581 permits::Value::Barrier(v) => {
1582 struct_ser.serialize_field("barrier", v)?;
1583 }
1584 }
1585 }
1586 struct_ser.end()
1587 }
1588}
1589impl<'de> serde::Deserialize<'de> for Permits {
1590 #[allow(deprecated)]
1591 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1592 where
1593 D: serde::Deserializer<'de>,
1594 {
1595 const FIELDS: &[&str] = &[
1596 "record",
1597 "barrier",
1598 ];
1599
1600 #[allow(clippy::enum_variant_names)]
1601 enum GeneratedField {
1602 Record,
1603 Barrier,
1604 }
1605 impl<'de> serde::Deserialize<'de> for GeneratedField {
1606 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1607 where
1608 D: serde::Deserializer<'de>,
1609 {
1610 struct GeneratedVisitor;
1611
1612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1613 type Value = GeneratedField;
1614
1615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1616 write!(formatter, "expected one of: {:?}", &FIELDS)
1617 }
1618
1619 #[allow(unused_variables)]
1620 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1621 where
1622 E: serde::de::Error,
1623 {
1624 match value {
1625 "record" => Ok(GeneratedField::Record),
1626 "barrier" => Ok(GeneratedField::Barrier),
1627 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1628 }
1629 }
1630 }
1631 deserializer.deserialize_identifier(GeneratedVisitor)
1632 }
1633 }
1634 struct GeneratedVisitor;
1635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1636 type Value = Permits;
1637
1638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1639 formatter.write_str("struct task_service.Permits")
1640 }
1641
1642 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Permits, V::Error>
1643 where
1644 V: serde::de::MapAccess<'de>,
1645 {
1646 let mut value__ = None;
1647 while let Some(k) = map_.next_key()? {
1648 match k {
1649 GeneratedField::Record => {
1650 if value__.is_some() {
1651 return Err(serde::de::Error::duplicate_field("record"));
1652 }
1653 value__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| permits::Value::Record(x.0));
1654 }
1655 GeneratedField::Barrier => {
1656 if value__.is_some() {
1657 return Err(serde::de::Error::duplicate_field("barrier"));
1658 }
1659 value__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| permits::Value::Barrier(x.0));
1660 }
1661 }
1662 }
1663 Ok(Permits {
1664 value: value__,
1665 })
1666 }
1667 }
1668 deserializer.deserialize_struct("task_service.Permits", FIELDS, GeneratedVisitor)
1669 }
1670}
1671impl serde::Serialize for TaskId {
1672 #[allow(deprecated)]
1673 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1674 where
1675 S: serde::Serializer,
1676 {
1677 use serde::ser::SerializeStruct;
1678 let mut len = 0;
1679 if !self.query_id.is_empty() {
1680 len += 1;
1681 }
1682 if self.stage_id != 0 {
1683 len += 1;
1684 }
1685 if self.task_id != 0 {
1686 len += 1;
1687 }
1688 let mut struct_ser = serializer.serialize_struct("task_service.TaskId", len)?;
1689 if !self.query_id.is_empty() {
1690 struct_ser.serialize_field("queryId", &self.query_id)?;
1691 }
1692 if self.stage_id != 0 {
1693 struct_ser.serialize_field("stageId", &self.stage_id)?;
1694 }
1695 if self.task_id != 0 {
1696 struct_ser.serialize_field("taskId", &self.task_id)?;
1697 }
1698 struct_ser.end()
1699 }
1700}
1701impl<'de> serde::Deserialize<'de> for TaskId {
1702 #[allow(deprecated)]
1703 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1704 where
1705 D: serde::Deserializer<'de>,
1706 {
1707 const FIELDS: &[&str] = &[
1708 "query_id",
1709 "queryId",
1710 "stage_id",
1711 "stageId",
1712 "task_id",
1713 "taskId",
1714 ];
1715
1716 #[allow(clippy::enum_variant_names)]
1717 enum GeneratedField {
1718 QueryId,
1719 StageId,
1720 TaskId,
1721 }
1722 impl<'de> serde::Deserialize<'de> for GeneratedField {
1723 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1724 where
1725 D: serde::Deserializer<'de>,
1726 {
1727 struct GeneratedVisitor;
1728
1729 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1730 type Value = GeneratedField;
1731
1732 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1733 write!(formatter, "expected one of: {:?}", &FIELDS)
1734 }
1735
1736 #[allow(unused_variables)]
1737 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1738 where
1739 E: serde::de::Error,
1740 {
1741 match value {
1742 "queryId" | "query_id" => Ok(GeneratedField::QueryId),
1743 "stageId" | "stage_id" => Ok(GeneratedField::StageId),
1744 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1745 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1746 }
1747 }
1748 }
1749 deserializer.deserialize_identifier(GeneratedVisitor)
1750 }
1751 }
1752 struct GeneratedVisitor;
1753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1754 type Value = TaskId;
1755
1756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1757 formatter.write_str("struct task_service.TaskId")
1758 }
1759
1760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
1761 where
1762 V: serde::de::MapAccess<'de>,
1763 {
1764 let mut query_id__ = None;
1765 let mut stage_id__ = None;
1766 let mut task_id__ = None;
1767 while let Some(k) = map_.next_key()? {
1768 match k {
1769 GeneratedField::QueryId => {
1770 if query_id__.is_some() {
1771 return Err(serde::de::Error::duplicate_field("queryId"));
1772 }
1773 query_id__ = Some(map_.next_value()?);
1774 }
1775 GeneratedField::StageId => {
1776 if stage_id__.is_some() {
1777 return Err(serde::de::Error::duplicate_field("stageId"));
1778 }
1779 stage_id__ =
1780 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1781 ;
1782 }
1783 GeneratedField::TaskId => {
1784 if task_id__.is_some() {
1785 return Err(serde::de::Error::duplicate_field("taskId"));
1786 }
1787 task_id__ =
1788 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1789 ;
1790 }
1791 }
1792 }
1793 Ok(TaskId {
1794 query_id: query_id__.unwrap_or_default(),
1795 stage_id: stage_id__.unwrap_or_default(),
1796 task_id: task_id__.unwrap_or_default(),
1797 })
1798 }
1799 }
1800 deserializer.deserialize_struct("task_service.TaskId", FIELDS, GeneratedVisitor)
1801 }
1802}
1803impl serde::Serialize for TaskInfoResponse {
1804 #[allow(deprecated)]
1805 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1806 where
1807 S: serde::Serializer,
1808 {
1809 use serde::ser::SerializeStruct;
1810 let mut len = 0;
1811 if self.task_id.is_some() {
1812 len += 1;
1813 }
1814 if self.task_status != 0 {
1815 len += 1;
1816 }
1817 if !self.error_message.is_empty() {
1818 len += 1;
1819 }
1820 let mut struct_ser = serializer.serialize_struct("task_service.TaskInfoResponse", len)?;
1821 if let Some(v) = self.task_id.as_ref() {
1822 struct_ser.serialize_field("taskId", v)?;
1823 }
1824 if self.task_status != 0 {
1825 let v = task_info_response::TaskStatus::try_from(self.task_status)
1826 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
1827 struct_ser.serialize_field("taskStatus", &v)?;
1828 }
1829 if !self.error_message.is_empty() {
1830 struct_ser.serialize_field("errorMessage", &self.error_message)?;
1831 }
1832 struct_ser.end()
1833 }
1834}
1835impl<'de> serde::Deserialize<'de> for TaskInfoResponse {
1836 #[allow(deprecated)]
1837 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1838 where
1839 D: serde::Deserializer<'de>,
1840 {
1841 const FIELDS: &[&str] = &[
1842 "task_id",
1843 "taskId",
1844 "task_status",
1845 "taskStatus",
1846 "error_message",
1847 "errorMessage",
1848 ];
1849
1850 #[allow(clippy::enum_variant_names)]
1851 enum GeneratedField {
1852 TaskId,
1853 TaskStatus,
1854 ErrorMessage,
1855 }
1856 impl<'de> serde::Deserialize<'de> for GeneratedField {
1857 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1858 where
1859 D: serde::Deserializer<'de>,
1860 {
1861 struct GeneratedVisitor;
1862
1863 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1864 type Value = GeneratedField;
1865
1866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1867 write!(formatter, "expected one of: {:?}", &FIELDS)
1868 }
1869
1870 #[allow(unused_variables)]
1871 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1872 where
1873 E: serde::de::Error,
1874 {
1875 match value {
1876 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1877 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
1878 "errorMessage" | "error_message" => Ok(GeneratedField::ErrorMessage),
1879 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1880 }
1881 }
1882 }
1883 deserializer.deserialize_identifier(GeneratedVisitor)
1884 }
1885 }
1886 struct GeneratedVisitor;
1887 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1888 type Value = TaskInfoResponse;
1889
1890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1891 formatter.write_str("struct task_service.TaskInfoResponse")
1892 }
1893
1894 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskInfoResponse, V::Error>
1895 where
1896 V: serde::de::MapAccess<'de>,
1897 {
1898 let mut task_id__ = None;
1899 let mut task_status__ = None;
1900 let mut error_message__ = None;
1901 while let Some(k) = map_.next_key()? {
1902 match k {
1903 GeneratedField::TaskId => {
1904 if task_id__.is_some() {
1905 return Err(serde::de::Error::duplicate_field("taskId"));
1906 }
1907 task_id__ = map_.next_value()?;
1908 }
1909 GeneratedField::TaskStatus => {
1910 if task_status__.is_some() {
1911 return Err(serde::de::Error::duplicate_field("taskStatus"));
1912 }
1913 task_status__ = Some(map_.next_value::<task_info_response::TaskStatus>()? as i32);
1914 }
1915 GeneratedField::ErrorMessage => {
1916 if error_message__.is_some() {
1917 return Err(serde::de::Error::duplicate_field("errorMessage"));
1918 }
1919 error_message__ = Some(map_.next_value()?);
1920 }
1921 }
1922 }
1923 Ok(TaskInfoResponse {
1924 task_id: task_id__,
1925 task_status: task_status__.unwrap_or_default(),
1926 error_message: error_message__.unwrap_or_default(),
1927 })
1928 }
1929 }
1930 deserializer.deserialize_struct("task_service.TaskInfoResponse", FIELDS, GeneratedVisitor)
1931 }
1932}
1933impl serde::Serialize for task_info_response::TaskStatus {
1934 #[allow(deprecated)]
1935 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1936 where
1937 S: serde::Serializer,
1938 {
1939 let variant = match self {
1940 Self::Unspecified => "UNSPECIFIED",
1941 Self::Pending => "PENDING",
1942 Self::Running => "RUNNING",
1943 Self::Finished => "FINISHED",
1944 Self::Failed => "FAILED",
1945 Self::Aborted => "ABORTED",
1946 Self::Cancelled => "CANCELLED",
1947 Self::Ping => "PING",
1948 };
1949 serializer.serialize_str(variant)
1950 }
1951}
1952impl<'de> serde::Deserialize<'de> for task_info_response::TaskStatus {
1953 #[allow(deprecated)]
1954 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1955 where
1956 D: serde::Deserializer<'de>,
1957 {
1958 const FIELDS: &[&str] = &[
1959 "UNSPECIFIED",
1960 "PENDING",
1961 "RUNNING",
1962 "FINISHED",
1963 "FAILED",
1964 "ABORTED",
1965 "CANCELLED",
1966 "PING",
1967 ];
1968
1969 struct GeneratedVisitor;
1970
1971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1972 type Value = task_info_response::TaskStatus;
1973
1974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1975 write!(formatter, "expected one of: {:?}", &FIELDS)
1976 }
1977
1978 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1979 where
1980 E: serde::de::Error,
1981 {
1982 i32::try_from(v)
1983 .ok()
1984 .and_then(|x| x.try_into().ok())
1985 .ok_or_else(|| {
1986 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1987 })
1988 }
1989
1990 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1991 where
1992 E: serde::de::Error,
1993 {
1994 i32::try_from(v)
1995 .ok()
1996 .and_then(|x| x.try_into().ok())
1997 .ok_or_else(|| {
1998 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1999 })
2000 }
2001
2002 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2003 where
2004 E: serde::de::Error,
2005 {
2006 match value {
2007 "UNSPECIFIED" => Ok(task_info_response::TaskStatus::Unspecified),
2008 "PENDING" => Ok(task_info_response::TaskStatus::Pending),
2009 "RUNNING" => Ok(task_info_response::TaskStatus::Running),
2010 "FINISHED" => Ok(task_info_response::TaskStatus::Finished),
2011 "FAILED" => Ok(task_info_response::TaskStatus::Failed),
2012 "ABORTED" => Ok(task_info_response::TaskStatus::Aborted),
2013 "CANCELLED" => Ok(task_info_response::TaskStatus::Cancelled),
2014 "PING" => Ok(task_info_response::TaskStatus::Ping),
2015 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2016 }
2017 }
2018 }
2019 deserializer.deserialize_any(GeneratedVisitor)
2020 }
2021}