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