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 OptionalUint32 {
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 use serde::ser::SerializeStruct;
1025 let mut len = 0;
1026 if self.value.is_some() {
1027 len += 1;
1028 }
1029 let mut struct_ser = serializer.serialize_struct("common.OptionalUint32", len)?;
1030 if let Some(v) = self.value.as_ref() {
1031 struct_ser.serialize_field("value", v)?;
1032 }
1033 struct_ser.end()
1034 }
1035}
1036impl<'de> serde::Deserialize<'de> for OptionalUint32 {
1037 #[allow(deprecated)]
1038 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1039 where
1040 D: serde::Deserializer<'de>,
1041 {
1042 const FIELDS: &[&str] = &[
1043 "value",
1044 ];
1045
1046 #[allow(clippy::enum_variant_names)]
1047 enum GeneratedField {
1048 Value,
1049 }
1050 impl<'de> serde::Deserialize<'de> for GeneratedField {
1051 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1052 where
1053 D: serde::Deserializer<'de>,
1054 {
1055 struct GeneratedVisitor;
1056
1057 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1058 type Value = GeneratedField;
1059
1060 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1061 write!(formatter, "expected one of: {:?}", &FIELDS)
1062 }
1063
1064 #[allow(unused_variables)]
1065 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1066 where
1067 E: serde::de::Error,
1068 {
1069 match value {
1070 "value" => Ok(GeneratedField::Value),
1071 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1072 }
1073 }
1074 }
1075 deserializer.deserialize_identifier(GeneratedVisitor)
1076 }
1077 }
1078 struct GeneratedVisitor;
1079 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1080 type Value = OptionalUint32;
1081
1082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1083 formatter.write_str("struct common.OptionalUint32")
1084 }
1085
1086 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OptionalUint32, V::Error>
1087 where
1088 V: serde::de::MapAccess<'de>,
1089 {
1090 let mut value__ = None;
1091 while let Some(k) = map_.next_key()? {
1092 match k {
1093 GeneratedField::Value => {
1094 if value__.is_some() {
1095 return Err(serde::de::Error::duplicate_field("value"));
1096 }
1097 value__ =
1098 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1099 ;
1100 }
1101 }
1102 }
1103 Ok(OptionalUint32 {
1104 value: value__,
1105 })
1106 }
1107 }
1108 deserializer.deserialize_struct("common.OptionalUint32", FIELDS, GeneratedVisitor)
1109 }
1110}
1111impl serde::Serialize for OptionalUint64 {
1112 #[allow(deprecated)]
1113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1114 where
1115 S: serde::Serializer,
1116 {
1117 use serde::ser::SerializeStruct;
1118 let mut len = 0;
1119 if self.value.is_some() {
1120 len += 1;
1121 }
1122 let mut struct_ser = serializer.serialize_struct("common.OptionalUint64", len)?;
1123 if let Some(v) = self.value.as_ref() {
1124 #[allow(clippy::needless_borrow)]
1125 #[allow(clippy::needless_borrows_for_generic_args)]
1126 struct_ser.serialize_field("value", ToString::to_string(&v).as_str())?;
1127 }
1128 struct_ser.end()
1129 }
1130}
1131impl<'de> serde::Deserialize<'de> for OptionalUint64 {
1132 #[allow(deprecated)]
1133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1134 where
1135 D: serde::Deserializer<'de>,
1136 {
1137 const FIELDS: &[&str] = &[
1138 "value",
1139 ];
1140
1141 #[allow(clippy::enum_variant_names)]
1142 enum GeneratedField {
1143 Value,
1144 }
1145 impl<'de> serde::Deserialize<'de> for GeneratedField {
1146 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1147 where
1148 D: serde::Deserializer<'de>,
1149 {
1150 struct GeneratedVisitor;
1151
1152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1153 type Value = GeneratedField;
1154
1155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1156 write!(formatter, "expected one of: {:?}", &FIELDS)
1157 }
1158
1159 #[allow(unused_variables)]
1160 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1161 where
1162 E: serde::de::Error,
1163 {
1164 match value {
1165 "value" => Ok(GeneratedField::Value),
1166 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1167 }
1168 }
1169 }
1170 deserializer.deserialize_identifier(GeneratedVisitor)
1171 }
1172 }
1173 struct GeneratedVisitor;
1174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1175 type Value = OptionalUint64;
1176
1177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1178 formatter.write_str("struct common.OptionalUint64")
1179 }
1180
1181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OptionalUint64, V::Error>
1182 where
1183 V: serde::de::MapAccess<'de>,
1184 {
1185 let mut value__ = None;
1186 while let Some(k) = map_.next_key()? {
1187 match k {
1188 GeneratedField::Value => {
1189 if value__.is_some() {
1190 return Err(serde::de::Error::duplicate_field("value"));
1191 }
1192 value__ =
1193 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1194 ;
1195 }
1196 }
1197 }
1198 Ok(OptionalUint64 {
1199 value: value__,
1200 })
1201 }
1202 }
1203 deserializer.deserialize_struct("common.OptionalUint64", FIELDS, GeneratedVisitor)
1204 }
1205}
1206impl serde::Serialize for OrderType {
1207 #[allow(deprecated)]
1208 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1209 where
1210 S: serde::Serializer,
1211 {
1212 use serde::ser::SerializeStruct;
1213 let mut len = 0;
1214 if self.direction != 0 {
1215 len += 1;
1216 }
1217 if self.nulls_are != 0 {
1218 len += 1;
1219 }
1220 let mut struct_ser = serializer.serialize_struct("common.OrderType", len)?;
1221 if self.direction != 0 {
1222 let v = Direction::try_from(self.direction)
1223 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?;
1224 struct_ser.serialize_field("direction", &v)?;
1225 }
1226 if self.nulls_are != 0 {
1227 let v = NullsAre::try_from(self.nulls_are)
1228 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.nulls_are)))?;
1229 struct_ser.serialize_field("nullsAre", &v)?;
1230 }
1231 struct_ser.end()
1232 }
1233}
1234impl<'de> serde::Deserialize<'de> for OrderType {
1235 #[allow(deprecated)]
1236 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1237 where
1238 D: serde::Deserializer<'de>,
1239 {
1240 const FIELDS: &[&str] = &[
1241 "direction",
1242 "nulls_are",
1243 "nullsAre",
1244 ];
1245
1246 #[allow(clippy::enum_variant_names)]
1247 enum GeneratedField {
1248 Direction,
1249 NullsAre,
1250 }
1251 impl<'de> serde::Deserialize<'de> for GeneratedField {
1252 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1253 where
1254 D: serde::Deserializer<'de>,
1255 {
1256 struct GeneratedVisitor;
1257
1258 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1259 type Value = GeneratedField;
1260
1261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1262 write!(formatter, "expected one of: {:?}", &FIELDS)
1263 }
1264
1265 #[allow(unused_variables)]
1266 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1267 where
1268 E: serde::de::Error,
1269 {
1270 match value {
1271 "direction" => Ok(GeneratedField::Direction),
1272 "nullsAre" | "nulls_are" => Ok(GeneratedField::NullsAre),
1273 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1274 }
1275 }
1276 }
1277 deserializer.deserialize_identifier(GeneratedVisitor)
1278 }
1279 }
1280 struct GeneratedVisitor;
1281 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1282 type Value = OrderType;
1283
1284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1285 formatter.write_str("struct common.OrderType")
1286 }
1287
1288 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OrderType, V::Error>
1289 where
1290 V: serde::de::MapAccess<'de>,
1291 {
1292 let mut direction__ = None;
1293 let mut nulls_are__ = None;
1294 while let Some(k) = map_.next_key()? {
1295 match k {
1296 GeneratedField::Direction => {
1297 if direction__.is_some() {
1298 return Err(serde::de::Error::duplicate_field("direction"));
1299 }
1300 direction__ = Some(map_.next_value::<Direction>()? as i32);
1301 }
1302 GeneratedField::NullsAre => {
1303 if nulls_are__.is_some() {
1304 return Err(serde::de::Error::duplicate_field("nullsAre"));
1305 }
1306 nulls_are__ = Some(map_.next_value::<NullsAre>()? as i32);
1307 }
1308 }
1309 }
1310 Ok(OrderType {
1311 direction: direction__.unwrap_or_default(),
1312 nulls_are: nulls_are__.unwrap_or_default(),
1313 })
1314 }
1315 }
1316 deserializer.deserialize_struct("common.OrderType", FIELDS, GeneratedVisitor)
1317 }
1318}
1319impl serde::Serialize for Status {
1320 #[allow(deprecated)]
1321 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1322 where
1323 S: serde::Serializer,
1324 {
1325 use serde::ser::SerializeStruct;
1326 let mut len = 0;
1327 if self.code != 0 {
1328 len += 1;
1329 }
1330 if !self.message.is_empty() {
1331 len += 1;
1332 }
1333 let mut struct_ser = serializer.serialize_struct("common.Status", len)?;
1334 if self.code != 0 {
1335 let v = status::Code::try_from(self.code)
1336 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.code)))?;
1337 struct_ser.serialize_field("code", &v)?;
1338 }
1339 if !self.message.is_empty() {
1340 struct_ser.serialize_field("message", &self.message)?;
1341 }
1342 struct_ser.end()
1343 }
1344}
1345impl<'de> serde::Deserialize<'de> for Status {
1346 #[allow(deprecated)]
1347 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1348 where
1349 D: serde::Deserializer<'de>,
1350 {
1351 const FIELDS: &[&str] = &[
1352 "code",
1353 "message",
1354 ];
1355
1356 #[allow(clippy::enum_variant_names)]
1357 enum GeneratedField {
1358 Code,
1359 Message,
1360 }
1361 impl<'de> serde::Deserialize<'de> for GeneratedField {
1362 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1363 where
1364 D: serde::Deserializer<'de>,
1365 {
1366 struct GeneratedVisitor;
1367
1368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1369 type Value = GeneratedField;
1370
1371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1372 write!(formatter, "expected one of: {:?}", &FIELDS)
1373 }
1374
1375 #[allow(unused_variables)]
1376 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1377 where
1378 E: serde::de::Error,
1379 {
1380 match value {
1381 "code" => Ok(GeneratedField::Code),
1382 "message" => Ok(GeneratedField::Message),
1383 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1384 }
1385 }
1386 }
1387 deserializer.deserialize_identifier(GeneratedVisitor)
1388 }
1389 }
1390 struct GeneratedVisitor;
1391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1392 type Value = Status;
1393
1394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1395 formatter.write_str("struct common.Status")
1396 }
1397
1398 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Status, V::Error>
1399 where
1400 V: serde::de::MapAccess<'de>,
1401 {
1402 let mut code__ = None;
1403 let mut message__ = None;
1404 while let Some(k) = map_.next_key()? {
1405 match k {
1406 GeneratedField::Code => {
1407 if code__.is_some() {
1408 return Err(serde::de::Error::duplicate_field("code"));
1409 }
1410 code__ = Some(map_.next_value::<status::Code>()? as i32);
1411 }
1412 GeneratedField::Message => {
1413 if message__.is_some() {
1414 return Err(serde::de::Error::duplicate_field("message"));
1415 }
1416 message__ = Some(map_.next_value()?);
1417 }
1418 }
1419 }
1420 Ok(Status {
1421 code: code__.unwrap_or_default(),
1422 message: message__.unwrap_or_default(),
1423 })
1424 }
1425 }
1426 deserializer.deserialize_struct("common.Status", FIELDS, GeneratedVisitor)
1427 }
1428}
1429impl serde::Serialize for status::Code {
1430 #[allow(deprecated)]
1431 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1432 where
1433 S: serde::Serializer,
1434 {
1435 let variant = match self {
1436 Self::Unspecified => "UNSPECIFIED",
1437 Self::Ok => "OK",
1438 Self::UnknownWorker => "UNKNOWN_WORKER",
1439 };
1440 serializer.serialize_str(variant)
1441 }
1442}
1443impl<'de> serde::Deserialize<'de> for status::Code {
1444 #[allow(deprecated)]
1445 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1446 where
1447 D: serde::Deserializer<'de>,
1448 {
1449 const FIELDS: &[&str] = &[
1450 "UNSPECIFIED",
1451 "OK",
1452 "UNKNOWN_WORKER",
1453 ];
1454
1455 struct GeneratedVisitor;
1456
1457 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1458 type Value = status::Code;
1459
1460 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1461 write!(formatter, "expected one of: {:?}", &FIELDS)
1462 }
1463
1464 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1465 where
1466 E: serde::de::Error,
1467 {
1468 i32::try_from(v)
1469 .ok()
1470 .and_then(|x| x.try_into().ok())
1471 .ok_or_else(|| {
1472 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1473 })
1474 }
1475
1476 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1477 where
1478 E: serde::de::Error,
1479 {
1480 i32::try_from(v)
1481 .ok()
1482 .and_then(|x| x.try_into().ok())
1483 .ok_or_else(|| {
1484 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1485 })
1486 }
1487
1488 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1489 where
1490 E: serde::de::Error,
1491 {
1492 match value {
1493 "UNSPECIFIED" => Ok(status::Code::Unspecified),
1494 "OK" => Ok(status::Code::Ok),
1495 "UNKNOWN_WORKER" => Ok(status::Code::UnknownWorker),
1496 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1497 }
1498 }
1499 }
1500 deserializer.deserialize_any(GeneratedVisitor)
1501 }
1502}
1503impl serde::Serialize for Uint32Vector {
1504 #[allow(deprecated)]
1505 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1506 where
1507 S: serde::Serializer,
1508 {
1509 use serde::ser::SerializeStruct;
1510 let mut len = 0;
1511 if !self.data.is_empty() {
1512 len += 1;
1513 }
1514 let mut struct_ser = serializer.serialize_struct("common.Uint32Vector", len)?;
1515 if !self.data.is_empty() {
1516 struct_ser.serialize_field("data", &self.data)?;
1517 }
1518 struct_ser.end()
1519 }
1520}
1521impl<'de> serde::Deserialize<'de> for Uint32Vector {
1522 #[allow(deprecated)]
1523 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1524 where
1525 D: serde::Deserializer<'de>,
1526 {
1527 const FIELDS: &[&str] = &[
1528 "data",
1529 ];
1530
1531 #[allow(clippy::enum_variant_names)]
1532 enum GeneratedField {
1533 Data,
1534 }
1535 impl<'de> serde::Deserialize<'de> for GeneratedField {
1536 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1537 where
1538 D: serde::Deserializer<'de>,
1539 {
1540 struct GeneratedVisitor;
1541
1542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1543 type Value = GeneratedField;
1544
1545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1546 write!(formatter, "expected one of: {:?}", &FIELDS)
1547 }
1548
1549 #[allow(unused_variables)]
1550 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1551 where
1552 E: serde::de::Error,
1553 {
1554 match value {
1555 "data" => Ok(GeneratedField::Data),
1556 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1557 }
1558 }
1559 }
1560 deserializer.deserialize_identifier(GeneratedVisitor)
1561 }
1562 }
1563 struct GeneratedVisitor;
1564 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1565 type Value = Uint32Vector;
1566
1567 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1568 formatter.write_str("struct common.Uint32Vector")
1569 }
1570
1571 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Uint32Vector, V::Error>
1572 where
1573 V: serde::de::MapAccess<'de>,
1574 {
1575 let mut data__ = None;
1576 while let Some(k) = map_.next_key()? {
1577 match k {
1578 GeneratedField::Data => {
1579 if data__.is_some() {
1580 return Err(serde::de::Error::duplicate_field("data"));
1581 }
1582 data__ =
1583 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1584 .into_iter().map(|x| x.0).collect())
1585 ;
1586 }
1587 }
1588 }
1589 Ok(Uint32Vector {
1590 data: data__.unwrap_or_default(),
1591 })
1592 }
1593 }
1594 deserializer.deserialize_struct("common.Uint32Vector", FIELDS, GeneratedVisitor)
1595 }
1596}
1597impl serde::Serialize for WorkerNode {
1598 #[allow(deprecated)]
1599 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1600 where
1601 S: serde::Serializer,
1602 {
1603 use serde::ser::SerializeStruct;
1604 let mut len = 0;
1605 if self.id != 0 {
1606 len += 1;
1607 }
1608 if self.r#type != 0 {
1609 len += 1;
1610 }
1611 if self.host.is_some() {
1612 len += 1;
1613 }
1614 if self.state != 0 {
1615 len += 1;
1616 }
1617 if self.property.is_some() {
1618 len += 1;
1619 }
1620 if self.transactional_id.is_some() {
1621 len += 1;
1622 }
1623 if self.resource.is_some() {
1624 len += 1;
1625 }
1626 if self.started_at.is_some() {
1627 len += 1;
1628 }
1629 let mut struct_ser = serializer.serialize_struct("common.WorkerNode", len)?;
1630 if self.id != 0 {
1631 struct_ser.serialize_field("id", &self.id)?;
1632 }
1633 if self.r#type != 0 {
1634 let v = WorkerType::try_from(self.r#type)
1635 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
1636 struct_ser.serialize_field("type", &v)?;
1637 }
1638 if let Some(v) = self.host.as_ref() {
1639 struct_ser.serialize_field("host", v)?;
1640 }
1641 if self.state != 0 {
1642 let v = worker_node::State::try_from(self.state)
1643 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
1644 struct_ser.serialize_field("state", &v)?;
1645 }
1646 if let Some(v) = self.property.as_ref() {
1647 struct_ser.serialize_field("property", v)?;
1648 }
1649 if let Some(v) = self.transactional_id.as_ref() {
1650 struct_ser.serialize_field("transactionalId", v)?;
1651 }
1652 if let Some(v) = self.resource.as_ref() {
1653 struct_ser.serialize_field("resource", v)?;
1654 }
1655 if let Some(v) = self.started_at.as_ref() {
1656 #[allow(clippy::needless_borrow)]
1657 #[allow(clippy::needless_borrows_for_generic_args)]
1658 struct_ser.serialize_field("startedAt", ToString::to_string(&v).as_str())?;
1659 }
1660 struct_ser.end()
1661 }
1662}
1663impl<'de> serde::Deserialize<'de> for WorkerNode {
1664 #[allow(deprecated)]
1665 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1666 where
1667 D: serde::Deserializer<'de>,
1668 {
1669 const FIELDS: &[&str] = &[
1670 "id",
1671 "type",
1672 "host",
1673 "state",
1674 "property",
1675 "transactional_id",
1676 "transactionalId",
1677 "resource",
1678 "started_at",
1679 "startedAt",
1680 ];
1681
1682 #[allow(clippy::enum_variant_names)]
1683 enum GeneratedField {
1684 Id,
1685 Type,
1686 Host,
1687 State,
1688 Property,
1689 TransactionalId,
1690 Resource,
1691 StartedAt,
1692 }
1693 impl<'de> serde::Deserialize<'de> for GeneratedField {
1694 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1695 where
1696 D: serde::Deserializer<'de>,
1697 {
1698 struct GeneratedVisitor;
1699
1700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1701 type Value = GeneratedField;
1702
1703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1704 write!(formatter, "expected one of: {:?}", &FIELDS)
1705 }
1706
1707 #[allow(unused_variables)]
1708 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1709 where
1710 E: serde::de::Error,
1711 {
1712 match value {
1713 "id" => Ok(GeneratedField::Id),
1714 "type" => Ok(GeneratedField::Type),
1715 "host" => Ok(GeneratedField::Host),
1716 "state" => Ok(GeneratedField::State),
1717 "property" => Ok(GeneratedField::Property),
1718 "transactionalId" | "transactional_id" => Ok(GeneratedField::TransactionalId),
1719 "resource" => Ok(GeneratedField::Resource),
1720 "startedAt" | "started_at" => Ok(GeneratedField::StartedAt),
1721 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1722 }
1723 }
1724 }
1725 deserializer.deserialize_identifier(GeneratedVisitor)
1726 }
1727 }
1728 struct GeneratedVisitor;
1729 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1730 type Value = WorkerNode;
1731
1732 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1733 formatter.write_str("struct common.WorkerNode")
1734 }
1735
1736 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerNode, V::Error>
1737 where
1738 V: serde::de::MapAccess<'de>,
1739 {
1740 let mut id__ = None;
1741 let mut r#type__ = None;
1742 let mut host__ = None;
1743 let mut state__ = None;
1744 let mut property__ = None;
1745 let mut transactional_id__ = None;
1746 let mut resource__ = None;
1747 let mut started_at__ = None;
1748 while let Some(k) = map_.next_key()? {
1749 match k {
1750 GeneratedField::Id => {
1751 if id__.is_some() {
1752 return Err(serde::de::Error::duplicate_field("id"));
1753 }
1754 id__ =
1755 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1756 ;
1757 }
1758 GeneratedField::Type => {
1759 if r#type__.is_some() {
1760 return Err(serde::de::Error::duplicate_field("type"));
1761 }
1762 r#type__ = Some(map_.next_value::<WorkerType>()? as i32);
1763 }
1764 GeneratedField::Host => {
1765 if host__.is_some() {
1766 return Err(serde::de::Error::duplicate_field("host"));
1767 }
1768 host__ = map_.next_value()?;
1769 }
1770 GeneratedField::State => {
1771 if state__.is_some() {
1772 return Err(serde::de::Error::duplicate_field("state"));
1773 }
1774 state__ = Some(map_.next_value::<worker_node::State>()? as i32);
1775 }
1776 GeneratedField::Property => {
1777 if property__.is_some() {
1778 return Err(serde::de::Error::duplicate_field("property"));
1779 }
1780 property__ = map_.next_value()?;
1781 }
1782 GeneratedField::TransactionalId => {
1783 if transactional_id__.is_some() {
1784 return Err(serde::de::Error::duplicate_field("transactionalId"));
1785 }
1786 transactional_id__ =
1787 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1788 ;
1789 }
1790 GeneratedField::Resource => {
1791 if resource__.is_some() {
1792 return Err(serde::de::Error::duplicate_field("resource"));
1793 }
1794 resource__ = map_.next_value()?;
1795 }
1796 GeneratedField::StartedAt => {
1797 if started_at__.is_some() {
1798 return Err(serde::de::Error::duplicate_field("startedAt"));
1799 }
1800 started_at__ =
1801 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1802 ;
1803 }
1804 }
1805 }
1806 Ok(WorkerNode {
1807 id: id__.unwrap_or_default(),
1808 r#type: r#type__.unwrap_or_default(),
1809 host: host__,
1810 state: state__.unwrap_or_default(),
1811 property: property__,
1812 transactional_id: transactional_id__,
1813 resource: resource__,
1814 started_at: started_at__,
1815 })
1816 }
1817 }
1818 deserializer.deserialize_struct("common.WorkerNode", FIELDS, GeneratedVisitor)
1819 }
1820}
1821impl serde::Serialize for worker_node::Property {
1822 #[allow(deprecated)]
1823 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1824 where
1825 S: serde::Serializer,
1826 {
1827 use serde::ser::SerializeStruct;
1828 let mut len = 0;
1829 if self.is_streaming {
1830 len += 1;
1831 }
1832 if self.is_serving {
1833 len += 1;
1834 }
1835 if self.is_unschedulable {
1836 len += 1;
1837 }
1838 if !self.internal_rpc_host_addr.is_empty() {
1839 len += 1;
1840 }
1841 if self.parallelism != 0 {
1842 len += 1;
1843 }
1844 if self.resource_group.is_some() {
1845 len += 1;
1846 }
1847 let mut struct_ser = serializer.serialize_struct("common.WorkerNode.Property", len)?;
1848 if self.is_streaming {
1849 struct_ser.serialize_field("isStreaming", &self.is_streaming)?;
1850 }
1851 if self.is_serving {
1852 struct_ser.serialize_field("isServing", &self.is_serving)?;
1853 }
1854 if self.is_unschedulable {
1855 struct_ser.serialize_field("isUnschedulable", &self.is_unschedulable)?;
1856 }
1857 if !self.internal_rpc_host_addr.is_empty() {
1858 struct_ser.serialize_field("internalRpcHostAddr", &self.internal_rpc_host_addr)?;
1859 }
1860 if self.parallelism != 0 {
1861 struct_ser.serialize_field("parallelism", &self.parallelism)?;
1862 }
1863 if let Some(v) = self.resource_group.as_ref() {
1864 struct_ser.serialize_field("resourceGroup", v)?;
1865 }
1866 struct_ser.end()
1867 }
1868}
1869impl<'de> serde::Deserialize<'de> for worker_node::Property {
1870 #[allow(deprecated)]
1871 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1872 where
1873 D: serde::Deserializer<'de>,
1874 {
1875 const FIELDS: &[&str] = &[
1876 "is_streaming",
1877 "isStreaming",
1878 "is_serving",
1879 "isServing",
1880 "is_unschedulable",
1881 "isUnschedulable",
1882 "internal_rpc_host_addr",
1883 "internalRpcHostAddr",
1884 "parallelism",
1885 "resource_group",
1886 "resourceGroup",
1887 ];
1888
1889 #[allow(clippy::enum_variant_names)]
1890 enum GeneratedField {
1891 IsStreaming,
1892 IsServing,
1893 IsUnschedulable,
1894 InternalRpcHostAddr,
1895 Parallelism,
1896 ResourceGroup,
1897 }
1898 impl<'de> serde::Deserialize<'de> for GeneratedField {
1899 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1900 where
1901 D: serde::Deserializer<'de>,
1902 {
1903 struct GeneratedVisitor;
1904
1905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1906 type Value = GeneratedField;
1907
1908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1909 write!(formatter, "expected one of: {:?}", &FIELDS)
1910 }
1911
1912 #[allow(unused_variables)]
1913 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1914 where
1915 E: serde::de::Error,
1916 {
1917 match value {
1918 "isStreaming" | "is_streaming" => Ok(GeneratedField::IsStreaming),
1919 "isServing" | "is_serving" => Ok(GeneratedField::IsServing),
1920 "isUnschedulable" | "is_unschedulable" => Ok(GeneratedField::IsUnschedulable),
1921 "internalRpcHostAddr" | "internal_rpc_host_addr" => Ok(GeneratedField::InternalRpcHostAddr),
1922 "parallelism" => Ok(GeneratedField::Parallelism),
1923 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
1924 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1925 }
1926 }
1927 }
1928 deserializer.deserialize_identifier(GeneratedVisitor)
1929 }
1930 }
1931 struct GeneratedVisitor;
1932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1933 type Value = worker_node::Property;
1934
1935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1936 formatter.write_str("struct common.WorkerNode.Property")
1937 }
1938
1939 fn visit_map<V>(self, mut map_: V) -> std::result::Result<worker_node::Property, V::Error>
1940 where
1941 V: serde::de::MapAccess<'de>,
1942 {
1943 let mut is_streaming__ = None;
1944 let mut is_serving__ = None;
1945 let mut is_unschedulable__ = None;
1946 let mut internal_rpc_host_addr__ = None;
1947 let mut parallelism__ = None;
1948 let mut resource_group__ = None;
1949 while let Some(k) = map_.next_key()? {
1950 match k {
1951 GeneratedField::IsStreaming => {
1952 if is_streaming__.is_some() {
1953 return Err(serde::de::Error::duplicate_field("isStreaming"));
1954 }
1955 is_streaming__ = Some(map_.next_value()?);
1956 }
1957 GeneratedField::IsServing => {
1958 if is_serving__.is_some() {
1959 return Err(serde::de::Error::duplicate_field("isServing"));
1960 }
1961 is_serving__ = Some(map_.next_value()?);
1962 }
1963 GeneratedField::IsUnschedulable => {
1964 if is_unschedulable__.is_some() {
1965 return Err(serde::de::Error::duplicate_field("isUnschedulable"));
1966 }
1967 is_unschedulable__ = Some(map_.next_value()?);
1968 }
1969 GeneratedField::InternalRpcHostAddr => {
1970 if internal_rpc_host_addr__.is_some() {
1971 return Err(serde::de::Error::duplicate_field("internalRpcHostAddr"));
1972 }
1973 internal_rpc_host_addr__ = Some(map_.next_value()?);
1974 }
1975 GeneratedField::Parallelism => {
1976 if parallelism__.is_some() {
1977 return Err(serde::de::Error::duplicate_field("parallelism"));
1978 }
1979 parallelism__ =
1980 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1981 ;
1982 }
1983 GeneratedField::ResourceGroup => {
1984 if resource_group__.is_some() {
1985 return Err(serde::de::Error::duplicate_field("resourceGroup"));
1986 }
1987 resource_group__ = map_.next_value()?;
1988 }
1989 }
1990 }
1991 Ok(worker_node::Property {
1992 is_streaming: is_streaming__.unwrap_or_default(),
1993 is_serving: is_serving__.unwrap_or_default(),
1994 is_unschedulable: is_unschedulable__.unwrap_or_default(),
1995 internal_rpc_host_addr: internal_rpc_host_addr__.unwrap_or_default(),
1996 parallelism: parallelism__.unwrap_or_default(),
1997 resource_group: resource_group__,
1998 })
1999 }
2000 }
2001 deserializer.deserialize_struct("common.WorkerNode.Property", FIELDS, GeneratedVisitor)
2002 }
2003}
2004impl serde::Serialize for worker_node::Resource {
2005 #[allow(deprecated)]
2006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2007 where
2008 S: serde::Serializer,
2009 {
2010 use serde::ser::SerializeStruct;
2011 let mut len = 0;
2012 if !self.rw_version.is_empty() {
2013 len += 1;
2014 }
2015 if self.total_memory_bytes != 0 {
2016 len += 1;
2017 }
2018 if self.total_cpu_cores != 0 {
2019 len += 1;
2020 }
2021 let mut struct_ser = serializer.serialize_struct("common.WorkerNode.Resource", len)?;
2022 if !self.rw_version.is_empty() {
2023 struct_ser.serialize_field("rwVersion", &self.rw_version)?;
2024 }
2025 if self.total_memory_bytes != 0 {
2026 #[allow(clippy::needless_borrow)]
2027 #[allow(clippy::needless_borrows_for_generic_args)]
2028 struct_ser.serialize_field("totalMemoryBytes", ToString::to_string(&self.total_memory_bytes).as_str())?;
2029 }
2030 if self.total_cpu_cores != 0 {
2031 #[allow(clippy::needless_borrow)]
2032 #[allow(clippy::needless_borrows_for_generic_args)]
2033 struct_ser.serialize_field("totalCpuCores", ToString::to_string(&self.total_cpu_cores).as_str())?;
2034 }
2035 struct_ser.end()
2036 }
2037}
2038impl<'de> serde::Deserialize<'de> for worker_node::Resource {
2039 #[allow(deprecated)]
2040 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2041 where
2042 D: serde::Deserializer<'de>,
2043 {
2044 const FIELDS: &[&str] = &[
2045 "rw_version",
2046 "rwVersion",
2047 "total_memory_bytes",
2048 "totalMemoryBytes",
2049 "total_cpu_cores",
2050 "totalCpuCores",
2051 ];
2052
2053 #[allow(clippy::enum_variant_names)]
2054 enum GeneratedField {
2055 RwVersion,
2056 TotalMemoryBytes,
2057 TotalCpuCores,
2058 }
2059 impl<'de> serde::Deserialize<'de> for GeneratedField {
2060 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2061 where
2062 D: serde::Deserializer<'de>,
2063 {
2064 struct GeneratedVisitor;
2065
2066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2067 type Value = GeneratedField;
2068
2069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2070 write!(formatter, "expected one of: {:?}", &FIELDS)
2071 }
2072
2073 #[allow(unused_variables)]
2074 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2075 where
2076 E: serde::de::Error,
2077 {
2078 match value {
2079 "rwVersion" | "rw_version" => Ok(GeneratedField::RwVersion),
2080 "totalMemoryBytes" | "total_memory_bytes" => Ok(GeneratedField::TotalMemoryBytes),
2081 "totalCpuCores" | "total_cpu_cores" => Ok(GeneratedField::TotalCpuCores),
2082 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2083 }
2084 }
2085 }
2086 deserializer.deserialize_identifier(GeneratedVisitor)
2087 }
2088 }
2089 struct GeneratedVisitor;
2090 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2091 type Value = worker_node::Resource;
2092
2093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2094 formatter.write_str("struct common.WorkerNode.Resource")
2095 }
2096
2097 fn visit_map<V>(self, mut map_: V) -> std::result::Result<worker_node::Resource, V::Error>
2098 where
2099 V: serde::de::MapAccess<'de>,
2100 {
2101 let mut rw_version__ = None;
2102 let mut total_memory_bytes__ = None;
2103 let mut total_cpu_cores__ = None;
2104 while let Some(k) = map_.next_key()? {
2105 match k {
2106 GeneratedField::RwVersion => {
2107 if rw_version__.is_some() {
2108 return Err(serde::de::Error::duplicate_field("rwVersion"));
2109 }
2110 rw_version__ = Some(map_.next_value()?);
2111 }
2112 GeneratedField::TotalMemoryBytes => {
2113 if total_memory_bytes__.is_some() {
2114 return Err(serde::de::Error::duplicate_field("totalMemoryBytes"));
2115 }
2116 total_memory_bytes__ =
2117 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2118 ;
2119 }
2120 GeneratedField::TotalCpuCores => {
2121 if total_cpu_cores__.is_some() {
2122 return Err(serde::de::Error::duplicate_field("totalCpuCores"));
2123 }
2124 total_cpu_cores__ =
2125 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2126 ;
2127 }
2128 }
2129 }
2130 Ok(worker_node::Resource {
2131 rw_version: rw_version__.unwrap_or_default(),
2132 total_memory_bytes: total_memory_bytes__.unwrap_or_default(),
2133 total_cpu_cores: total_cpu_cores__.unwrap_or_default(),
2134 })
2135 }
2136 }
2137 deserializer.deserialize_struct("common.WorkerNode.Resource", FIELDS, GeneratedVisitor)
2138 }
2139}
2140impl serde::Serialize for worker_node::State {
2141 #[allow(deprecated)]
2142 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2143 where
2144 S: serde::Serializer,
2145 {
2146 let variant = match self {
2147 Self::Unspecified => "UNSPECIFIED",
2148 Self::Starting => "STARTING",
2149 Self::Running => "RUNNING",
2150 };
2151 serializer.serialize_str(variant)
2152 }
2153}
2154impl<'de> serde::Deserialize<'de> for worker_node::State {
2155 #[allow(deprecated)]
2156 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2157 where
2158 D: serde::Deserializer<'de>,
2159 {
2160 const FIELDS: &[&str] = &[
2161 "UNSPECIFIED",
2162 "STARTING",
2163 "RUNNING",
2164 ];
2165
2166 struct GeneratedVisitor;
2167
2168 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2169 type Value = worker_node::State;
2170
2171 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2172 write!(formatter, "expected one of: {:?}", &FIELDS)
2173 }
2174
2175 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2176 where
2177 E: serde::de::Error,
2178 {
2179 i32::try_from(v)
2180 .ok()
2181 .and_then(|x| x.try_into().ok())
2182 .ok_or_else(|| {
2183 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2184 })
2185 }
2186
2187 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2188 where
2189 E: serde::de::Error,
2190 {
2191 i32::try_from(v)
2192 .ok()
2193 .and_then(|x| x.try_into().ok())
2194 .ok_or_else(|| {
2195 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2196 })
2197 }
2198
2199 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2200 where
2201 E: serde::de::Error,
2202 {
2203 match value {
2204 "UNSPECIFIED" => Ok(worker_node::State::Unspecified),
2205 "STARTING" => Ok(worker_node::State::Starting),
2206 "RUNNING" => Ok(worker_node::State::Running),
2207 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2208 }
2209 }
2210 }
2211 deserializer.deserialize_any(GeneratedVisitor)
2212 }
2213}
2214impl serde::Serialize for WorkerSlotMapping {
2215 #[allow(deprecated)]
2216 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2217 where
2218 S: serde::Serializer,
2219 {
2220 use serde::ser::SerializeStruct;
2221 let mut len = 0;
2222 if !self.original_indices.is_empty() {
2223 len += 1;
2224 }
2225 if !self.data.is_empty() {
2226 len += 1;
2227 }
2228 let mut struct_ser = serializer.serialize_struct("common.WorkerSlotMapping", len)?;
2229 if !self.original_indices.is_empty() {
2230 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
2231 }
2232 if !self.data.is_empty() {
2233 struct_ser.serialize_field("data", &self.data.iter().map(ToString::to_string).collect::<Vec<_>>())?;
2234 }
2235 struct_ser.end()
2236 }
2237}
2238impl<'de> serde::Deserialize<'de> for WorkerSlotMapping {
2239 #[allow(deprecated)]
2240 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2241 where
2242 D: serde::Deserializer<'de>,
2243 {
2244 const FIELDS: &[&str] = &[
2245 "original_indices",
2246 "originalIndices",
2247 "data",
2248 ];
2249
2250 #[allow(clippy::enum_variant_names)]
2251 enum GeneratedField {
2252 OriginalIndices,
2253 Data,
2254 }
2255 impl<'de> serde::Deserialize<'de> for GeneratedField {
2256 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2257 where
2258 D: serde::Deserializer<'de>,
2259 {
2260 struct GeneratedVisitor;
2261
2262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2263 type Value = GeneratedField;
2264
2265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2266 write!(formatter, "expected one of: {:?}", &FIELDS)
2267 }
2268
2269 #[allow(unused_variables)]
2270 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2271 where
2272 E: serde::de::Error,
2273 {
2274 match value {
2275 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
2276 "data" => Ok(GeneratedField::Data),
2277 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2278 }
2279 }
2280 }
2281 deserializer.deserialize_identifier(GeneratedVisitor)
2282 }
2283 }
2284 struct GeneratedVisitor;
2285 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2286 type Value = WorkerSlotMapping;
2287
2288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2289 formatter.write_str("struct common.WorkerSlotMapping")
2290 }
2291
2292 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerSlotMapping, V::Error>
2293 where
2294 V: serde::de::MapAccess<'de>,
2295 {
2296 let mut original_indices__ = None;
2297 let mut data__ = None;
2298 while let Some(k) = map_.next_key()? {
2299 match k {
2300 GeneratedField::OriginalIndices => {
2301 if original_indices__.is_some() {
2302 return Err(serde::de::Error::duplicate_field("originalIndices"));
2303 }
2304 original_indices__ =
2305 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2306 .into_iter().map(|x| x.0).collect())
2307 ;
2308 }
2309 GeneratedField::Data => {
2310 if data__.is_some() {
2311 return Err(serde::de::Error::duplicate_field("data"));
2312 }
2313 data__ =
2314 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2315 .into_iter().map(|x| x.0).collect())
2316 ;
2317 }
2318 }
2319 }
2320 Ok(WorkerSlotMapping {
2321 original_indices: original_indices__.unwrap_or_default(),
2322 data: data__.unwrap_or_default(),
2323 })
2324 }
2325 }
2326 deserializer.deserialize_struct("common.WorkerSlotMapping", FIELDS, GeneratedVisitor)
2327 }
2328}
2329impl serde::Serialize for WorkerType {
2330 #[allow(deprecated)]
2331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2332 where
2333 S: serde::Serializer,
2334 {
2335 let variant = match self {
2336 Self::Unspecified => "WORKER_TYPE_UNSPECIFIED",
2337 Self::Frontend => "WORKER_TYPE_FRONTEND",
2338 Self::ComputeNode => "WORKER_TYPE_COMPUTE_NODE",
2339 Self::RiseCtl => "WORKER_TYPE_RISE_CTL",
2340 Self::Compactor => "WORKER_TYPE_COMPACTOR",
2341 Self::Meta => "WORKER_TYPE_META",
2342 };
2343 serializer.serialize_str(variant)
2344 }
2345}
2346impl<'de> serde::Deserialize<'de> for WorkerType {
2347 #[allow(deprecated)]
2348 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2349 where
2350 D: serde::Deserializer<'de>,
2351 {
2352 const FIELDS: &[&str] = &[
2353 "WORKER_TYPE_UNSPECIFIED",
2354 "WORKER_TYPE_FRONTEND",
2355 "WORKER_TYPE_COMPUTE_NODE",
2356 "WORKER_TYPE_RISE_CTL",
2357 "WORKER_TYPE_COMPACTOR",
2358 "WORKER_TYPE_META",
2359 ];
2360
2361 struct GeneratedVisitor;
2362
2363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2364 type Value = WorkerType;
2365
2366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2367 write!(formatter, "expected one of: {:?}", &FIELDS)
2368 }
2369
2370 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2371 where
2372 E: serde::de::Error,
2373 {
2374 i32::try_from(v)
2375 .ok()
2376 .and_then(|x| x.try_into().ok())
2377 .ok_or_else(|| {
2378 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2379 })
2380 }
2381
2382 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2383 where
2384 E: serde::de::Error,
2385 {
2386 i32::try_from(v)
2387 .ok()
2388 .and_then(|x| x.try_into().ok())
2389 .ok_or_else(|| {
2390 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2391 })
2392 }
2393
2394 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2395 where
2396 E: serde::de::Error,
2397 {
2398 match value {
2399 "WORKER_TYPE_UNSPECIFIED" => Ok(WorkerType::Unspecified),
2400 "WORKER_TYPE_FRONTEND" => Ok(WorkerType::Frontend),
2401 "WORKER_TYPE_COMPUTE_NODE" => Ok(WorkerType::ComputeNode),
2402 "WORKER_TYPE_RISE_CTL" => Ok(WorkerType::RiseCtl),
2403 "WORKER_TYPE_COMPACTOR" => Ok(WorkerType::Compactor),
2404 "WORKER_TYPE_META" => Ok(WorkerType::Meta),
2405 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2406 }
2407 }
2408 }
2409 deserializer.deserialize_any(GeneratedVisitor)
2410 }
2411}