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