1use crate::common::*;
2impl serde::Serialize for ActorInfo {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let mut len = 0;
10 if self.actor_id != 0 {
11 len += 1;
12 }
13 if self.host.is_some() {
14 len += 1;
15 }
16 let mut struct_ser = serializer.serialize_struct("common.ActorInfo", len)?;
17 if self.actor_id != 0 {
18 struct_ser.serialize_field("actorId", &self.actor_id)?;
19 }
20 if let Some(v) = self.host.as_ref() {
21 struct_ser.serialize_field("host", v)?;
22 }
23 struct_ser.end()
24 }
25}
26impl<'de> serde::Deserialize<'de> for ActorInfo {
27 #[allow(deprecated)]
28 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
29 where
30 D: serde::Deserializer<'de>,
31 {
32 const FIELDS: &[&str] = &[
33 "actor_id",
34 "actorId",
35 "host",
36 ];
37
38 #[allow(clippy::enum_variant_names)]
39 enum GeneratedField {
40 ActorId,
41 Host,
42 }
43 impl<'de> serde::Deserialize<'de> for GeneratedField {
44 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
45 where
46 D: serde::Deserializer<'de>,
47 {
48 struct GeneratedVisitor;
49
50 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
51 type Value = GeneratedField;
52
53 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54 write!(formatter, "expected one of: {:?}", &FIELDS)
55 }
56
57 #[allow(unused_variables)]
58 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
59 where
60 E: serde::de::Error,
61 {
62 match value {
63 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
64 "host" => Ok(GeneratedField::Host),
65 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
66 }
67 }
68 }
69 deserializer.deserialize_identifier(GeneratedVisitor)
70 }
71 }
72 struct GeneratedVisitor;
73 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
74 type Value = ActorInfo;
75
76 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77 formatter.write_str("struct common.ActorInfo")
78 }
79
80 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorInfo, V::Error>
81 where
82 V: serde::de::MapAccess<'de>,
83 {
84 let mut actor_id__ = None;
85 let mut host__ = None;
86 while let Some(k) = map_.next_key()? {
87 match k {
88 GeneratedField::ActorId => {
89 if actor_id__.is_some() {
90 return Err(serde::de::Error::duplicate_field("actorId"));
91 }
92 actor_id__ =
93 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
94 ;
95 }
96 GeneratedField::Host => {
97 if host__.is_some() {
98 return Err(serde::de::Error::duplicate_field("host"));
99 }
100 host__ = map_.next_value()?;
101 }
102 }
103 }
104 Ok(ActorInfo {
105 actor_id: actor_id__.unwrap_or_default(),
106 host: host__,
107 })
108 }
109 }
110 deserializer.deserialize_struct("common.ActorInfo", FIELDS, GeneratedVisitor)
111 }
112}
113impl serde::Serialize for ActorLocation {
114 #[allow(deprecated)]
115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
116 where
117 S: serde::Serializer,
118 {
119 use serde::ser::SerializeStruct;
120 let mut len = 0;
121 if self.worker_node_id != 0 {
122 len += 1;
123 }
124 let mut struct_ser = serializer.serialize_struct("common.ActorLocation", len)?;
125 if self.worker_node_id != 0 {
126 struct_ser.serialize_field("workerNodeId", &self.worker_node_id)?;
127 }
128 struct_ser.end()
129 }
130}
131impl<'de> serde::Deserialize<'de> for ActorLocation {
132 #[allow(deprecated)]
133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
134 where
135 D: serde::Deserializer<'de>,
136 {
137 const FIELDS: &[&str] = &[
138 "worker_node_id",
139 "workerNodeId",
140 ];
141
142 #[allow(clippy::enum_variant_names)]
143 enum GeneratedField {
144 WorkerNodeId,
145 }
146 impl<'de> serde::Deserialize<'de> for GeneratedField {
147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
148 where
149 D: serde::Deserializer<'de>,
150 {
151 struct GeneratedVisitor;
152
153 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
154 type Value = GeneratedField;
155
156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
157 write!(formatter, "expected one of: {:?}", &FIELDS)
158 }
159
160 #[allow(unused_variables)]
161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
162 where
163 E: serde::de::Error,
164 {
165 match value {
166 "workerNodeId" | "worker_node_id" => Ok(GeneratedField::WorkerNodeId),
167 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
168 }
169 }
170 }
171 deserializer.deserialize_identifier(GeneratedVisitor)
172 }
173 }
174 struct GeneratedVisitor;
175 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
176 type Value = ActorLocation;
177
178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
179 formatter.write_str("struct common.ActorLocation")
180 }
181
182 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorLocation, V::Error>
183 where
184 V: serde::de::MapAccess<'de>,
185 {
186 let mut worker_node_id__ = None;
187 while let Some(k) = map_.next_key()? {
188 match k {
189 GeneratedField::WorkerNodeId => {
190 if worker_node_id__.is_some() {
191 return Err(serde::de::Error::duplicate_field("workerNodeId"));
192 }
193 worker_node_id__ =
194 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
195 ;
196 }
197 }
198 }
199 Ok(ActorLocation {
200 worker_node_id: worker_node_id__.unwrap_or_default(),
201 })
202 }
203 }
204 deserializer.deserialize_struct("common.ActorLocation", FIELDS, GeneratedVisitor)
205 }
206}
207impl serde::Serialize for BatchQueryCommittedEpoch {
208 #[allow(deprecated)]
209 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
210 where
211 S: serde::Serializer,
212 {
213 use serde::ser::SerializeStruct;
214 let mut len = 0;
215 if self.epoch != 0 {
216 len += 1;
217 }
218 if self.hummock_version_id != 0 {
219 len += 1;
220 }
221 let mut struct_ser = serializer.serialize_struct("common.BatchQueryCommittedEpoch", len)?;
222 if self.epoch != 0 {
223 #[allow(clippy::needless_borrow)]
224 #[allow(clippy::needless_borrows_for_generic_args)]
225 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
226 }
227 if self.hummock_version_id != 0 {
228 #[allow(clippy::needless_borrow)]
229 #[allow(clippy::needless_borrows_for_generic_args)]
230 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
231 }
232 struct_ser.end()
233 }
234}
235impl<'de> serde::Deserialize<'de> for BatchQueryCommittedEpoch {
236 #[allow(deprecated)]
237 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
238 where
239 D: serde::Deserializer<'de>,
240 {
241 const FIELDS: &[&str] = &[
242 "epoch",
243 "hummock_version_id",
244 "hummockVersionId",
245 ];
246
247 #[allow(clippy::enum_variant_names)]
248 enum GeneratedField {
249 Epoch,
250 HummockVersionId,
251 }
252 impl<'de> serde::Deserialize<'de> for GeneratedField {
253 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
254 where
255 D: serde::Deserializer<'de>,
256 {
257 struct GeneratedVisitor;
258
259 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
260 type Value = GeneratedField;
261
262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
263 write!(formatter, "expected one of: {:?}", &FIELDS)
264 }
265
266 #[allow(unused_variables)]
267 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
268 where
269 E: serde::de::Error,
270 {
271 match value {
272 "epoch" => Ok(GeneratedField::Epoch),
273 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
274 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
275 }
276 }
277 }
278 deserializer.deserialize_identifier(GeneratedVisitor)
279 }
280 }
281 struct GeneratedVisitor;
282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
283 type Value = BatchQueryCommittedEpoch;
284
285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
286 formatter.write_str("struct common.BatchQueryCommittedEpoch")
287 }
288
289 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchQueryCommittedEpoch, V::Error>
290 where
291 V: serde::de::MapAccess<'de>,
292 {
293 let mut epoch__ = None;
294 let mut hummock_version_id__ = None;
295 while let Some(k) = map_.next_key()? {
296 match k {
297 GeneratedField::Epoch => {
298 if epoch__.is_some() {
299 return Err(serde::de::Error::duplicate_field("epoch"));
300 }
301 epoch__ =
302 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
303 ;
304 }
305 GeneratedField::HummockVersionId => {
306 if hummock_version_id__.is_some() {
307 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
308 }
309 hummock_version_id__ =
310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
311 ;
312 }
313 }
314 }
315 Ok(BatchQueryCommittedEpoch {
316 epoch: epoch__.unwrap_or_default(),
317 hummock_version_id: hummock_version_id__.unwrap_or_default(),
318 })
319 }
320 }
321 deserializer.deserialize_struct("common.BatchQueryCommittedEpoch", FIELDS, GeneratedVisitor)
322 }
323}
324impl serde::Serialize for BatchQueryEpoch {
325 #[allow(deprecated)]
326 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
327 where
328 S: serde::Serializer,
329 {
330 use serde::ser::SerializeStruct;
331 let mut len = 0;
332 if self.epoch.is_some() {
333 len += 1;
334 }
335 let mut struct_ser = serializer.serialize_struct("common.BatchQueryEpoch", len)?;
336 if let Some(v) = self.epoch.as_ref() {
337 match v {
338 batch_query_epoch::Epoch::Committed(v) => {
339 struct_ser.serialize_field("committed", v)?;
340 }
341 batch_query_epoch::Epoch::Current(v) => {
342 #[allow(clippy::needless_borrow)]
343 #[allow(clippy::needless_borrows_for_generic_args)]
344 struct_ser.serialize_field("current", ToString::to_string(&v).as_str())?;
345 }
346 batch_query_epoch::Epoch::Backup(v) => {
347 #[allow(clippy::needless_borrow)]
348 #[allow(clippy::needless_borrows_for_generic_args)]
349 struct_ser.serialize_field("backup", ToString::to_string(&v).as_str())?;
350 }
351 batch_query_epoch::Epoch::TimeTravel(v) => {
352 #[allow(clippy::needless_borrow)]
353 #[allow(clippy::needless_borrows_for_generic_args)]
354 struct_ser.serialize_field("timeTravel", ToString::to_string(&v).as_str())?;
355 }
356 }
357 }
358 struct_ser.end()
359 }
360}
361impl<'de> serde::Deserialize<'de> for BatchQueryEpoch {
362 #[allow(deprecated)]
363 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
364 where
365 D: serde::Deserializer<'de>,
366 {
367 const FIELDS: &[&str] = &[
368 "committed",
369 "current",
370 "backup",
371 "time_travel",
372 "timeTravel",
373 ];
374
375 #[allow(clippy::enum_variant_names)]
376 enum GeneratedField {
377 Committed,
378 Current,
379 Backup,
380 TimeTravel,
381 }
382 impl<'de> serde::Deserialize<'de> for GeneratedField {
383 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
384 where
385 D: serde::Deserializer<'de>,
386 {
387 struct GeneratedVisitor;
388
389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
390 type Value = GeneratedField;
391
392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
393 write!(formatter, "expected one of: {:?}", &FIELDS)
394 }
395
396 #[allow(unused_variables)]
397 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
398 where
399 E: serde::de::Error,
400 {
401 match value {
402 "committed" => Ok(GeneratedField::Committed),
403 "current" => Ok(GeneratedField::Current),
404 "backup" => Ok(GeneratedField::Backup),
405 "timeTravel" | "time_travel" => Ok(GeneratedField::TimeTravel),
406 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
407 }
408 }
409 }
410 deserializer.deserialize_identifier(GeneratedVisitor)
411 }
412 }
413 struct GeneratedVisitor;
414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
415 type Value = BatchQueryEpoch;
416
417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
418 formatter.write_str("struct common.BatchQueryEpoch")
419 }
420
421 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchQueryEpoch, V::Error>
422 where
423 V: serde::de::MapAccess<'de>,
424 {
425 let mut epoch__ = None;
426 while let Some(k) = map_.next_key()? {
427 match k {
428 GeneratedField::Committed => {
429 if epoch__.is_some() {
430 return Err(serde::de::Error::duplicate_field("committed"));
431 }
432 epoch__ = map_.next_value::<::std::option::Option<_>>()?.map(batch_query_epoch::Epoch::Committed)
433;
434 }
435 GeneratedField::Current => {
436 if epoch__.is_some() {
437 return Err(serde::de::Error::duplicate_field("current"));
438 }
439 epoch__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| batch_query_epoch::Epoch::Current(x.0));
440 }
441 GeneratedField::Backup => {
442 if epoch__.is_some() {
443 return Err(serde::de::Error::duplicate_field("backup"));
444 }
445 epoch__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| batch_query_epoch::Epoch::Backup(x.0));
446 }
447 GeneratedField::TimeTravel => {
448 if epoch__.is_some() {
449 return Err(serde::de::Error::duplicate_field("timeTravel"));
450 }
451 epoch__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| batch_query_epoch::Epoch::TimeTravel(x.0));
452 }
453 }
454 }
455 Ok(BatchQueryEpoch {
456 epoch: epoch__,
457 })
458 }
459 }
460 deserializer.deserialize_struct("common.BatchQueryEpoch", FIELDS, GeneratedVisitor)
461 }
462}
463impl serde::Serialize for Buffer {
464 #[allow(deprecated)]
465 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
466 where
467 S: serde::Serializer,
468 {
469 use serde::ser::SerializeStruct;
470 let mut len = 0;
471 if self.compression != 0 {
472 len += 1;
473 }
474 if !self.body.is_empty() {
475 len += 1;
476 }
477 let mut struct_ser = serializer.serialize_struct("common.Buffer", len)?;
478 if self.compression != 0 {
479 let v = buffer::CompressionType::try_from(self.compression)
480 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compression)))?;
481 struct_ser.serialize_field("compression", &v)?;
482 }
483 if !self.body.is_empty() {
484 #[allow(clippy::needless_borrow)]
485 #[allow(clippy::needless_borrows_for_generic_args)]
486 struct_ser.serialize_field("body", pbjson::private::base64::encode(&self.body).as_str())?;
487 }
488 struct_ser.end()
489 }
490}
491impl<'de> serde::Deserialize<'de> for Buffer {
492 #[allow(deprecated)]
493 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
494 where
495 D: serde::Deserializer<'de>,
496 {
497 const FIELDS: &[&str] = &[
498 "compression",
499 "body",
500 ];
501
502 #[allow(clippy::enum_variant_names)]
503 enum GeneratedField {
504 Compression,
505 Body,
506 }
507 impl<'de> serde::Deserialize<'de> for GeneratedField {
508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
509 where
510 D: serde::Deserializer<'de>,
511 {
512 struct GeneratedVisitor;
513
514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
515 type Value = GeneratedField;
516
517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
518 write!(formatter, "expected one of: {:?}", &FIELDS)
519 }
520
521 #[allow(unused_variables)]
522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
523 where
524 E: serde::de::Error,
525 {
526 match value {
527 "compression" => Ok(GeneratedField::Compression),
528 "body" => Ok(GeneratedField::Body),
529 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
530 }
531 }
532 }
533 deserializer.deserialize_identifier(GeneratedVisitor)
534 }
535 }
536 struct GeneratedVisitor;
537 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
538 type Value = Buffer;
539
540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
541 formatter.write_str("struct common.Buffer")
542 }
543
544 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Buffer, V::Error>
545 where
546 V: serde::de::MapAccess<'de>,
547 {
548 let mut compression__ = None;
549 let mut body__ = None;
550 while let Some(k) = map_.next_key()? {
551 match k {
552 GeneratedField::Compression => {
553 if compression__.is_some() {
554 return Err(serde::de::Error::duplicate_field("compression"));
555 }
556 compression__ = Some(map_.next_value::<buffer::CompressionType>()? as i32);
557 }
558 GeneratedField::Body => {
559 if body__.is_some() {
560 return Err(serde::de::Error::duplicate_field("body"));
561 }
562 body__ =
563 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
564 ;
565 }
566 }
567 }
568 Ok(Buffer {
569 compression: compression__.unwrap_or_default(),
570 body: body__.unwrap_or_default(),
571 })
572 }
573 }
574 deserializer.deserialize_struct("common.Buffer", FIELDS, GeneratedVisitor)
575 }
576}
577impl serde::Serialize for buffer::CompressionType {
578 #[allow(deprecated)]
579 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
580 where
581 S: serde::Serializer,
582 {
583 let variant = match self {
584 Self::Unspecified => "UNSPECIFIED",
585 Self::None => "NONE",
586 };
587 serializer.serialize_str(variant)
588 }
589}
590impl<'de> serde::Deserialize<'de> for buffer::CompressionType {
591 #[allow(deprecated)]
592 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
593 where
594 D: serde::Deserializer<'de>,
595 {
596 const FIELDS: &[&str] = &[
597 "UNSPECIFIED",
598 "NONE",
599 ];
600
601 struct GeneratedVisitor;
602
603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
604 type Value = buffer::CompressionType;
605
606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
607 write!(formatter, "expected one of: {:?}", &FIELDS)
608 }
609
610 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
611 where
612 E: serde::de::Error,
613 {
614 i32::try_from(v)
615 .ok()
616 .and_then(|x| x.try_into().ok())
617 .ok_or_else(|| {
618 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
619 })
620 }
621
622 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
623 where
624 E: serde::de::Error,
625 {
626 i32::try_from(v)
627 .ok()
628 .and_then(|x| x.try_into().ok())
629 .ok_or_else(|| {
630 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
631 })
632 }
633
634 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
635 where
636 E: serde::de::Error,
637 {
638 match value {
639 "UNSPECIFIED" => Ok(buffer::CompressionType::Unspecified),
640 "NONE" => Ok(buffer::CompressionType::None),
641 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
642 }
643 }
644 }
645 deserializer.deserialize_any(GeneratedVisitor)
646 }
647}
648impl serde::Serialize for ColumnOrder {
649 #[allow(deprecated)]
650 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
651 where
652 S: serde::Serializer,
653 {
654 use serde::ser::SerializeStruct;
655 let mut len = 0;
656 if self.column_index != 0 {
657 len += 1;
658 }
659 if self.order_type.is_some() {
660 len += 1;
661 }
662 let mut struct_ser = serializer.serialize_struct("common.ColumnOrder", len)?;
663 if self.column_index != 0 {
664 struct_ser.serialize_field("columnIndex", &self.column_index)?;
665 }
666 if let Some(v) = self.order_type.as_ref() {
667 struct_ser.serialize_field("orderType", v)?;
668 }
669 struct_ser.end()
670 }
671}
672impl<'de> serde::Deserialize<'de> for ColumnOrder {
673 #[allow(deprecated)]
674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
675 where
676 D: serde::Deserializer<'de>,
677 {
678 const FIELDS: &[&str] = &[
679 "column_index",
680 "columnIndex",
681 "order_type",
682 "orderType",
683 ];
684
685 #[allow(clippy::enum_variant_names)]
686 enum GeneratedField {
687 ColumnIndex,
688 OrderType,
689 }
690 impl<'de> serde::Deserialize<'de> for GeneratedField {
691 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
692 where
693 D: serde::Deserializer<'de>,
694 {
695 struct GeneratedVisitor;
696
697 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
698 type Value = GeneratedField;
699
700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
701 write!(formatter, "expected one of: {:?}", &FIELDS)
702 }
703
704 #[allow(unused_variables)]
705 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
706 where
707 E: serde::de::Error,
708 {
709 match value {
710 "columnIndex" | "column_index" => Ok(GeneratedField::ColumnIndex),
711 "orderType" | "order_type" => Ok(GeneratedField::OrderType),
712 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
713 }
714 }
715 }
716 deserializer.deserialize_identifier(GeneratedVisitor)
717 }
718 }
719 struct GeneratedVisitor;
720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
721 type Value = ColumnOrder;
722
723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
724 formatter.write_str("struct common.ColumnOrder")
725 }
726
727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ColumnOrder, V::Error>
728 where
729 V: serde::de::MapAccess<'de>,
730 {
731 let mut column_index__ = None;
732 let mut order_type__ = None;
733 while let Some(k) = map_.next_key()? {
734 match k {
735 GeneratedField::ColumnIndex => {
736 if column_index__.is_some() {
737 return Err(serde::de::Error::duplicate_field("columnIndex"));
738 }
739 column_index__ =
740 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
741 ;
742 }
743 GeneratedField::OrderType => {
744 if order_type__.is_some() {
745 return Err(serde::de::Error::duplicate_field("orderType"));
746 }
747 order_type__ = map_.next_value()?;
748 }
749 }
750 }
751 Ok(ColumnOrder {
752 column_index: column_index__.unwrap_or_default(),
753 order_type: order_type__,
754 })
755 }
756 }
757 deserializer.deserialize_struct("common.ColumnOrder", FIELDS, GeneratedVisitor)
758 }
759}
760impl serde::Serialize for Direction {
761 #[allow(deprecated)]
762 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
763 where
764 S: serde::Serializer,
765 {
766 let variant = match self {
767 Self::Unspecified => "DIRECTION_UNSPECIFIED",
768 Self::Ascending => "DIRECTION_ASCENDING",
769 Self::Descending => "DIRECTION_DESCENDING",
770 };
771 serializer.serialize_str(variant)
772 }
773}
774impl<'de> serde::Deserialize<'de> for Direction {
775 #[allow(deprecated)]
776 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
777 where
778 D: serde::Deserializer<'de>,
779 {
780 const FIELDS: &[&str] = &[
781 "DIRECTION_UNSPECIFIED",
782 "DIRECTION_ASCENDING",
783 "DIRECTION_DESCENDING",
784 ];
785
786 struct GeneratedVisitor;
787
788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
789 type Value = Direction;
790
791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
792 write!(formatter, "expected one of: {:?}", &FIELDS)
793 }
794
795 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
796 where
797 E: serde::de::Error,
798 {
799 i32::try_from(v)
800 .ok()
801 .and_then(|x| x.try_into().ok())
802 .ok_or_else(|| {
803 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
804 })
805 }
806
807 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
808 where
809 E: serde::de::Error,
810 {
811 i32::try_from(v)
812 .ok()
813 .and_then(|x| x.try_into().ok())
814 .ok_or_else(|| {
815 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
816 })
817 }
818
819 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
820 where
821 E: serde::de::Error,
822 {
823 match value {
824 "DIRECTION_UNSPECIFIED" => Ok(Direction::Unspecified),
825 "DIRECTION_ASCENDING" => Ok(Direction::Ascending),
826 "DIRECTION_DESCENDING" => Ok(Direction::Descending),
827 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
828 }
829 }
830 }
831 deserializer.deserialize_any(GeneratedVisitor)
832 }
833}
834impl serde::Serialize for HostAddress {
835 #[allow(deprecated)]
836 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
837 where
838 S: serde::Serializer,
839 {
840 use serde::ser::SerializeStruct;
841 let mut len = 0;
842 if !self.host.is_empty() {
843 len += 1;
844 }
845 if self.port != 0 {
846 len += 1;
847 }
848 let mut struct_ser = serializer.serialize_struct("common.HostAddress", len)?;
849 if !self.host.is_empty() {
850 struct_ser.serialize_field("host", &self.host)?;
851 }
852 if self.port != 0 {
853 struct_ser.serialize_field("port", &self.port)?;
854 }
855 struct_ser.end()
856 }
857}
858impl<'de> serde::Deserialize<'de> for HostAddress {
859 #[allow(deprecated)]
860 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
861 where
862 D: serde::Deserializer<'de>,
863 {
864 const FIELDS: &[&str] = &[
865 "host",
866 "port",
867 ];
868
869 #[allow(clippy::enum_variant_names)]
870 enum GeneratedField {
871 Host,
872 Port,
873 }
874 impl<'de> serde::Deserialize<'de> for GeneratedField {
875 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
876 where
877 D: serde::Deserializer<'de>,
878 {
879 struct GeneratedVisitor;
880
881 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
882 type Value = GeneratedField;
883
884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
885 write!(formatter, "expected one of: {:?}", &FIELDS)
886 }
887
888 #[allow(unused_variables)]
889 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
890 where
891 E: serde::de::Error,
892 {
893 match value {
894 "host" => Ok(GeneratedField::Host),
895 "port" => Ok(GeneratedField::Port),
896 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
897 }
898 }
899 }
900 deserializer.deserialize_identifier(GeneratedVisitor)
901 }
902 }
903 struct GeneratedVisitor;
904 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
905 type Value = HostAddress;
906
907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
908 formatter.write_str("struct common.HostAddress")
909 }
910
911 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HostAddress, V::Error>
912 where
913 V: serde::de::MapAccess<'de>,
914 {
915 let mut host__ = None;
916 let mut port__ = None;
917 while let Some(k) = map_.next_key()? {
918 match k {
919 GeneratedField::Host => {
920 if host__.is_some() {
921 return Err(serde::de::Error::duplicate_field("host"));
922 }
923 host__ = Some(map_.next_value()?);
924 }
925 GeneratedField::Port => {
926 if port__.is_some() {
927 return Err(serde::de::Error::duplicate_field("port"));
928 }
929 port__ =
930 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
931 ;
932 }
933 }
934 }
935 Ok(HostAddress {
936 host: host__.unwrap_or_default(),
937 port: port__.unwrap_or_default(),
938 })
939 }
940 }
941 deserializer.deserialize_struct("common.HostAddress", FIELDS, GeneratedVisitor)
942 }
943}
944impl serde::Serialize for NullsAre {
945 #[allow(deprecated)]
946 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
947 where
948 S: serde::Serializer,
949 {
950 let variant = match self {
951 Self::Unspecified => "NULLS_ARE_UNSPECIFIED",
952 Self::Largest => "NULLS_ARE_LARGEST",
953 Self::Smallest => "NULLS_ARE_SMALLEST",
954 };
955 serializer.serialize_str(variant)
956 }
957}
958impl<'de> serde::Deserialize<'de> for NullsAre {
959 #[allow(deprecated)]
960 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
961 where
962 D: serde::Deserializer<'de>,
963 {
964 const FIELDS: &[&str] = &[
965 "NULLS_ARE_UNSPECIFIED",
966 "NULLS_ARE_LARGEST",
967 "NULLS_ARE_SMALLEST",
968 ];
969
970 struct GeneratedVisitor;
971
972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
973 type Value = NullsAre;
974
975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
976 write!(formatter, "expected one of: {:?}", &FIELDS)
977 }
978
979 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
980 where
981 E: serde::de::Error,
982 {
983 i32::try_from(v)
984 .ok()
985 .and_then(|x| x.try_into().ok())
986 .ok_or_else(|| {
987 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
988 })
989 }
990
991 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
992 where
993 E: serde::de::Error,
994 {
995 i32::try_from(v)
996 .ok()
997 .and_then(|x| x.try_into().ok())
998 .ok_or_else(|| {
999 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1000 })
1001 }
1002
1003 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1004 where
1005 E: serde::de::Error,
1006 {
1007 match value {
1008 "NULLS_ARE_UNSPECIFIED" => Ok(NullsAre::Unspecified),
1009 "NULLS_ARE_LARGEST" => Ok(NullsAre::Largest),
1010 "NULLS_ARE_SMALLEST" => Ok(NullsAre::Smallest),
1011 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1012 }
1013 }
1014 }
1015 deserializer.deserialize_any(GeneratedVisitor)
1016 }
1017}
1018impl serde::Serialize for ObjectType {
1019 #[allow(deprecated)]
1020 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1021 where
1022 S: serde::Serializer,
1023 {
1024 let variant = match self {
1025 Self::Unspecified => "UNSPECIFIED",
1026 Self::Database => "DATABASE",
1027 Self::Schema => "SCHEMA",
1028 Self::Table => "TABLE",
1029 Self::Mview => "MVIEW",
1030 Self::Source => "SOURCE",
1031 Self::Sink => "SINK",
1032 Self::View => "VIEW",
1033 Self::Index => "INDEX",
1034 Self::Function => "FUNCTION",
1035 Self::Connection => "CONNECTION",
1036 Self::Subscription => "SUBSCRIPTION",
1037 Self::Secret => "SECRET",
1038 };
1039 serializer.serialize_str(variant)
1040 }
1041}
1042impl<'de> serde::Deserialize<'de> for ObjectType {
1043 #[allow(deprecated)]
1044 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1045 where
1046 D: serde::Deserializer<'de>,
1047 {
1048 const FIELDS: &[&str] = &[
1049 "UNSPECIFIED",
1050 "DATABASE",
1051 "SCHEMA",
1052 "TABLE",
1053 "MVIEW",
1054 "SOURCE",
1055 "SINK",
1056 "VIEW",
1057 "INDEX",
1058 "FUNCTION",
1059 "CONNECTION",
1060 "SUBSCRIPTION",
1061 "SECRET",
1062 ];
1063
1064 struct GeneratedVisitor;
1065
1066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1067 type Value = ObjectType;
1068
1069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1070 write!(formatter, "expected one of: {:?}", &FIELDS)
1071 }
1072
1073 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1074 where
1075 E: serde::de::Error,
1076 {
1077 i32::try_from(v)
1078 .ok()
1079 .and_then(|x| x.try_into().ok())
1080 .ok_or_else(|| {
1081 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1082 })
1083 }
1084
1085 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1086 where
1087 E: serde::de::Error,
1088 {
1089 i32::try_from(v)
1090 .ok()
1091 .and_then(|x| x.try_into().ok())
1092 .ok_or_else(|| {
1093 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1094 })
1095 }
1096
1097 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1098 where
1099 E: serde::de::Error,
1100 {
1101 match value {
1102 "UNSPECIFIED" => Ok(ObjectType::Unspecified),
1103 "DATABASE" => Ok(ObjectType::Database),
1104 "SCHEMA" => Ok(ObjectType::Schema),
1105 "TABLE" => Ok(ObjectType::Table),
1106 "MVIEW" => Ok(ObjectType::Mview),
1107 "SOURCE" => Ok(ObjectType::Source),
1108 "SINK" => Ok(ObjectType::Sink),
1109 "VIEW" => Ok(ObjectType::View),
1110 "INDEX" => Ok(ObjectType::Index),
1111 "FUNCTION" => Ok(ObjectType::Function),
1112 "CONNECTION" => Ok(ObjectType::Connection),
1113 "SUBSCRIPTION" => Ok(ObjectType::Subscription),
1114 "SECRET" => Ok(ObjectType::Secret),
1115 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1116 }
1117 }
1118 }
1119 deserializer.deserialize_any(GeneratedVisitor)
1120 }
1121}
1122impl serde::Serialize for OptionalUint32 {
1123 #[allow(deprecated)]
1124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1125 where
1126 S: serde::Serializer,
1127 {
1128 use serde::ser::SerializeStruct;
1129 let mut len = 0;
1130 if self.value.is_some() {
1131 len += 1;
1132 }
1133 let mut struct_ser = serializer.serialize_struct("common.OptionalUint32", len)?;
1134 if let Some(v) = self.value.as_ref() {
1135 struct_ser.serialize_field("value", v)?;
1136 }
1137 struct_ser.end()
1138 }
1139}
1140impl<'de> serde::Deserialize<'de> for OptionalUint32 {
1141 #[allow(deprecated)]
1142 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1143 where
1144 D: serde::Deserializer<'de>,
1145 {
1146 const FIELDS: &[&str] = &[
1147 "value",
1148 ];
1149
1150 #[allow(clippy::enum_variant_names)]
1151 enum GeneratedField {
1152 Value,
1153 }
1154 impl<'de> serde::Deserialize<'de> for GeneratedField {
1155 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1156 where
1157 D: serde::Deserializer<'de>,
1158 {
1159 struct GeneratedVisitor;
1160
1161 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1162 type Value = GeneratedField;
1163
1164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1165 write!(formatter, "expected one of: {:?}", &FIELDS)
1166 }
1167
1168 #[allow(unused_variables)]
1169 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1170 where
1171 E: serde::de::Error,
1172 {
1173 match value {
1174 "value" => Ok(GeneratedField::Value),
1175 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1176 }
1177 }
1178 }
1179 deserializer.deserialize_identifier(GeneratedVisitor)
1180 }
1181 }
1182 struct GeneratedVisitor;
1183 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1184 type Value = OptionalUint32;
1185
1186 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1187 formatter.write_str("struct common.OptionalUint32")
1188 }
1189
1190 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OptionalUint32, V::Error>
1191 where
1192 V: serde::de::MapAccess<'de>,
1193 {
1194 let mut value__ = None;
1195 while let Some(k) = map_.next_key()? {
1196 match k {
1197 GeneratedField::Value => {
1198 if value__.is_some() {
1199 return Err(serde::de::Error::duplicate_field("value"));
1200 }
1201 value__ =
1202 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1203 ;
1204 }
1205 }
1206 }
1207 Ok(OptionalUint32 {
1208 value: value__,
1209 })
1210 }
1211 }
1212 deserializer.deserialize_struct("common.OptionalUint32", FIELDS, GeneratedVisitor)
1213 }
1214}
1215impl serde::Serialize for OptionalUint64 {
1216 #[allow(deprecated)]
1217 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1218 where
1219 S: serde::Serializer,
1220 {
1221 use serde::ser::SerializeStruct;
1222 let mut len = 0;
1223 if self.value.is_some() {
1224 len += 1;
1225 }
1226 let mut struct_ser = serializer.serialize_struct("common.OptionalUint64", len)?;
1227 if let Some(v) = self.value.as_ref() {
1228 #[allow(clippy::needless_borrow)]
1229 #[allow(clippy::needless_borrows_for_generic_args)]
1230 struct_ser.serialize_field("value", ToString::to_string(&v).as_str())?;
1231 }
1232 struct_ser.end()
1233 }
1234}
1235impl<'de> serde::Deserialize<'de> for OptionalUint64 {
1236 #[allow(deprecated)]
1237 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1238 where
1239 D: serde::Deserializer<'de>,
1240 {
1241 const FIELDS: &[&str] = &[
1242 "value",
1243 ];
1244
1245 #[allow(clippy::enum_variant_names)]
1246 enum GeneratedField {
1247 Value,
1248 }
1249 impl<'de> serde::Deserialize<'de> for GeneratedField {
1250 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1251 where
1252 D: serde::Deserializer<'de>,
1253 {
1254 struct GeneratedVisitor;
1255
1256 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1257 type Value = GeneratedField;
1258
1259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1260 write!(formatter, "expected one of: {:?}", &FIELDS)
1261 }
1262
1263 #[allow(unused_variables)]
1264 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1265 where
1266 E: serde::de::Error,
1267 {
1268 match value {
1269 "value" => Ok(GeneratedField::Value),
1270 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1271 }
1272 }
1273 }
1274 deserializer.deserialize_identifier(GeneratedVisitor)
1275 }
1276 }
1277 struct GeneratedVisitor;
1278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1279 type Value = OptionalUint64;
1280
1281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1282 formatter.write_str("struct common.OptionalUint64")
1283 }
1284
1285 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OptionalUint64, V::Error>
1286 where
1287 V: serde::de::MapAccess<'de>,
1288 {
1289 let mut value__ = None;
1290 while let Some(k) = map_.next_key()? {
1291 match k {
1292 GeneratedField::Value => {
1293 if value__.is_some() {
1294 return Err(serde::de::Error::duplicate_field("value"));
1295 }
1296 value__ =
1297 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1298 ;
1299 }
1300 }
1301 }
1302 Ok(OptionalUint64 {
1303 value: value__,
1304 })
1305 }
1306 }
1307 deserializer.deserialize_struct("common.OptionalUint64", FIELDS, GeneratedVisitor)
1308 }
1309}
1310impl serde::Serialize for OrderType {
1311 #[allow(deprecated)]
1312 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1313 where
1314 S: serde::Serializer,
1315 {
1316 use serde::ser::SerializeStruct;
1317 let mut len = 0;
1318 if self.direction != 0 {
1319 len += 1;
1320 }
1321 if self.nulls_are != 0 {
1322 len += 1;
1323 }
1324 let mut struct_ser = serializer.serialize_struct("common.OrderType", len)?;
1325 if self.direction != 0 {
1326 let v = Direction::try_from(self.direction)
1327 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?;
1328 struct_ser.serialize_field("direction", &v)?;
1329 }
1330 if self.nulls_are != 0 {
1331 let v = NullsAre::try_from(self.nulls_are)
1332 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.nulls_are)))?;
1333 struct_ser.serialize_field("nullsAre", &v)?;
1334 }
1335 struct_ser.end()
1336 }
1337}
1338impl<'de> serde::Deserialize<'de> for OrderType {
1339 #[allow(deprecated)]
1340 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1341 where
1342 D: serde::Deserializer<'de>,
1343 {
1344 const FIELDS: &[&str] = &[
1345 "direction",
1346 "nulls_are",
1347 "nullsAre",
1348 ];
1349
1350 #[allow(clippy::enum_variant_names)]
1351 enum GeneratedField {
1352 Direction,
1353 NullsAre,
1354 }
1355 impl<'de> serde::Deserialize<'de> for GeneratedField {
1356 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1357 where
1358 D: serde::Deserializer<'de>,
1359 {
1360 struct GeneratedVisitor;
1361
1362 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1363 type Value = GeneratedField;
1364
1365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1366 write!(formatter, "expected one of: {:?}", &FIELDS)
1367 }
1368
1369 #[allow(unused_variables)]
1370 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1371 where
1372 E: serde::de::Error,
1373 {
1374 match value {
1375 "direction" => Ok(GeneratedField::Direction),
1376 "nullsAre" | "nulls_are" => Ok(GeneratedField::NullsAre),
1377 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1378 }
1379 }
1380 }
1381 deserializer.deserialize_identifier(GeneratedVisitor)
1382 }
1383 }
1384 struct GeneratedVisitor;
1385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1386 type Value = OrderType;
1387
1388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1389 formatter.write_str("struct common.OrderType")
1390 }
1391
1392 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OrderType, V::Error>
1393 where
1394 V: serde::de::MapAccess<'de>,
1395 {
1396 let mut direction__ = None;
1397 let mut nulls_are__ = None;
1398 while let Some(k) = map_.next_key()? {
1399 match k {
1400 GeneratedField::Direction => {
1401 if direction__.is_some() {
1402 return Err(serde::de::Error::duplicate_field("direction"));
1403 }
1404 direction__ = Some(map_.next_value::<Direction>()? as i32);
1405 }
1406 GeneratedField::NullsAre => {
1407 if nulls_are__.is_some() {
1408 return Err(serde::de::Error::duplicate_field("nullsAre"));
1409 }
1410 nulls_are__ = Some(map_.next_value::<NullsAre>()? as i32);
1411 }
1412 }
1413 }
1414 Ok(OrderType {
1415 direction: direction__.unwrap_or_default(),
1416 nulls_are: nulls_are__.unwrap_or_default(),
1417 })
1418 }
1419 }
1420 deserializer.deserialize_struct("common.OrderType", FIELDS, GeneratedVisitor)
1421 }
1422}
1423impl serde::Serialize for Status {
1424 #[allow(deprecated)]
1425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1426 where
1427 S: serde::Serializer,
1428 {
1429 use serde::ser::SerializeStruct;
1430 let mut len = 0;
1431 if self.code != 0 {
1432 len += 1;
1433 }
1434 if !self.message.is_empty() {
1435 len += 1;
1436 }
1437 let mut struct_ser = serializer.serialize_struct("common.Status", len)?;
1438 if self.code != 0 {
1439 let v = status::Code::try_from(self.code)
1440 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.code)))?;
1441 struct_ser.serialize_field("code", &v)?;
1442 }
1443 if !self.message.is_empty() {
1444 struct_ser.serialize_field("message", &self.message)?;
1445 }
1446 struct_ser.end()
1447 }
1448}
1449impl<'de> serde::Deserialize<'de> for Status {
1450 #[allow(deprecated)]
1451 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1452 where
1453 D: serde::Deserializer<'de>,
1454 {
1455 const FIELDS: &[&str] = &[
1456 "code",
1457 "message",
1458 ];
1459
1460 #[allow(clippy::enum_variant_names)]
1461 enum GeneratedField {
1462 Code,
1463 Message,
1464 }
1465 impl<'de> serde::Deserialize<'de> for GeneratedField {
1466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1467 where
1468 D: serde::Deserializer<'de>,
1469 {
1470 struct GeneratedVisitor;
1471
1472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1473 type Value = GeneratedField;
1474
1475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1476 write!(formatter, "expected one of: {:?}", &FIELDS)
1477 }
1478
1479 #[allow(unused_variables)]
1480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1481 where
1482 E: serde::de::Error,
1483 {
1484 match value {
1485 "code" => Ok(GeneratedField::Code),
1486 "message" => Ok(GeneratedField::Message),
1487 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1488 }
1489 }
1490 }
1491 deserializer.deserialize_identifier(GeneratedVisitor)
1492 }
1493 }
1494 struct GeneratedVisitor;
1495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1496 type Value = Status;
1497
1498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1499 formatter.write_str("struct common.Status")
1500 }
1501
1502 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Status, V::Error>
1503 where
1504 V: serde::de::MapAccess<'de>,
1505 {
1506 let mut code__ = None;
1507 let mut message__ = None;
1508 while let Some(k) = map_.next_key()? {
1509 match k {
1510 GeneratedField::Code => {
1511 if code__.is_some() {
1512 return Err(serde::de::Error::duplicate_field("code"));
1513 }
1514 code__ = Some(map_.next_value::<status::Code>()? as i32);
1515 }
1516 GeneratedField::Message => {
1517 if message__.is_some() {
1518 return Err(serde::de::Error::duplicate_field("message"));
1519 }
1520 message__ = Some(map_.next_value()?);
1521 }
1522 }
1523 }
1524 Ok(Status {
1525 code: code__.unwrap_or_default(),
1526 message: message__.unwrap_or_default(),
1527 })
1528 }
1529 }
1530 deserializer.deserialize_struct("common.Status", FIELDS, GeneratedVisitor)
1531 }
1532}
1533impl serde::Serialize for status::Code {
1534 #[allow(deprecated)]
1535 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1536 where
1537 S: serde::Serializer,
1538 {
1539 let variant = match self {
1540 Self::Unspecified => "UNSPECIFIED",
1541 Self::Ok => "OK",
1542 Self::UnknownWorker => "UNKNOWN_WORKER",
1543 };
1544 serializer.serialize_str(variant)
1545 }
1546}
1547impl<'de> serde::Deserialize<'de> for status::Code {
1548 #[allow(deprecated)]
1549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1550 where
1551 D: serde::Deserializer<'de>,
1552 {
1553 const FIELDS: &[&str] = &[
1554 "UNSPECIFIED",
1555 "OK",
1556 "UNKNOWN_WORKER",
1557 ];
1558
1559 struct GeneratedVisitor;
1560
1561 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1562 type Value = status::Code;
1563
1564 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1565 write!(formatter, "expected one of: {:?}", &FIELDS)
1566 }
1567
1568 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1569 where
1570 E: serde::de::Error,
1571 {
1572 i32::try_from(v)
1573 .ok()
1574 .and_then(|x| x.try_into().ok())
1575 .ok_or_else(|| {
1576 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1577 })
1578 }
1579
1580 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1581 where
1582 E: serde::de::Error,
1583 {
1584 i32::try_from(v)
1585 .ok()
1586 .and_then(|x| x.try_into().ok())
1587 .ok_or_else(|| {
1588 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1589 })
1590 }
1591
1592 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1593 where
1594 E: serde::de::Error,
1595 {
1596 match value {
1597 "UNSPECIFIED" => Ok(status::Code::Unspecified),
1598 "OK" => Ok(status::Code::Ok),
1599 "UNKNOWN_WORKER" => Ok(status::Code::UnknownWorker),
1600 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1601 }
1602 }
1603 }
1604 deserializer.deserialize_any(GeneratedVisitor)
1605 }
1606}
1607impl serde::Serialize for Uint32Vector {
1608 #[allow(deprecated)]
1609 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1610 where
1611 S: serde::Serializer,
1612 {
1613 use serde::ser::SerializeStruct;
1614 let mut len = 0;
1615 if !self.data.is_empty() {
1616 len += 1;
1617 }
1618 let mut struct_ser = serializer.serialize_struct("common.Uint32Vector", len)?;
1619 if !self.data.is_empty() {
1620 struct_ser.serialize_field("data", &self.data)?;
1621 }
1622 struct_ser.end()
1623 }
1624}
1625impl<'de> serde::Deserialize<'de> for Uint32Vector {
1626 #[allow(deprecated)]
1627 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1628 where
1629 D: serde::Deserializer<'de>,
1630 {
1631 const FIELDS: &[&str] = &[
1632 "data",
1633 ];
1634
1635 #[allow(clippy::enum_variant_names)]
1636 enum GeneratedField {
1637 Data,
1638 }
1639 impl<'de> serde::Deserialize<'de> for GeneratedField {
1640 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1641 where
1642 D: serde::Deserializer<'de>,
1643 {
1644 struct GeneratedVisitor;
1645
1646 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1647 type Value = GeneratedField;
1648
1649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1650 write!(formatter, "expected one of: {:?}", &FIELDS)
1651 }
1652
1653 #[allow(unused_variables)]
1654 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1655 where
1656 E: serde::de::Error,
1657 {
1658 match value {
1659 "data" => Ok(GeneratedField::Data),
1660 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1661 }
1662 }
1663 }
1664 deserializer.deserialize_identifier(GeneratedVisitor)
1665 }
1666 }
1667 struct GeneratedVisitor;
1668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1669 type Value = Uint32Vector;
1670
1671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1672 formatter.write_str("struct common.Uint32Vector")
1673 }
1674
1675 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Uint32Vector, V::Error>
1676 where
1677 V: serde::de::MapAccess<'de>,
1678 {
1679 let mut data__ = None;
1680 while let Some(k) = map_.next_key()? {
1681 match k {
1682 GeneratedField::Data => {
1683 if data__.is_some() {
1684 return Err(serde::de::Error::duplicate_field("data"));
1685 }
1686 data__ =
1687 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1688 .into_iter().map(|x| x.0).collect())
1689 ;
1690 }
1691 }
1692 }
1693 Ok(Uint32Vector {
1694 data: data__.unwrap_or_default(),
1695 })
1696 }
1697 }
1698 deserializer.deserialize_struct("common.Uint32Vector", FIELDS, GeneratedVisitor)
1699 }
1700}
1701impl serde::Serialize for WorkerNode {
1702 #[allow(deprecated)]
1703 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1704 where
1705 S: serde::Serializer,
1706 {
1707 use serde::ser::SerializeStruct;
1708 let mut len = 0;
1709 if self.id != 0 {
1710 len += 1;
1711 }
1712 if self.r#type != 0 {
1713 len += 1;
1714 }
1715 if self.host.is_some() {
1716 len += 1;
1717 }
1718 if self.state != 0 {
1719 len += 1;
1720 }
1721 if self.property.is_some() {
1722 len += 1;
1723 }
1724 if self.transactional_id.is_some() {
1725 len += 1;
1726 }
1727 if self.resource.is_some() {
1728 len += 1;
1729 }
1730 if self.started_at.is_some() {
1731 len += 1;
1732 }
1733 let mut struct_ser = serializer.serialize_struct("common.WorkerNode", len)?;
1734 if self.id != 0 {
1735 struct_ser.serialize_field("id", &self.id)?;
1736 }
1737 if self.r#type != 0 {
1738 let v = WorkerType::try_from(self.r#type)
1739 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
1740 struct_ser.serialize_field("type", &v)?;
1741 }
1742 if let Some(v) = self.host.as_ref() {
1743 struct_ser.serialize_field("host", v)?;
1744 }
1745 if self.state != 0 {
1746 let v = worker_node::State::try_from(self.state)
1747 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
1748 struct_ser.serialize_field("state", &v)?;
1749 }
1750 if let Some(v) = self.property.as_ref() {
1751 struct_ser.serialize_field("property", v)?;
1752 }
1753 if let Some(v) = self.transactional_id.as_ref() {
1754 struct_ser.serialize_field("transactionalId", v)?;
1755 }
1756 if let Some(v) = self.resource.as_ref() {
1757 struct_ser.serialize_field("resource", v)?;
1758 }
1759 if let Some(v) = self.started_at.as_ref() {
1760 #[allow(clippy::needless_borrow)]
1761 #[allow(clippy::needless_borrows_for_generic_args)]
1762 struct_ser.serialize_field("startedAt", ToString::to_string(&v).as_str())?;
1763 }
1764 struct_ser.end()
1765 }
1766}
1767impl<'de> serde::Deserialize<'de> for WorkerNode {
1768 #[allow(deprecated)]
1769 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1770 where
1771 D: serde::Deserializer<'de>,
1772 {
1773 const FIELDS: &[&str] = &[
1774 "id",
1775 "type",
1776 "host",
1777 "state",
1778 "property",
1779 "transactional_id",
1780 "transactionalId",
1781 "resource",
1782 "started_at",
1783 "startedAt",
1784 ];
1785
1786 #[allow(clippy::enum_variant_names)]
1787 enum GeneratedField {
1788 Id,
1789 Type,
1790 Host,
1791 State,
1792 Property,
1793 TransactionalId,
1794 Resource,
1795 StartedAt,
1796 }
1797 impl<'de> serde::Deserialize<'de> for GeneratedField {
1798 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1799 where
1800 D: serde::Deserializer<'de>,
1801 {
1802 struct GeneratedVisitor;
1803
1804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1805 type Value = GeneratedField;
1806
1807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1808 write!(formatter, "expected one of: {:?}", &FIELDS)
1809 }
1810
1811 #[allow(unused_variables)]
1812 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1813 where
1814 E: serde::de::Error,
1815 {
1816 match value {
1817 "id" => Ok(GeneratedField::Id),
1818 "type" => Ok(GeneratedField::Type),
1819 "host" => Ok(GeneratedField::Host),
1820 "state" => Ok(GeneratedField::State),
1821 "property" => Ok(GeneratedField::Property),
1822 "transactionalId" | "transactional_id" => Ok(GeneratedField::TransactionalId),
1823 "resource" => Ok(GeneratedField::Resource),
1824 "startedAt" | "started_at" => Ok(GeneratedField::StartedAt),
1825 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1826 }
1827 }
1828 }
1829 deserializer.deserialize_identifier(GeneratedVisitor)
1830 }
1831 }
1832 struct GeneratedVisitor;
1833 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1834 type Value = WorkerNode;
1835
1836 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1837 formatter.write_str("struct common.WorkerNode")
1838 }
1839
1840 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerNode, V::Error>
1841 where
1842 V: serde::de::MapAccess<'de>,
1843 {
1844 let mut id__ = None;
1845 let mut r#type__ = None;
1846 let mut host__ = None;
1847 let mut state__ = None;
1848 let mut property__ = None;
1849 let mut transactional_id__ = None;
1850 let mut resource__ = None;
1851 let mut started_at__ = None;
1852 while let Some(k) = map_.next_key()? {
1853 match k {
1854 GeneratedField::Id => {
1855 if id__.is_some() {
1856 return Err(serde::de::Error::duplicate_field("id"));
1857 }
1858 id__ =
1859 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1860 ;
1861 }
1862 GeneratedField::Type => {
1863 if r#type__.is_some() {
1864 return Err(serde::de::Error::duplicate_field("type"));
1865 }
1866 r#type__ = Some(map_.next_value::<WorkerType>()? as i32);
1867 }
1868 GeneratedField::Host => {
1869 if host__.is_some() {
1870 return Err(serde::de::Error::duplicate_field("host"));
1871 }
1872 host__ = map_.next_value()?;
1873 }
1874 GeneratedField::State => {
1875 if state__.is_some() {
1876 return Err(serde::de::Error::duplicate_field("state"));
1877 }
1878 state__ = Some(map_.next_value::<worker_node::State>()? as i32);
1879 }
1880 GeneratedField::Property => {
1881 if property__.is_some() {
1882 return Err(serde::de::Error::duplicate_field("property"));
1883 }
1884 property__ = map_.next_value()?;
1885 }
1886 GeneratedField::TransactionalId => {
1887 if transactional_id__.is_some() {
1888 return Err(serde::de::Error::duplicate_field("transactionalId"));
1889 }
1890 transactional_id__ =
1891 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1892 ;
1893 }
1894 GeneratedField::Resource => {
1895 if resource__.is_some() {
1896 return Err(serde::de::Error::duplicate_field("resource"));
1897 }
1898 resource__ = map_.next_value()?;
1899 }
1900 GeneratedField::StartedAt => {
1901 if started_at__.is_some() {
1902 return Err(serde::de::Error::duplicate_field("startedAt"));
1903 }
1904 started_at__ =
1905 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1906 ;
1907 }
1908 }
1909 }
1910 Ok(WorkerNode {
1911 id: id__.unwrap_or_default(),
1912 r#type: r#type__.unwrap_or_default(),
1913 host: host__,
1914 state: state__.unwrap_or_default(),
1915 property: property__,
1916 transactional_id: transactional_id__,
1917 resource: resource__,
1918 started_at: started_at__,
1919 })
1920 }
1921 }
1922 deserializer.deserialize_struct("common.WorkerNode", FIELDS, GeneratedVisitor)
1923 }
1924}
1925impl serde::Serialize for worker_node::Property {
1926 #[allow(deprecated)]
1927 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1928 where
1929 S: serde::Serializer,
1930 {
1931 use serde::ser::SerializeStruct;
1932 let mut len = 0;
1933 if self.is_streaming {
1934 len += 1;
1935 }
1936 if self.is_serving {
1937 len += 1;
1938 }
1939 if self.is_unschedulable {
1940 len += 1;
1941 }
1942 if !self.internal_rpc_host_addr.is_empty() {
1943 len += 1;
1944 }
1945 if self.parallelism != 0 {
1946 len += 1;
1947 }
1948 if self.resource_group.is_some() {
1949 len += 1;
1950 }
1951 let mut struct_ser = serializer.serialize_struct("common.WorkerNode.Property", len)?;
1952 if self.is_streaming {
1953 struct_ser.serialize_field("isStreaming", &self.is_streaming)?;
1954 }
1955 if self.is_serving {
1956 struct_ser.serialize_field("isServing", &self.is_serving)?;
1957 }
1958 if self.is_unschedulable {
1959 struct_ser.serialize_field("isUnschedulable", &self.is_unschedulable)?;
1960 }
1961 if !self.internal_rpc_host_addr.is_empty() {
1962 struct_ser.serialize_field("internalRpcHostAddr", &self.internal_rpc_host_addr)?;
1963 }
1964 if self.parallelism != 0 {
1965 struct_ser.serialize_field("parallelism", &self.parallelism)?;
1966 }
1967 if let Some(v) = self.resource_group.as_ref() {
1968 struct_ser.serialize_field("resourceGroup", v)?;
1969 }
1970 struct_ser.end()
1971 }
1972}
1973impl<'de> serde::Deserialize<'de> for worker_node::Property {
1974 #[allow(deprecated)]
1975 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1976 where
1977 D: serde::Deserializer<'de>,
1978 {
1979 const FIELDS: &[&str] = &[
1980 "is_streaming",
1981 "isStreaming",
1982 "is_serving",
1983 "isServing",
1984 "is_unschedulable",
1985 "isUnschedulable",
1986 "internal_rpc_host_addr",
1987 "internalRpcHostAddr",
1988 "parallelism",
1989 "resource_group",
1990 "resourceGroup",
1991 ];
1992
1993 #[allow(clippy::enum_variant_names)]
1994 enum GeneratedField {
1995 IsStreaming,
1996 IsServing,
1997 IsUnschedulable,
1998 InternalRpcHostAddr,
1999 Parallelism,
2000 ResourceGroup,
2001 }
2002 impl<'de> serde::Deserialize<'de> for GeneratedField {
2003 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2004 where
2005 D: serde::Deserializer<'de>,
2006 {
2007 struct GeneratedVisitor;
2008
2009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2010 type Value = GeneratedField;
2011
2012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2013 write!(formatter, "expected one of: {:?}", &FIELDS)
2014 }
2015
2016 #[allow(unused_variables)]
2017 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2018 where
2019 E: serde::de::Error,
2020 {
2021 match value {
2022 "isStreaming" | "is_streaming" => Ok(GeneratedField::IsStreaming),
2023 "isServing" | "is_serving" => Ok(GeneratedField::IsServing),
2024 "isUnschedulable" | "is_unschedulable" => Ok(GeneratedField::IsUnschedulable),
2025 "internalRpcHostAddr" | "internal_rpc_host_addr" => Ok(GeneratedField::InternalRpcHostAddr),
2026 "parallelism" => Ok(GeneratedField::Parallelism),
2027 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
2028 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2029 }
2030 }
2031 }
2032 deserializer.deserialize_identifier(GeneratedVisitor)
2033 }
2034 }
2035 struct GeneratedVisitor;
2036 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2037 type Value = worker_node::Property;
2038
2039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2040 formatter.write_str("struct common.WorkerNode.Property")
2041 }
2042
2043 fn visit_map<V>(self, mut map_: V) -> std::result::Result<worker_node::Property, V::Error>
2044 where
2045 V: serde::de::MapAccess<'de>,
2046 {
2047 let mut is_streaming__ = None;
2048 let mut is_serving__ = None;
2049 let mut is_unschedulable__ = None;
2050 let mut internal_rpc_host_addr__ = None;
2051 let mut parallelism__ = None;
2052 let mut resource_group__ = None;
2053 while let Some(k) = map_.next_key()? {
2054 match k {
2055 GeneratedField::IsStreaming => {
2056 if is_streaming__.is_some() {
2057 return Err(serde::de::Error::duplicate_field("isStreaming"));
2058 }
2059 is_streaming__ = Some(map_.next_value()?);
2060 }
2061 GeneratedField::IsServing => {
2062 if is_serving__.is_some() {
2063 return Err(serde::de::Error::duplicate_field("isServing"));
2064 }
2065 is_serving__ = Some(map_.next_value()?);
2066 }
2067 GeneratedField::IsUnschedulable => {
2068 if is_unschedulable__.is_some() {
2069 return Err(serde::de::Error::duplicate_field("isUnschedulable"));
2070 }
2071 is_unschedulable__ = Some(map_.next_value()?);
2072 }
2073 GeneratedField::InternalRpcHostAddr => {
2074 if internal_rpc_host_addr__.is_some() {
2075 return Err(serde::de::Error::duplicate_field("internalRpcHostAddr"));
2076 }
2077 internal_rpc_host_addr__ = Some(map_.next_value()?);
2078 }
2079 GeneratedField::Parallelism => {
2080 if parallelism__.is_some() {
2081 return Err(serde::de::Error::duplicate_field("parallelism"));
2082 }
2083 parallelism__ =
2084 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2085 ;
2086 }
2087 GeneratedField::ResourceGroup => {
2088 if resource_group__.is_some() {
2089 return Err(serde::de::Error::duplicate_field("resourceGroup"));
2090 }
2091 resource_group__ = map_.next_value()?;
2092 }
2093 }
2094 }
2095 Ok(worker_node::Property {
2096 is_streaming: is_streaming__.unwrap_or_default(),
2097 is_serving: is_serving__.unwrap_or_default(),
2098 is_unschedulable: is_unschedulable__.unwrap_or_default(),
2099 internal_rpc_host_addr: internal_rpc_host_addr__.unwrap_or_default(),
2100 parallelism: parallelism__.unwrap_or_default(),
2101 resource_group: resource_group__,
2102 })
2103 }
2104 }
2105 deserializer.deserialize_struct("common.WorkerNode.Property", FIELDS, GeneratedVisitor)
2106 }
2107}
2108impl serde::Serialize for worker_node::Resource {
2109 #[allow(deprecated)]
2110 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2111 where
2112 S: serde::Serializer,
2113 {
2114 use serde::ser::SerializeStruct;
2115 let mut len = 0;
2116 if !self.rw_version.is_empty() {
2117 len += 1;
2118 }
2119 if self.total_memory_bytes != 0 {
2120 len += 1;
2121 }
2122 if self.total_cpu_cores != 0 {
2123 len += 1;
2124 }
2125 let mut struct_ser = serializer.serialize_struct("common.WorkerNode.Resource", len)?;
2126 if !self.rw_version.is_empty() {
2127 struct_ser.serialize_field("rwVersion", &self.rw_version)?;
2128 }
2129 if self.total_memory_bytes != 0 {
2130 #[allow(clippy::needless_borrow)]
2131 #[allow(clippy::needless_borrows_for_generic_args)]
2132 struct_ser.serialize_field("totalMemoryBytes", ToString::to_string(&self.total_memory_bytes).as_str())?;
2133 }
2134 if self.total_cpu_cores != 0 {
2135 #[allow(clippy::needless_borrow)]
2136 #[allow(clippy::needless_borrows_for_generic_args)]
2137 struct_ser.serialize_field("totalCpuCores", ToString::to_string(&self.total_cpu_cores).as_str())?;
2138 }
2139 struct_ser.end()
2140 }
2141}
2142impl<'de> serde::Deserialize<'de> for worker_node::Resource {
2143 #[allow(deprecated)]
2144 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2145 where
2146 D: serde::Deserializer<'de>,
2147 {
2148 const FIELDS: &[&str] = &[
2149 "rw_version",
2150 "rwVersion",
2151 "total_memory_bytes",
2152 "totalMemoryBytes",
2153 "total_cpu_cores",
2154 "totalCpuCores",
2155 ];
2156
2157 #[allow(clippy::enum_variant_names)]
2158 enum GeneratedField {
2159 RwVersion,
2160 TotalMemoryBytes,
2161 TotalCpuCores,
2162 }
2163 impl<'de> serde::Deserialize<'de> for GeneratedField {
2164 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2165 where
2166 D: serde::Deserializer<'de>,
2167 {
2168 struct GeneratedVisitor;
2169
2170 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2171 type Value = GeneratedField;
2172
2173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2174 write!(formatter, "expected one of: {:?}", &FIELDS)
2175 }
2176
2177 #[allow(unused_variables)]
2178 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2179 where
2180 E: serde::de::Error,
2181 {
2182 match value {
2183 "rwVersion" | "rw_version" => Ok(GeneratedField::RwVersion),
2184 "totalMemoryBytes" | "total_memory_bytes" => Ok(GeneratedField::TotalMemoryBytes),
2185 "totalCpuCores" | "total_cpu_cores" => Ok(GeneratedField::TotalCpuCores),
2186 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2187 }
2188 }
2189 }
2190 deserializer.deserialize_identifier(GeneratedVisitor)
2191 }
2192 }
2193 struct GeneratedVisitor;
2194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2195 type Value = worker_node::Resource;
2196
2197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2198 formatter.write_str("struct common.WorkerNode.Resource")
2199 }
2200
2201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<worker_node::Resource, V::Error>
2202 where
2203 V: serde::de::MapAccess<'de>,
2204 {
2205 let mut rw_version__ = None;
2206 let mut total_memory_bytes__ = None;
2207 let mut total_cpu_cores__ = None;
2208 while let Some(k) = map_.next_key()? {
2209 match k {
2210 GeneratedField::RwVersion => {
2211 if rw_version__.is_some() {
2212 return Err(serde::de::Error::duplicate_field("rwVersion"));
2213 }
2214 rw_version__ = Some(map_.next_value()?);
2215 }
2216 GeneratedField::TotalMemoryBytes => {
2217 if total_memory_bytes__.is_some() {
2218 return Err(serde::de::Error::duplicate_field("totalMemoryBytes"));
2219 }
2220 total_memory_bytes__ =
2221 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2222 ;
2223 }
2224 GeneratedField::TotalCpuCores => {
2225 if total_cpu_cores__.is_some() {
2226 return Err(serde::de::Error::duplicate_field("totalCpuCores"));
2227 }
2228 total_cpu_cores__ =
2229 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2230 ;
2231 }
2232 }
2233 }
2234 Ok(worker_node::Resource {
2235 rw_version: rw_version__.unwrap_or_default(),
2236 total_memory_bytes: total_memory_bytes__.unwrap_or_default(),
2237 total_cpu_cores: total_cpu_cores__.unwrap_or_default(),
2238 })
2239 }
2240 }
2241 deserializer.deserialize_struct("common.WorkerNode.Resource", FIELDS, GeneratedVisitor)
2242 }
2243}
2244impl serde::Serialize for worker_node::State {
2245 #[allow(deprecated)]
2246 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2247 where
2248 S: serde::Serializer,
2249 {
2250 let variant = match self {
2251 Self::Unspecified => "UNSPECIFIED",
2252 Self::Starting => "STARTING",
2253 Self::Running => "RUNNING",
2254 };
2255 serializer.serialize_str(variant)
2256 }
2257}
2258impl<'de> serde::Deserialize<'de> for worker_node::State {
2259 #[allow(deprecated)]
2260 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2261 where
2262 D: serde::Deserializer<'de>,
2263 {
2264 const FIELDS: &[&str] = &[
2265 "UNSPECIFIED",
2266 "STARTING",
2267 "RUNNING",
2268 ];
2269
2270 struct GeneratedVisitor;
2271
2272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2273 type Value = worker_node::State;
2274
2275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2276 write!(formatter, "expected one of: {:?}", &FIELDS)
2277 }
2278
2279 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2280 where
2281 E: serde::de::Error,
2282 {
2283 i32::try_from(v)
2284 .ok()
2285 .and_then(|x| x.try_into().ok())
2286 .ok_or_else(|| {
2287 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2288 })
2289 }
2290
2291 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2292 where
2293 E: serde::de::Error,
2294 {
2295 i32::try_from(v)
2296 .ok()
2297 .and_then(|x| x.try_into().ok())
2298 .ok_or_else(|| {
2299 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2300 })
2301 }
2302
2303 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2304 where
2305 E: serde::de::Error,
2306 {
2307 match value {
2308 "UNSPECIFIED" => Ok(worker_node::State::Unspecified),
2309 "STARTING" => Ok(worker_node::State::Starting),
2310 "RUNNING" => Ok(worker_node::State::Running),
2311 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2312 }
2313 }
2314 }
2315 deserializer.deserialize_any(GeneratedVisitor)
2316 }
2317}
2318impl serde::Serialize for WorkerSlotMapping {
2319 #[allow(deprecated)]
2320 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2321 where
2322 S: serde::Serializer,
2323 {
2324 use serde::ser::SerializeStruct;
2325 let mut len = 0;
2326 if !self.original_indices.is_empty() {
2327 len += 1;
2328 }
2329 if !self.data.is_empty() {
2330 len += 1;
2331 }
2332 let mut struct_ser = serializer.serialize_struct("common.WorkerSlotMapping", len)?;
2333 if !self.original_indices.is_empty() {
2334 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
2335 }
2336 if !self.data.is_empty() {
2337 struct_ser.serialize_field("data", &self.data.iter().map(ToString::to_string).collect::<Vec<_>>())?;
2338 }
2339 struct_ser.end()
2340 }
2341}
2342impl<'de> serde::Deserialize<'de> for WorkerSlotMapping {
2343 #[allow(deprecated)]
2344 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2345 where
2346 D: serde::Deserializer<'de>,
2347 {
2348 const FIELDS: &[&str] = &[
2349 "original_indices",
2350 "originalIndices",
2351 "data",
2352 ];
2353
2354 #[allow(clippy::enum_variant_names)]
2355 enum GeneratedField {
2356 OriginalIndices,
2357 Data,
2358 }
2359 impl<'de> serde::Deserialize<'de> for GeneratedField {
2360 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2361 where
2362 D: serde::Deserializer<'de>,
2363 {
2364 struct GeneratedVisitor;
2365
2366 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2367 type Value = GeneratedField;
2368
2369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2370 write!(formatter, "expected one of: {:?}", &FIELDS)
2371 }
2372
2373 #[allow(unused_variables)]
2374 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2375 where
2376 E: serde::de::Error,
2377 {
2378 match value {
2379 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
2380 "data" => Ok(GeneratedField::Data),
2381 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2382 }
2383 }
2384 }
2385 deserializer.deserialize_identifier(GeneratedVisitor)
2386 }
2387 }
2388 struct GeneratedVisitor;
2389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2390 type Value = WorkerSlotMapping;
2391
2392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2393 formatter.write_str("struct common.WorkerSlotMapping")
2394 }
2395
2396 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerSlotMapping, V::Error>
2397 where
2398 V: serde::de::MapAccess<'de>,
2399 {
2400 let mut original_indices__ = None;
2401 let mut data__ = None;
2402 while let Some(k) = map_.next_key()? {
2403 match k {
2404 GeneratedField::OriginalIndices => {
2405 if original_indices__.is_some() {
2406 return Err(serde::de::Error::duplicate_field("originalIndices"));
2407 }
2408 original_indices__ =
2409 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2410 .into_iter().map(|x| x.0).collect())
2411 ;
2412 }
2413 GeneratedField::Data => {
2414 if data__.is_some() {
2415 return Err(serde::de::Error::duplicate_field("data"));
2416 }
2417 data__ =
2418 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2419 .into_iter().map(|x| x.0).collect())
2420 ;
2421 }
2422 }
2423 }
2424 Ok(WorkerSlotMapping {
2425 original_indices: original_indices__.unwrap_or_default(),
2426 data: data__.unwrap_or_default(),
2427 })
2428 }
2429 }
2430 deserializer.deserialize_struct("common.WorkerSlotMapping", FIELDS, GeneratedVisitor)
2431 }
2432}
2433impl serde::Serialize for WorkerType {
2434 #[allow(deprecated)]
2435 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2436 where
2437 S: serde::Serializer,
2438 {
2439 let variant = match self {
2440 Self::Unspecified => "WORKER_TYPE_UNSPECIFIED",
2441 Self::Frontend => "WORKER_TYPE_FRONTEND",
2442 Self::ComputeNode => "WORKER_TYPE_COMPUTE_NODE",
2443 Self::RiseCtl => "WORKER_TYPE_RISE_CTL",
2444 Self::Compactor => "WORKER_TYPE_COMPACTOR",
2445 Self::Meta => "WORKER_TYPE_META",
2446 };
2447 serializer.serialize_str(variant)
2448 }
2449}
2450impl<'de> serde::Deserialize<'de> for WorkerType {
2451 #[allow(deprecated)]
2452 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2453 where
2454 D: serde::Deserializer<'de>,
2455 {
2456 const FIELDS: &[&str] = &[
2457 "WORKER_TYPE_UNSPECIFIED",
2458 "WORKER_TYPE_FRONTEND",
2459 "WORKER_TYPE_COMPUTE_NODE",
2460 "WORKER_TYPE_RISE_CTL",
2461 "WORKER_TYPE_COMPACTOR",
2462 "WORKER_TYPE_META",
2463 ];
2464
2465 struct GeneratedVisitor;
2466
2467 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2468 type Value = WorkerType;
2469
2470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2471 write!(formatter, "expected one of: {:?}", &FIELDS)
2472 }
2473
2474 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2475 where
2476 E: serde::de::Error,
2477 {
2478 i32::try_from(v)
2479 .ok()
2480 .and_then(|x| x.try_into().ok())
2481 .ok_or_else(|| {
2482 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2483 })
2484 }
2485
2486 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2487 where
2488 E: serde::de::Error,
2489 {
2490 i32::try_from(v)
2491 .ok()
2492 .and_then(|x| x.try_into().ok())
2493 .ok_or_else(|| {
2494 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2495 })
2496 }
2497
2498 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2499 where
2500 E: serde::de::Error,
2501 {
2502 match value {
2503 "WORKER_TYPE_UNSPECIFIED" => Ok(WorkerType::Unspecified),
2504 "WORKER_TYPE_FRONTEND" => Ok(WorkerType::Frontend),
2505 "WORKER_TYPE_COMPUTE_NODE" => Ok(WorkerType::ComputeNode),
2506 "WORKER_TYPE_RISE_CTL" => Ok(WorkerType::RiseCtl),
2507 "WORKER_TYPE_COMPACTOR" => Ok(WorkerType::Compactor),
2508 "WORKER_TYPE_META" => Ok(WorkerType::Meta),
2509 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2510 }
2511 }
2512 }
2513 deserializer.deserialize_any(GeneratedVisitor)
2514 }
2515}