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