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