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