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 ColumnOrder {
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.column_index != 0 {
657 len += 1;
658 }
659 if self.order_type.is_some() {
660 len += 1;
661 }
662 let mut struct_ser = serializer.serialize_struct("common.ColumnOrder", len)?;
663 if self.column_index != 0 {
664 struct_ser.serialize_field("columnIndex", &self.column_index)?;
665 }
666 if let Some(v) = self.order_type.as_ref() {
667 struct_ser.serialize_field("orderType", v)?;
668 }
669 struct_ser.end()
670 }
671}
672impl<'de> serde::Deserialize<'de> for ColumnOrder {
673 #[allow(deprecated)]
674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
675 where
676 D: serde::Deserializer<'de>,
677 {
678 const FIELDS: &[&str] = &[
679 "column_index",
680 "columnIndex",
681 "order_type",
682 "orderType",
683 ];
684
685 #[allow(clippy::enum_variant_names)]
686 enum GeneratedField {
687 ColumnIndex,
688 OrderType,
689 }
690 impl<'de> serde::Deserialize<'de> for GeneratedField {
691 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
692 where
693 D: serde::Deserializer<'de>,
694 {
695 struct GeneratedVisitor;
696
697 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
698 type Value = GeneratedField;
699
700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
701 write!(formatter, "expected one of: {:?}", &FIELDS)
702 }
703
704 #[allow(unused_variables)]
705 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
706 where
707 E: serde::de::Error,
708 {
709 match value {
710 "columnIndex" | "column_index" => Ok(GeneratedField::ColumnIndex),
711 "orderType" | "order_type" => Ok(GeneratedField::OrderType),
712 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
713 }
714 }
715 }
716 deserializer.deserialize_identifier(GeneratedVisitor)
717 }
718 }
719 struct GeneratedVisitor;
720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
721 type Value = ColumnOrder;
722
723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
724 formatter.write_str("struct common.ColumnOrder")
725 }
726
727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ColumnOrder, V::Error>
728 where
729 V: serde::de::MapAccess<'de>,
730 {
731 let mut column_index__ = None;
732 let mut order_type__ = None;
733 while let Some(k) = map_.next_key()? {
734 match k {
735 GeneratedField::ColumnIndex => {
736 if column_index__.is_some() {
737 return Err(serde::de::Error::duplicate_field("columnIndex"));
738 }
739 column_index__ =
740 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
741 ;
742 }
743 GeneratedField::OrderType => {
744 if order_type__.is_some() {
745 return Err(serde::de::Error::duplicate_field("orderType"));
746 }
747 order_type__ = map_.next_value()?;
748 }
749 }
750 }
751 Ok(ColumnOrder {
752 column_index: column_index__.unwrap_or_default(),
753 order_type: order_type__,
754 })
755 }
756 }
757 deserializer.deserialize_struct("common.ColumnOrder", FIELDS, GeneratedVisitor)
758 }
759}
760impl serde::Serialize for Direction {
761 #[allow(deprecated)]
762 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
763 where
764 S: serde::Serializer,
765 {
766 let variant = match self {
767 Self::Unspecified => "DIRECTION_UNSPECIFIED",
768 Self::Ascending => "DIRECTION_ASCENDING",
769 Self::Descending => "DIRECTION_DESCENDING",
770 };
771 serializer.serialize_str(variant)
772 }
773}
774impl<'de> serde::Deserialize<'de> for Direction {
775 #[allow(deprecated)]
776 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
777 where
778 D: serde::Deserializer<'de>,
779 {
780 const FIELDS: &[&str] = &[
781 "DIRECTION_UNSPECIFIED",
782 "DIRECTION_ASCENDING",
783 "DIRECTION_DESCENDING",
784 ];
785
786 struct GeneratedVisitor;
787
788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
789 type Value = Direction;
790
791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
792 write!(formatter, "expected one of: {:?}", &FIELDS)
793 }
794
795 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
796 where
797 E: serde::de::Error,
798 {
799 i32::try_from(v)
800 .ok()
801 .and_then(|x| x.try_into().ok())
802 .ok_or_else(|| {
803 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
804 })
805 }
806
807 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
808 where
809 E: serde::de::Error,
810 {
811 i32::try_from(v)
812 .ok()
813 .and_then(|x| x.try_into().ok())
814 .ok_or_else(|| {
815 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
816 })
817 }
818
819 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
820 where
821 E: serde::de::Error,
822 {
823 match value {
824 "DIRECTION_UNSPECIFIED" => Ok(Direction::Unspecified),
825 "DIRECTION_ASCENDING" => Ok(Direction::Ascending),
826 "DIRECTION_DESCENDING" => Ok(Direction::Descending),
827 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
828 }
829 }
830 }
831 deserializer.deserialize_any(GeneratedVisitor)
832 }
833}
834impl serde::Serialize for DistanceType {
835 #[allow(deprecated)]
836 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
837 where
838 S: serde::Serializer,
839 {
840 let variant = match self {
841 Self::Unspecified => "DISTANCE_TYPE_UNSPECIFIED",
842 Self::L1 => "DISTANCE_TYPE_L1",
843 Self::L2 => "DISTANCE_TYPE_L2",
844 Self::Cosine => "DISTANCE_TYPE_COSINE",
845 Self::InnerProduct => "DISTANCE_TYPE_INNER_PRODUCT",
846 };
847 serializer.serialize_str(variant)
848 }
849}
850impl<'de> serde::Deserialize<'de> for DistanceType {
851 #[allow(deprecated)]
852 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
853 where
854 D: serde::Deserializer<'de>,
855 {
856 const FIELDS: &[&str] = &[
857 "DISTANCE_TYPE_UNSPECIFIED",
858 "DISTANCE_TYPE_L1",
859 "DISTANCE_TYPE_L2",
860 "DISTANCE_TYPE_COSINE",
861 "DISTANCE_TYPE_INNER_PRODUCT",
862 ];
863
864 struct GeneratedVisitor;
865
866 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
867 type Value = DistanceType;
868
869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
870 write!(formatter, "expected one of: {:?}", &FIELDS)
871 }
872
873 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
874 where
875 E: serde::de::Error,
876 {
877 i32::try_from(v)
878 .ok()
879 .and_then(|x| x.try_into().ok())
880 .ok_or_else(|| {
881 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
882 })
883 }
884
885 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
886 where
887 E: serde::de::Error,
888 {
889 i32::try_from(v)
890 .ok()
891 .and_then(|x| x.try_into().ok())
892 .ok_or_else(|| {
893 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
894 })
895 }
896
897 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
898 where
899 E: serde::de::Error,
900 {
901 match value {
902 "DISTANCE_TYPE_UNSPECIFIED" => Ok(DistanceType::Unspecified),
903 "DISTANCE_TYPE_L1" => Ok(DistanceType::L1),
904 "DISTANCE_TYPE_L2" => Ok(DistanceType::L2),
905 "DISTANCE_TYPE_COSINE" => Ok(DistanceType::Cosine),
906 "DISTANCE_TYPE_INNER_PRODUCT" => Ok(DistanceType::InnerProduct),
907 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
908 }
909 }
910 }
911 deserializer.deserialize_any(GeneratedVisitor)
912 }
913}
914impl serde::Serialize for HostAddress {
915 #[allow(deprecated)]
916 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
917 where
918 S: serde::Serializer,
919 {
920 use serde::ser::SerializeStruct;
921 let mut len = 0;
922 if !self.host.is_empty() {
923 len += 1;
924 }
925 if self.port != 0 {
926 len += 1;
927 }
928 let mut struct_ser = serializer.serialize_struct("common.HostAddress", len)?;
929 if !self.host.is_empty() {
930 struct_ser.serialize_field("host", &self.host)?;
931 }
932 if self.port != 0 {
933 struct_ser.serialize_field("port", &self.port)?;
934 }
935 struct_ser.end()
936 }
937}
938impl<'de> serde::Deserialize<'de> for HostAddress {
939 #[allow(deprecated)]
940 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
941 where
942 D: serde::Deserializer<'de>,
943 {
944 const FIELDS: &[&str] = &[
945 "host",
946 "port",
947 ];
948
949 #[allow(clippy::enum_variant_names)]
950 enum GeneratedField {
951 Host,
952 Port,
953 }
954 impl<'de> serde::Deserialize<'de> for GeneratedField {
955 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
956 where
957 D: serde::Deserializer<'de>,
958 {
959 struct GeneratedVisitor;
960
961 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
962 type Value = GeneratedField;
963
964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
965 write!(formatter, "expected one of: {:?}", &FIELDS)
966 }
967
968 #[allow(unused_variables)]
969 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
970 where
971 E: serde::de::Error,
972 {
973 match value {
974 "host" => Ok(GeneratedField::Host),
975 "port" => Ok(GeneratedField::Port),
976 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
977 }
978 }
979 }
980 deserializer.deserialize_identifier(GeneratedVisitor)
981 }
982 }
983 struct GeneratedVisitor;
984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
985 type Value = HostAddress;
986
987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
988 formatter.write_str("struct common.HostAddress")
989 }
990
991 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HostAddress, V::Error>
992 where
993 V: serde::de::MapAccess<'de>,
994 {
995 let mut host__ = None;
996 let mut port__ = None;
997 while let Some(k) = map_.next_key()? {
998 match k {
999 GeneratedField::Host => {
1000 if host__.is_some() {
1001 return Err(serde::de::Error::duplicate_field("host"));
1002 }
1003 host__ = Some(map_.next_value()?);
1004 }
1005 GeneratedField::Port => {
1006 if port__.is_some() {
1007 return Err(serde::de::Error::duplicate_field("port"));
1008 }
1009 port__ =
1010 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1011 ;
1012 }
1013 }
1014 }
1015 Ok(HostAddress {
1016 host: host__.unwrap_or_default(),
1017 port: port__.unwrap_or_default(),
1018 })
1019 }
1020 }
1021 deserializer.deserialize_struct("common.HostAddress", FIELDS, GeneratedVisitor)
1022 }
1023}
1024impl serde::Serialize for NullsAre {
1025 #[allow(deprecated)]
1026 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1027 where
1028 S: serde::Serializer,
1029 {
1030 let variant = match self {
1031 Self::Unspecified => "NULLS_ARE_UNSPECIFIED",
1032 Self::Largest => "NULLS_ARE_LARGEST",
1033 Self::Smallest => "NULLS_ARE_SMALLEST",
1034 };
1035 serializer.serialize_str(variant)
1036 }
1037}
1038impl<'de> serde::Deserialize<'de> for NullsAre {
1039 #[allow(deprecated)]
1040 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1041 where
1042 D: serde::Deserializer<'de>,
1043 {
1044 const FIELDS: &[&str] = &[
1045 "NULLS_ARE_UNSPECIFIED",
1046 "NULLS_ARE_LARGEST",
1047 "NULLS_ARE_SMALLEST",
1048 ];
1049
1050 struct GeneratedVisitor;
1051
1052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1053 type Value = NullsAre;
1054
1055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1056 write!(formatter, "expected one of: {:?}", &FIELDS)
1057 }
1058
1059 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1060 where
1061 E: serde::de::Error,
1062 {
1063 i32::try_from(v)
1064 .ok()
1065 .and_then(|x| x.try_into().ok())
1066 .ok_or_else(|| {
1067 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1068 })
1069 }
1070
1071 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1072 where
1073 E: serde::de::Error,
1074 {
1075 i32::try_from(v)
1076 .ok()
1077 .and_then(|x| x.try_into().ok())
1078 .ok_or_else(|| {
1079 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1080 })
1081 }
1082
1083 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1084 where
1085 E: serde::de::Error,
1086 {
1087 match value {
1088 "NULLS_ARE_UNSPECIFIED" => Ok(NullsAre::Unspecified),
1089 "NULLS_ARE_LARGEST" => Ok(NullsAre::Largest),
1090 "NULLS_ARE_SMALLEST" => Ok(NullsAre::Smallest),
1091 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1092 }
1093 }
1094 }
1095 deserializer.deserialize_any(GeneratedVisitor)
1096 }
1097}
1098impl serde::Serialize for ObjectType {
1099 #[allow(deprecated)]
1100 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1101 where
1102 S: serde::Serializer,
1103 {
1104 let variant = match self {
1105 Self::Unspecified => "UNSPECIFIED",
1106 Self::Database => "DATABASE",
1107 Self::Schema => "SCHEMA",
1108 Self::Table => "TABLE",
1109 Self::Mview => "MVIEW",
1110 Self::Source => "SOURCE",
1111 Self::Sink => "SINK",
1112 Self::View => "VIEW",
1113 Self::Index => "INDEX",
1114 Self::Function => "FUNCTION",
1115 Self::Connection => "CONNECTION",
1116 Self::Subscription => "SUBSCRIPTION",
1117 Self::Secret => "SECRET",
1118 };
1119 serializer.serialize_str(variant)
1120 }
1121}
1122impl<'de> serde::Deserialize<'de> for ObjectType {
1123 #[allow(deprecated)]
1124 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1125 where
1126 D: serde::Deserializer<'de>,
1127 {
1128 const FIELDS: &[&str] = &[
1129 "UNSPECIFIED",
1130 "DATABASE",
1131 "SCHEMA",
1132 "TABLE",
1133 "MVIEW",
1134 "SOURCE",
1135 "SINK",
1136 "VIEW",
1137 "INDEX",
1138 "FUNCTION",
1139 "CONNECTION",
1140 "SUBSCRIPTION",
1141 "SECRET",
1142 ];
1143
1144 struct GeneratedVisitor;
1145
1146 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1147 type Value = ObjectType;
1148
1149 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1150 write!(formatter, "expected one of: {:?}", &FIELDS)
1151 }
1152
1153 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1154 where
1155 E: serde::de::Error,
1156 {
1157 i32::try_from(v)
1158 .ok()
1159 .and_then(|x| x.try_into().ok())
1160 .ok_or_else(|| {
1161 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1162 })
1163 }
1164
1165 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1166 where
1167 E: serde::de::Error,
1168 {
1169 i32::try_from(v)
1170 .ok()
1171 .and_then(|x| x.try_into().ok())
1172 .ok_or_else(|| {
1173 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1174 })
1175 }
1176
1177 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1178 where
1179 E: serde::de::Error,
1180 {
1181 match value {
1182 "UNSPECIFIED" => Ok(ObjectType::Unspecified),
1183 "DATABASE" => Ok(ObjectType::Database),
1184 "SCHEMA" => Ok(ObjectType::Schema),
1185 "TABLE" => Ok(ObjectType::Table),
1186 "MVIEW" => Ok(ObjectType::Mview),
1187 "SOURCE" => Ok(ObjectType::Source),
1188 "SINK" => Ok(ObjectType::Sink),
1189 "VIEW" => Ok(ObjectType::View),
1190 "INDEX" => Ok(ObjectType::Index),
1191 "FUNCTION" => Ok(ObjectType::Function),
1192 "CONNECTION" => Ok(ObjectType::Connection),
1193 "SUBSCRIPTION" => Ok(ObjectType::Subscription),
1194 "SECRET" => Ok(ObjectType::Secret),
1195 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1196 }
1197 }
1198 }
1199 deserializer.deserialize_any(GeneratedVisitor)
1200 }
1201}
1202impl serde::Serialize for OptionalUint32 {
1203 #[allow(deprecated)]
1204 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1205 where
1206 S: serde::Serializer,
1207 {
1208 use serde::ser::SerializeStruct;
1209 let mut len = 0;
1210 if self.value.is_some() {
1211 len += 1;
1212 }
1213 let mut struct_ser = serializer.serialize_struct("common.OptionalUint32", len)?;
1214 if let Some(v) = self.value.as_ref() {
1215 struct_ser.serialize_field("value", v)?;
1216 }
1217 struct_ser.end()
1218 }
1219}
1220impl<'de> serde::Deserialize<'de> for OptionalUint32 {
1221 #[allow(deprecated)]
1222 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1223 where
1224 D: serde::Deserializer<'de>,
1225 {
1226 const FIELDS: &[&str] = &[
1227 "value",
1228 ];
1229
1230 #[allow(clippy::enum_variant_names)]
1231 enum GeneratedField {
1232 Value,
1233 }
1234 impl<'de> serde::Deserialize<'de> for GeneratedField {
1235 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1236 where
1237 D: serde::Deserializer<'de>,
1238 {
1239 struct GeneratedVisitor;
1240
1241 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1242 type Value = GeneratedField;
1243
1244 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1245 write!(formatter, "expected one of: {:?}", &FIELDS)
1246 }
1247
1248 #[allow(unused_variables)]
1249 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1250 where
1251 E: serde::de::Error,
1252 {
1253 match value {
1254 "value" => Ok(GeneratedField::Value),
1255 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1256 }
1257 }
1258 }
1259 deserializer.deserialize_identifier(GeneratedVisitor)
1260 }
1261 }
1262 struct GeneratedVisitor;
1263 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1264 type Value = OptionalUint32;
1265
1266 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1267 formatter.write_str("struct common.OptionalUint32")
1268 }
1269
1270 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OptionalUint32, V::Error>
1271 where
1272 V: serde::de::MapAccess<'de>,
1273 {
1274 let mut value__ = None;
1275 while let Some(k) = map_.next_key()? {
1276 match k {
1277 GeneratedField::Value => {
1278 if value__.is_some() {
1279 return Err(serde::de::Error::duplicate_field("value"));
1280 }
1281 value__ =
1282 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1283 ;
1284 }
1285 }
1286 }
1287 Ok(OptionalUint32 {
1288 value: value__,
1289 })
1290 }
1291 }
1292 deserializer.deserialize_struct("common.OptionalUint32", FIELDS, GeneratedVisitor)
1293 }
1294}
1295impl serde::Serialize for OptionalUint64 {
1296 #[allow(deprecated)]
1297 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1298 where
1299 S: serde::Serializer,
1300 {
1301 use serde::ser::SerializeStruct;
1302 let mut len = 0;
1303 if self.value.is_some() {
1304 len += 1;
1305 }
1306 let mut struct_ser = serializer.serialize_struct("common.OptionalUint64", len)?;
1307 if let Some(v) = self.value.as_ref() {
1308 #[allow(clippy::needless_borrow)]
1309 #[allow(clippy::needless_borrows_for_generic_args)]
1310 struct_ser.serialize_field("value", ToString::to_string(&v).as_str())?;
1311 }
1312 struct_ser.end()
1313 }
1314}
1315impl<'de> serde::Deserialize<'de> for OptionalUint64 {
1316 #[allow(deprecated)]
1317 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1318 where
1319 D: serde::Deserializer<'de>,
1320 {
1321 const FIELDS: &[&str] = &[
1322 "value",
1323 ];
1324
1325 #[allow(clippy::enum_variant_names)]
1326 enum GeneratedField {
1327 Value,
1328 }
1329 impl<'de> serde::Deserialize<'de> for GeneratedField {
1330 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1331 where
1332 D: serde::Deserializer<'de>,
1333 {
1334 struct GeneratedVisitor;
1335
1336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1337 type Value = GeneratedField;
1338
1339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1340 write!(formatter, "expected one of: {:?}", &FIELDS)
1341 }
1342
1343 #[allow(unused_variables)]
1344 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1345 where
1346 E: serde::de::Error,
1347 {
1348 match value {
1349 "value" => Ok(GeneratedField::Value),
1350 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1351 }
1352 }
1353 }
1354 deserializer.deserialize_identifier(GeneratedVisitor)
1355 }
1356 }
1357 struct GeneratedVisitor;
1358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1359 type Value = OptionalUint64;
1360
1361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1362 formatter.write_str("struct common.OptionalUint64")
1363 }
1364
1365 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OptionalUint64, V::Error>
1366 where
1367 V: serde::de::MapAccess<'de>,
1368 {
1369 let mut value__ = None;
1370 while let Some(k) = map_.next_key()? {
1371 match k {
1372 GeneratedField::Value => {
1373 if value__.is_some() {
1374 return Err(serde::de::Error::duplicate_field("value"));
1375 }
1376 value__ =
1377 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1378 ;
1379 }
1380 }
1381 }
1382 Ok(OptionalUint64 {
1383 value: value__,
1384 })
1385 }
1386 }
1387 deserializer.deserialize_struct("common.OptionalUint64", FIELDS, GeneratedVisitor)
1388 }
1389}
1390impl serde::Serialize for OrderType {
1391 #[allow(deprecated)]
1392 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1393 where
1394 S: serde::Serializer,
1395 {
1396 use serde::ser::SerializeStruct;
1397 let mut len = 0;
1398 if self.direction != 0 {
1399 len += 1;
1400 }
1401 if self.nulls_are != 0 {
1402 len += 1;
1403 }
1404 let mut struct_ser = serializer.serialize_struct("common.OrderType", len)?;
1405 if self.direction != 0 {
1406 let v = Direction::try_from(self.direction)
1407 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?;
1408 struct_ser.serialize_field("direction", &v)?;
1409 }
1410 if self.nulls_are != 0 {
1411 let v = NullsAre::try_from(self.nulls_are)
1412 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.nulls_are)))?;
1413 struct_ser.serialize_field("nullsAre", &v)?;
1414 }
1415 struct_ser.end()
1416 }
1417}
1418impl<'de> serde::Deserialize<'de> for OrderType {
1419 #[allow(deprecated)]
1420 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1421 where
1422 D: serde::Deserializer<'de>,
1423 {
1424 const FIELDS: &[&str] = &[
1425 "direction",
1426 "nulls_are",
1427 "nullsAre",
1428 ];
1429
1430 #[allow(clippy::enum_variant_names)]
1431 enum GeneratedField {
1432 Direction,
1433 NullsAre,
1434 }
1435 impl<'de> serde::Deserialize<'de> for GeneratedField {
1436 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1437 where
1438 D: serde::Deserializer<'de>,
1439 {
1440 struct GeneratedVisitor;
1441
1442 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1443 type Value = GeneratedField;
1444
1445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1446 write!(formatter, "expected one of: {:?}", &FIELDS)
1447 }
1448
1449 #[allow(unused_variables)]
1450 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1451 where
1452 E: serde::de::Error,
1453 {
1454 match value {
1455 "direction" => Ok(GeneratedField::Direction),
1456 "nullsAre" | "nulls_are" => Ok(GeneratedField::NullsAre),
1457 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1458 }
1459 }
1460 }
1461 deserializer.deserialize_identifier(GeneratedVisitor)
1462 }
1463 }
1464 struct GeneratedVisitor;
1465 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1466 type Value = OrderType;
1467
1468 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1469 formatter.write_str("struct common.OrderType")
1470 }
1471
1472 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OrderType, V::Error>
1473 where
1474 V: serde::de::MapAccess<'de>,
1475 {
1476 let mut direction__ = None;
1477 let mut nulls_are__ = None;
1478 while let Some(k) = map_.next_key()? {
1479 match k {
1480 GeneratedField::Direction => {
1481 if direction__.is_some() {
1482 return Err(serde::de::Error::duplicate_field("direction"));
1483 }
1484 direction__ = Some(map_.next_value::<Direction>()? as i32);
1485 }
1486 GeneratedField::NullsAre => {
1487 if nulls_are__.is_some() {
1488 return Err(serde::de::Error::duplicate_field("nullsAre"));
1489 }
1490 nulls_are__ = Some(map_.next_value::<NullsAre>()? as i32);
1491 }
1492 }
1493 }
1494 Ok(OrderType {
1495 direction: direction__.unwrap_or_default(),
1496 nulls_are: nulls_are__.unwrap_or_default(),
1497 })
1498 }
1499 }
1500 deserializer.deserialize_struct("common.OrderType", FIELDS, GeneratedVisitor)
1501 }
1502}
1503impl serde::Serialize for Status {
1504 #[allow(deprecated)]
1505 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1506 where
1507 S: serde::Serializer,
1508 {
1509 use serde::ser::SerializeStruct;
1510 let mut len = 0;
1511 if self.code != 0 {
1512 len += 1;
1513 }
1514 if !self.message.is_empty() {
1515 len += 1;
1516 }
1517 let mut struct_ser = serializer.serialize_struct("common.Status", len)?;
1518 if self.code != 0 {
1519 let v = status::Code::try_from(self.code)
1520 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.code)))?;
1521 struct_ser.serialize_field("code", &v)?;
1522 }
1523 if !self.message.is_empty() {
1524 struct_ser.serialize_field("message", &self.message)?;
1525 }
1526 struct_ser.end()
1527 }
1528}
1529impl<'de> serde::Deserialize<'de> for Status {
1530 #[allow(deprecated)]
1531 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1532 where
1533 D: serde::Deserializer<'de>,
1534 {
1535 const FIELDS: &[&str] = &[
1536 "code",
1537 "message",
1538 ];
1539
1540 #[allow(clippy::enum_variant_names)]
1541 enum GeneratedField {
1542 Code,
1543 Message,
1544 }
1545 impl<'de> serde::Deserialize<'de> for GeneratedField {
1546 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1547 where
1548 D: serde::Deserializer<'de>,
1549 {
1550 struct GeneratedVisitor;
1551
1552 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1553 type Value = GeneratedField;
1554
1555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1556 write!(formatter, "expected one of: {:?}", &FIELDS)
1557 }
1558
1559 #[allow(unused_variables)]
1560 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1561 where
1562 E: serde::de::Error,
1563 {
1564 match value {
1565 "code" => Ok(GeneratedField::Code),
1566 "message" => Ok(GeneratedField::Message),
1567 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1568 }
1569 }
1570 }
1571 deserializer.deserialize_identifier(GeneratedVisitor)
1572 }
1573 }
1574 struct GeneratedVisitor;
1575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1576 type Value = Status;
1577
1578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1579 formatter.write_str("struct common.Status")
1580 }
1581
1582 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Status, V::Error>
1583 where
1584 V: serde::de::MapAccess<'de>,
1585 {
1586 let mut code__ = None;
1587 let mut message__ = None;
1588 while let Some(k) = map_.next_key()? {
1589 match k {
1590 GeneratedField::Code => {
1591 if code__.is_some() {
1592 return Err(serde::de::Error::duplicate_field("code"));
1593 }
1594 code__ = Some(map_.next_value::<status::Code>()? as i32);
1595 }
1596 GeneratedField::Message => {
1597 if message__.is_some() {
1598 return Err(serde::de::Error::duplicate_field("message"));
1599 }
1600 message__ = Some(map_.next_value()?);
1601 }
1602 }
1603 }
1604 Ok(Status {
1605 code: code__.unwrap_or_default(),
1606 message: message__.unwrap_or_default(),
1607 })
1608 }
1609 }
1610 deserializer.deserialize_struct("common.Status", FIELDS, GeneratedVisitor)
1611 }
1612}
1613impl serde::Serialize for status::Code {
1614 #[allow(deprecated)]
1615 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1616 where
1617 S: serde::Serializer,
1618 {
1619 let variant = match self {
1620 Self::Unspecified => "UNSPECIFIED",
1621 Self::Ok => "OK",
1622 Self::UnknownWorker => "UNKNOWN_WORKER",
1623 };
1624 serializer.serialize_str(variant)
1625 }
1626}
1627impl<'de> serde::Deserialize<'de> for status::Code {
1628 #[allow(deprecated)]
1629 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1630 where
1631 D: serde::Deserializer<'de>,
1632 {
1633 const FIELDS: &[&str] = &[
1634 "UNSPECIFIED",
1635 "OK",
1636 "UNKNOWN_WORKER",
1637 ];
1638
1639 struct GeneratedVisitor;
1640
1641 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1642 type Value = status::Code;
1643
1644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1645 write!(formatter, "expected one of: {:?}", &FIELDS)
1646 }
1647
1648 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1649 where
1650 E: serde::de::Error,
1651 {
1652 i32::try_from(v)
1653 .ok()
1654 .and_then(|x| x.try_into().ok())
1655 .ok_or_else(|| {
1656 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1657 })
1658 }
1659
1660 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1661 where
1662 E: serde::de::Error,
1663 {
1664 i32::try_from(v)
1665 .ok()
1666 .and_then(|x| x.try_into().ok())
1667 .ok_or_else(|| {
1668 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1669 })
1670 }
1671
1672 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1673 where
1674 E: serde::de::Error,
1675 {
1676 match value {
1677 "UNSPECIFIED" => Ok(status::Code::Unspecified),
1678 "OK" => Ok(status::Code::Ok),
1679 "UNKNOWN_WORKER" => Ok(status::Code::UnknownWorker),
1680 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1681 }
1682 }
1683 }
1684 deserializer.deserialize_any(GeneratedVisitor)
1685 }
1686}
1687impl serde::Serialize for Uint32Vector {
1688 #[allow(deprecated)]
1689 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1690 where
1691 S: serde::Serializer,
1692 {
1693 use serde::ser::SerializeStruct;
1694 let mut len = 0;
1695 if !self.data.is_empty() {
1696 len += 1;
1697 }
1698 let mut struct_ser = serializer.serialize_struct("common.Uint32Vector", len)?;
1699 if !self.data.is_empty() {
1700 struct_ser.serialize_field("data", &self.data)?;
1701 }
1702 struct_ser.end()
1703 }
1704}
1705impl<'de> serde::Deserialize<'de> for Uint32Vector {
1706 #[allow(deprecated)]
1707 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1708 where
1709 D: serde::Deserializer<'de>,
1710 {
1711 const FIELDS: &[&str] = &[
1712 "data",
1713 ];
1714
1715 #[allow(clippy::enum_variant_names)]
1716 enum GeneratedField {
1717 Data,
1718 }
1719 impl<'de> serde::Deserialize<'de> for GeneratedField {
1720 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1721 where
1722 D: serde::Deserializer<'de>,
1723 {
1724 struct GeneratedVisitor;
1725
1726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1727 type Value = GeneratedField;
1728
1729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1730 write!(formatter, "expected one of: {:?}", &FIELDS)
1731 }
1732
1733 #[allow(unused_variables)]
1734 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1735 where
1736 E: serde::de::Error,
1737 {
1738 match value {
1739 "data" => Ok(GeneratedField::Data),
1740 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1741 }
1742 }
1743 }
1744 deserializer.deserialize_identifier(GeneratedVisitor)
1745 }
1746 }
1747 struct GeneratedVisitor;
1748 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1749 type Value = Uint32Vector;
1750
1751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1752 formatter.write_str("struct common.Uint32Vector")
1753 }
1754
1755 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Uint32Vector, V::Error>
1756 where
1757 V: serde::de::MapAccess<'de>,
1758 {
1759 let mut data__ = None;
1760 while let Some(k) = map_.next_key()? {
1761 match k {
1762 GeneratedField::Data => {
1763 if data__.is_some() {
1764 return Err(serde::de::Error::duplicate_field("data"));
1765 }
1766 data__ =
1767 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1768 .into_iter().map(|x| x.0).collect())
1769 ;
1770 }
1771 }
1772 }
1773 Ok(Uint32Vector {
1774 data: data__.unwrap_or_default(),
1775 })
1776 }
1777 }
1778 deserializer.deserialize_struct("common.Uint32Vector", FIELDS, GeneratedVisitor)
1779 }
1780}
1781impl serde::Serialize for WorkerNode {
1782 #[allow(deprecated)]
1783 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1784 where
1785 S: serde::Serializer,
1786 {
1787 use serde::ser::SerializeStruct;
1788 let mut len = 0;
1789 if self.id != 0 {
1790 len += 1;
1791 }
1792 if self.r#type != 0 {
1793 len += 1;
1794 }
1795 if self.host.is_some() {
1796 len += 1;
1797 }
1798 if self.state != 0 {
1799 len += 1;
1800 }
1801 if self.property.is_some() {
1802 len += 1;
1803 }
1804 if self.transactional_id.is_some() {
1805 len += 1;
1806 }
1807 if self.resource.is_some() {
1808 len += 1;
1809 }
1810 if self.started_at.is_some() {
1811 len += 1;
1812 }
1813 let mut struct_ser = serializer.serialize_struct("common.WorkerNode", len)?;
1814 if self.id != 0 {
1815 struct_ser.serialize_field("id", &self.id)?;
1816 }
1817 if self.r#type != 0 {
1818 let v = WorkerType::try_from(self.r#type)
1819 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
1820 struct_ser.serialize_field("type", &v)?;
1821 }
1822 if let Some(v) = self.host.as_ref() {
1823 struct_ser.serialize_field("host", v)?;
1824 }
1825 if self.state != 0 {
1826 let v = worker_node::State::try_from(self.state)
1827 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
1828 struct_ser.serialize_field("state", &v)?;
1829 }
1830 if let Some(v) = self.property.as_ref() {
1831 struct_ser.serialize_field("property", v)?;
1832 }
1833 if let Some(v) = self.transactional_id.as_ref() {
1834 struct_ser.serialize_field("transactionalId", v)?;
1835 }
1836 if let Some(v) = self.resource.as_ref() {
1837 struct_ser.serialize_field("resource", v)?;
1838 }
1839 if let Some(v) = self.started_at.as_ref() {
1840 #[allow(clippy::needless_borrow)]
1841 #[allow(clippy::needless_borrows_for_generic_args)]
1842 struct_ser.serialize_field("startedAt", ToString::to_string(&v).as_str())?;
1843 }
1844 struct_ser.end()
1845 }
1846}
1847impl<'de> serde::Deserialize<'de> for WorkerNode {
1848 #[allow(deprecated)]
1849 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1850 where
1851 D: serde::Deserializer<'de>,
1852 {
1853 const FIELDS: &[&str] = &[
1854 "id",
1855 "type",
1856 "host",
1857 "state",
1858 "property",
1859 "transactional_id",
1860 "transactionalId",
1861 "resource",
1862 "started_at",
1863 "startedAt",
1864 ];
1865
1866 #[allow(clippy::enum_variant_names)]
1867 enum GeneratedField {
1868 Id,
1869 Type,
1870 Host,
1871 State,
1872 Property,
1873 TransactionalId,
1874 Resource,
1875 StartedAt,
1876 }
1877 impl<'de> serde::Deserialize<'de> for GeneratedField {
1878 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1879 where
1880 D: serde::Deserializer<'de>,
1881 {
1882 struct GeneratedVisitor;
1883
1884 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1885 type Value = GeneratedField;
1886
1887 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1888 write!(formatter, "expected one of: {:?}", &FIELDS)
1889 }
1890
1891 #[allow(unused_variables)]
1892 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1893 where
1894 E: serde::de::Error,
1895 {
1896 match value {
1897 "id" => Ok(GeneratedField::Id),
1898 "type" => Ok(GeneratedField::Type),
1899 "host" => Ok(GeneratedField::Host),
1900 "state" => Ok(GeneratedField::State),
1901 "property" => Ok(GeneratedField::Property),
1902 "transactionalId" | "transactional_id" => Ok(GeneratedField::TransactionalId),
1903 "resource" => Ok(GeneratedField::Resource),
1904 "startedAt" | "started_at" => Ok(GeneratedField::StartedAt),
1905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1906 }
1907 }
1908 }
1909 deserializer.deserialize_identifier(GeneratedVisitor)
1910 }
1911 }
1912 struct GeneratedVisitor;
1913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1914 type Value = WorkerNode;
1915
1916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1917 formatter.write_str("struct common.WorkerNode")
1918 }
1919
1920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerNode, V::Error>
1921 where
1922 V: serde::de::MapAccess<'de>,
1923 {
1924 let mut id__ = None;
1925 let mut r#type__ = None;
1926 let mut host__ = None;
1927 let mut state__ = None;
1928 let mut property__ = None;
1929 let mut transactional_id__ = None;
1930 let mut resource__ = None;
1931 let mut started_at__ = None;
1932 while let Some(k) = map_.next_key()? {
1933 match k {
1934 GeneratedField::Id => {
1935 if id__.is_some() {
1936 return Err(serde::de::Error::duplicate_field("id"));
1937 }
1938 id__ =
1939 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1940 ;
1941 }
1942 GeneratedField::Type => {
1943 if r#type__.is_some() {
1944 return Err(serde::de::Error::duplicate_field("type"));
1945 }
1946 r#type__ = Some(map_.next_value::<WorkerType>()? as i32);
1947 }
1948 GeneratedField::Host => {
1949 if host__.is_some() {
1950 return Err(serde::de::Error::duplicate_field("host"));
1951 }
1952 host__ = map_.next_value()?;
1953 }
1954 GeneratedField::State => {
1955 if state__.is_some() {
1956 return Err(serde::de::Error::duplicate_field("state"));
1957 }
1958 state__ = Some(map_.next_value::<worker_node::State>()? as i32);
1959 }
1960 GeneratedField::Property => {
1961 if property__.is_some() {
1962 return Err(serde::de::Error::duplicate_field("property"));
1963 }
1964 property__ = map_.next_value()?;
1965 }
1966 GeneratedField::TransactionalId => {
1967 if transactional_id__.is_some() {
1968 return Err(serde::de::Error::duplicate_field("transactionalId"));
1969 }
1970 transactional_id__ =
1971 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1972 ;
1973 }
1974 GeneratedField::Resource => {
1975 if resource__.is_some() {
1976 return Err(serde::de::Error::duplicate_field("resource"));
1977 }
1978 resource__ = map_.next_value()?;
1979 }
1980 GeneratedField::StartedAt => {
1981 if started_at__.is_some() {
1982 return Err(serde::de::Error::duplicate_field("startedAt"));
1983 }
1984 started_at__ =
1985 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1986 ;
1987 }
1988 }
1989 }
1990 Ok(WorkerNode {
1991 id: id__.unwrap_or_default(),
1992 r#type: r#type__.unwrap_or_default(),
1993 host: host__,
1994 state: state__.unwrap_or_default(),
1995 property: property__,
1996 transactional_id: transactional_id__,
1997 resource: resource__,
1998 started_at: started_at__,
1999 })
2000 }
2001 }
2002 deserializer.deserialize_struct("common.WorkerNode", FIELDS, GeneratedVisitor)
2003 }
2004}
2005impl serde::Serialize for worker_node::Property {
2006 #[allow(deprecated)]
2007 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2008 where
2009 S: serde::Serializer,
2010 {
2011 use serde::ser::SerializeStruct;
2012 let mut len = 0;
2013 if self.is_streaming {
2014 len += 1;
2015 }
2016 if self.is_serving {
2017 len += 1;
2018 }
2019 if self.is_unschedulable {
2020 len += 1;
2021 }
2022 if !self.internal_rpc_host_addr.is_empty() {
2023 len += 1;
2024 }
2025 if self.parallelism != 0 {
2026 len += 1;
2027 }
2028 if self.resource_group.is_some() {
2029 len += 1;
2030 }
2031 let mut struct_ser = serializer.serialize_struct("common.WorkerNode.Property", len)?;
2032 if self.is_streaming {
2033 struct_ser.serialize_field("isStreaming", &self.is_streaming)?;
2034 }
2035 if self.is_serving {
2036 struct_ser.serialize_field("isServing", &self.is_serving)?;
2037 }
2038 if self.is_unschedulable {
2039 struct_ser.serialize_field("isUnschedulable", &self.is_unschedulable)?;
2040 }
2041 if !self.internal_rpc_host_addr.is_empty() {
2042 struct_ser.serialize_field("internalRpcHostAddr", &self.internal_rpc_host_addr)?;
2043 }
2044 if self.parallelism != 0 {
2045 struct_ser.serialize_field("parallelism", &self.parallelism)?;
2046 }
2047 if let Some(v) = self.resource_group.as_ref() {
2048 struct_ser.serialize_field("resourceGroup", v)?;
2049 }
2050 struct_ser.end()
2051 }
2052}
2053impl<'de> serde::Deserialize<'de> for worker_node::Property {
2054 #[allow(deprecated)]
2055 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2056 where
2057 D: serde::Deserializer<'de>,
2058 {
2059 const FIELDS: &[&str] = &[
2060 "is_streaming",
2061 "isStreaming",
2062 "is_serving",
2063 "isServing",
2064 "is_unschedulable",
2065 "isUnschedulable",
2066 "internal_rpc_host_addr",
2067 "internalRpcHostAddr",
2068 "parallelism",
2069 "resource_group",
2070 "resourceGroup",
2071 ];
2072
2073 #[allow(clippy::enum_variant_names)]
2074 enum GeneratedField {
2075 IsStreaming,
2076 IsServing,
2077 IsUnschedulable,
2078 InternalRpcHostAddr,
2079 Parallelism,
2080 ResourceGroup,
2081 }
2082 impl<'de> serde::Deserialize<'de> for GeneratedField {
2083 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2084 where
2085 D: serde::Deserializer<'de>,
2086 {
2087 struct GeneratedVisitor;
2088
2089 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2090 type Value = GeneratedField;
2091
2092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2093 write!(formatter, "expected one of: {:?}", &FIELDS)
2094 }
2095
2096 #[allow(unused_variables)]
2097 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2098 where
2099 E: serde::de::Error,
2100 {
2101 match value {
2102 "isStreaming" | "is_streaming" => Ok(GeneratedField::IsStreaming),
2103 "isServing" | "is_serving" => Ok(GeneratedField::IsServing),
2104 "isUnschedulable" | "is_unschedulable" => Ok(GeneratedField::IsUnschedulable),
2105 "internalRpcHostAddr" | "internal_rpc_host_addr" => Ok(GeneratedField::InternalRpcHostAddr),
2106 "parallelism" => Ok(GeneratedField::Parallelism),
2107 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
2108 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2109 }
2110 }
2111 }
2112 deserializer.deserialize_identifier(GeneratedVisitor)
2113 }
2114 }
2115 struct GeneratedVisitor;
2116 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2117 type Value = worker_node::Property;
2118
2119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2120 formatter.write_str("struct common.WorkerNode.Property")
2121 }
2122
2123 fn visit_map<V>(self, mut map_: V) -> std::result::Result<worker_node::Property, V::Error>
2124 where
2125 V: serde::de::MapAccess<'de>,
2126 {
2127 let mut is_streaming__ = None;
2128 let mut is_serving__ = None;
2129 let mut is_unschedulable__ = None;
2130 let mut internal_rpc_host_addr__ = None;
2131 let mut parallelism__ = None;
2132 let mut resource_group__ = None;
2133 while let Some(k) = map_.next_key()? {
2134 match k {
2135 GeneratedField::IsStreaming => {
2136 if is_streaming__.is_some() {
2137 return Err(serde::de::Error::duplicate_field("isStreaming"));
2138 }
2139 is_streaming__ = Some(map_.next_value()?);
2140 }
2141 GeneratedField::IsServing => {
2142 if is_serving__.is_some() {
2143 return Err(serde::de::Error::duplicate_field("isServing"));
2144 }
2145 is_serving__ = Some(map_.next_value()?);
2146 }
2147 GeneratedField::IsUnschedulable => {
2148 if is_unschedulable__.is_some() {
2149 return Err(serde::de::Error::duplicate_field("isUnschedulable"));
2150 }
2151 is_unschedulable__ = Some(map_.next_value()?);
2152 }
2153 GeneratedField::InternalRpcHostAddr => {
2154 if internal_rpc_host_addr__.is_some() {
2155 return Err(serde::de::Error::duplicate_field("internalRpcHostAddr"));
2156 }
2157 internal_rpc_host_addr__ = Some(map_.next_value()?);
2158 }
2159 GeneratedField::Parallelism => {
2160 if parallelism__.is_some() {
2161 return Err(serde::de::Error::duplicate_field("parallelism"));
2162 }
2163 parallelism__ =
2164 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2165 ;
2166 }
2167 GeneratedField::ResourceGroup => {
2168 if resource_group__.is_some() {
2169 return Err(serde::de::Error::duplicate_field("resourceGroup"));
2170 }
2171 resource_group__ = map_.next_value()?;
2172 }
2173 }
2174 }
2175 Ok(worker_node::Property {
2176 is_streaming: is_streaming__.unwrap_or_default(),
2177 is_serving: is_serving__.unwrap_or_default(),
2178 is_unschedulable: is_unschedulable__.unwrap_or_default(),
2179 internal_rpc_host_addr: internal_rpc_host_addr__.unwrap_or_default(),
2180 parallelism: parallelism__.unwrap_or_default(),
2181 resource_group: resource_group__,
2182 })
2183 }
2184 }
2185 deserializer.deserialize_struct("common.WorkerNode.Property", FIELDS, GeneratedVisitor)
2186 }
2187}
2188impl serde::Serialize for worker_node::Resource {
2189 #[allow(deprecated)]
2190 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2191 where
2192 S: serde::Serializer,
2193 {
2194 use serde::ser::SerializeStruct;
2195 let mut len = 0;
2196 if !self.rw_version.is_empty() {
2197 len += 1;
2198 }
2199 if self.total_memory_bytes != 0 {
2200 len += 1;
2201 }
2202 if self.total_cpu_cores != 0 {
2203 len += 1;
2204 }
2205 let mut struct_ser = serializer.serialize_struct("common.WorkerNode.Resource", len)?;
2206 if !self.rw_version.is_empty() {
2207 struct_ser.serialize_field("rwVersion", &self.rw_version)?;
2208 }
2209 if self.total_memory_bytes != 0 {
2210 #[allow(clippy::needless_borrow)]
2211 #[allow(clippy::needless_borrows_for_generic_args)]
2212 struct_ser.serialize_field("totalMemoryBytes", ToString::to_string(&self.total_memory_bytes).as_str())?;
2213 }
2214 if self.total_cpu_cores != 0 {
2215 #[allow(clippy::needless_borrow)]
2216 #[allow(clippy::needless_borrows_for_generic_args)]
2217 struct_ser.serialize_field("totalCpuCores", ToString::to_string(&self.total_cpu_cores).as_str())?;
2218 }
2219 struct_ser.end()
2220 }
2221}
2222impl<'de> serde::Deserialize<'de> for worker_node::Resource {
2223 #[allow(deprecated)]
2224 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2225 where
2226 D: serde::Deserializer<'de>,
2227 {
2228 const FIELDS: &[&str] = &[
2229 "rw_version",
2230 "rwVersion",
2231 "total_memory_bytes",
2232 "totalMemoryBytes",
2233 "total_cpu_cores",
2234 "totalCpuCores",
2235 ];
2236
2237 #[allow(clippy::enum_variant_names)]
2238 enum GeneratedField {
2239 RwVersion,
2240 TotalMemoryBytes,
2241 TotalCpuCores,
2242 }
2243 impl<'de> serde::Deserialize<'de> for GeneratedField {
2244 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2245 where
2246 D: serde::Deserializer<'de>,
2247 {
2248 struct GeneratedVisitor;
2249
2250 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2251 type Value = GeneratedField;
2252
2253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2254 write!(formatter, "expected one of: {:?}", &FIELDS)
2255 }
2256
2257 #[allow(unused_variables)]
2258 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2259 where
2260 E: serde::de::Error,
2261 {
2262 match value {
2263 "rwVersion" | "rw_version" => Ok(GeneratedField::RwVersion),
2264 "totalMemoryBytes" | "total_memory_bytes" => Ok(GeneratedField::TotalMemoryBytes),
2265 "totalCpuCores" | "total_cpu_cores" => Ok(GeneratedField::TotalCpuCores),
2266 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2267 }
2268 }
2269 }
2270 deserializer.deserialize_identifier(GeneratedVisitor)
2271 }
2272 }
2273 struct GeneratedVisitor;
2274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2275 type Value = worker_node::Resource;
2276
2277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2278 formatter.write_str("struct common.WorkerNode.Resource")
2279 }
2280
2281 fn visit_map<V>(self, mut map_: V) -> std::result::Result<worker_node::Resource, V::Error>
2282 where
2283 V: serde::de::MapAccess<'de>,
2284 {
2285 let mut rw_version__ = None;
2286 let mut total_memory_bytes__ = None;
2287 let mut total_cpu_cores__ = None;
2288 while let Some(k) = map_.next_key()? {
2289 match k {
2290 GeneratedField::RwVersion => {
2291 if rw_version__.is_some() {
2292 return Err(serde::de::Error::duplicate_field("rwVersion"));
2293 }
2294 rw_version__ = Some(map_.next_value()?);
2295 }
2296 GeneratedField::TotalMemoryBytes => {
2297 if total_memory_bytes__.is_some() {
2298 return Err(serde::de::Error::duplicate_field("totalMemoryBytes"));
2299 }
2300 total_memory_bytes__ =
2301 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2302 ;
2303 }
2304 GeneratedField::TotalCpuCores => {
2305 if total_cpu_cores__.is_some() {
2306 return Err(serde::de::Error::duplicate_field("totalCpuCores"));
2307 }
2308 total_cpu_cores__ =
2309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2310 ;
2311 }
2312 }
2313 }
2314 Ok(worker_node::Resource {
2315 rw_version: rw_version__.unwrap_or_default(),
2316 total_memory_bytes: total_memory_bytes__.unwrap_or_default(),
2317 total_cpu_cores: total_cpu_cores__.unwrap_or_default(),
2318 })
2319 }
2320 }
2321 deserializer.deserialize_struct("common.WorkerNode.Resource", FIELDS, GeneratedVisitor)
2322 }
2323}
2324impl serde::Serialize for worker_node::State {
2325 #[allow(deprecated)]
2326 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2327 where
2328 S: serde::Serializer,
2329 {
2330 let variant = match self {
2331 Self::Unspecified => "UNSPECIFIED",
2332 Self::Starting => "STARTING",
2333 Self::Running => "RUNNING",
2334 };
2335 serializer.serialize_str(variant)
2336 }
2337}
2338impl<'de> serde::Deserialize<'de> for worker_node::State {
2339 #[allow(deprecated)]
2340 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2341 where
2342 D: serde::Deserializer<'de>,
2343 {
2344 const FIELDS: &[&str] = &[
2345 "UNSPECIFIED",
2346 "STARTING",
2347 "RUNNING",
2348 ];
2349
2350 struct GeneratedVisitor;
2351
2352 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2353 type Value = worker_node::State;
2354
2355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2356 write!(formatter, "expected one of: {:?}", &FIELDS)
2357 }
2358
2359 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2360 where
2361 E: serde::de::Error,
2362 {
2363 i32::try_from(v)
2364 .ok()
2365 .and_then(|x| x.try_into().ok())
2366 .ok_or_else(|| {
2367 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2368 })
2369 }
2370
2371 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2372 where
2373 E: serde::de::Error,
2374 {
2375 i32::try_from(v)
2376 .ok()
2377 .and_then(|x| x.try_into().ok())
2378 .ok_or_else(|| {
2379 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2380 })
2381 }
2382
2383 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2384 where
2385 E: serde::de::Error,
2386 {
2387 match value {
2388 "UNSPECIFIED" => Ok(worker_node::State::Unspecified),
2389 "STARTING" => Ok(worker_node::State::Starting),
2390 "RUNNING" => Ok(worker_node::State::Running),
2391 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2392 }
2393 }
2394 }
2395 deserializer.deserialize_any(GeneratedVisitor)
2396 }
2397}
2398impl serde::Serialize for WorkerSlotMapping {
2399 #[allow(deprecated)]
2400 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2401 where
2402 S: serde::Serializer,
2403 {
2404 use serde::ser::SerializeStruct;
2405 let mut len = 0;
2406 if !self.original_indices.is_empty() {
2407 len += 1;
2408 }
2409 if !self.data.is_empty() {
2410 len += 1;
2411 }
2412 let mut struct_ser = serializer.serialize_struct("common.WorkerSlotMapping", len)?;
2413 if !self.original_indices.is_empty() {
2414 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
2415 }
2416 if !self.data.is_empty() {
2417 struct_ser.serialize_field("data", &self.data.iter().map(ToString::to_string).collect::<Vec<_>>())?;
2418 }
2419 struct_ser.end()
2420 }
2421}
2422impl<'de> serde::Deserialize<'de> for WorkerSlotMapping {
2423 #[allow(deprecated)]
2424 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2425 where
2426 D: serde::Deserializer<'de>,
2427 {
2428 const FIELDS: &[&str] = &[
2429 "original_indices",
2430 "originalIndices",
2431 "data",
2432 ];
2433
2434 #[allow(clippy::enum_variant_names)]
2435 enum GeneratedField {
2436 OriginalIndices,
2437 Data,
2438 }
2439 impl<'de> serde::Deserialize<'de> for GeneratedField {
2440 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2441 where
2442 D: serde::Deserializer<'de>,
2443 {
2444 struct GeneratedVisitor;
2445
2446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2447 type Value = GeneratedField;
2448
2449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2450 write!(formatter, "expected one of: {:?}", &FIELDS)
2451 }
2452
2453 #[allow(unused_variables)]
2454 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2455 where
2456 E: serde::de::Error,
2457 {
2458 match value {
2459 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
2460 "data" => Ok(GeneratedField::Data),
2461 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2462 }
2463 }
2464 }
2465 deserializer.deserialize_identifier(GeneratedVisitor)
2466 }
2467 }
2468 struct GeneratedVisitor;
2469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2470 type Value = WorkerSlotMapping;
2471
2472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2473 formatter.write_str("struct common.WorkerSlotMapping")
2474 }
2475
2476 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerSlotMapping, V::Error>
2477 where
2478 V: serde::de::MapAccess<'de>,
2479 {
2480 let mut original_indices__ = None;
2481 let mut data__ = None;
2482 while let Some(k) = map_.next_key()? {
2483 match k {
2484 GeneratedField::OriginalIndices => {
2485 if original_indices__.is_some() {
2486 return Err(serde::de::Error::duplicate_field("originalIndices"));
2487 }
2488 original_indices__ =
2489 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2490 .into_iter().map(|x| x.0).collect())
2491 ;
2492 }
2493 GeneratedField::Data => {
2494 if data__.is_some() {
2495 return Err(serde::de::Error::duplicate_field("data"));
2496 }
2497 data__ =
2498 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2499 .into_iter().map(|x| x.0).collect())
2500 ;
2501 }
2502 }
2503 }
2504 Ok(WorkerSlotMapping {
2505 original_indices: original_indices__.unwrap_or_default(),
2506 data: data__.unwrap_or_default(),
2507 })
2508 }
2509 }
2510 deserializer.deserialize_struct("common.WorkerSlotMapping", FIELDS, GeneratedVisitor)
2511 }
2512}
2513impl serde::Serialize for WorkerType {
2514 #[allow(deprecated)]
2515 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2516 where
2517 S: serde::Serializer,
2518 {
2519 let variant = match self {
2520 Self::Unspecified => "WORKER_TYPE_UNSPECIFIED",
2521 Self::Frontend => "WORKER_TYPE_FRONTEND",
2522 Self::ComputeNode => "WORKER_TYPE_COMPUTE_NODE",
2523 Self::RiseCtl => "WORKER_TYPE_RISE_CTL",
2524 Self::Compactor => "WORKER_TYPE_COMPACTOR",
2525 Self::Meta => "WORKER_TYPE_META",
2526 };
2527 serializer.serialize_str(variant)
2528 }
2529}
2530impl<'de> serde::Deserialize<'de> for WorkerType {
2531 #[allow(deprecated)]
2532 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2533 where
2534 D: serde::Deserializer<'de>,
2535 {
2536 const FIELDS: &[&str] = &[
2537 "WORKER_TYPE_UNSPECIFIED",
2538 "WORKER_TYPE_FRONTEND",
2539 "WORKER_TYPE_COMPUTE_NODE",
2540 "WORKER_TYPE_RISE_CTL",
2541 "WORKER_TYPE_COMPACTOR",
2542 "WORKER_TYPE_META",
2543 ];
2544
2545 struct GeneratedVisitor;
2546
2547 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2548 type Value = WorkerType;
2549
2550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2551 write!(formatter, "expected one of: {:?}", &FIELDS)
2552 }
2553
2554 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2555 where
2556 E: serde::de::Error,
2557 {
2558 i32::try_from(v)
2559 .ok()
2560 .and_then(|x| x.try_into().ok())
2561 .ok_or_else(|| {
2562 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2563 })
2564 }
2565
2566 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2567 where
2568 E: serde::de::Error,
2569 {
2570 i32::try_from(v)
2571 .ok()
2572 .and_then(|x| x.try_into().ok())
2573 .ok_or_else(|| {
2574 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2575 })
2576 }
2577
2578 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2579 where
2580 E: serde::de::Error,
2581 {
2582 match value {
2583 "WORKER_TYPE_UNSPECIFIED" => Ok(WorkerType::Unspecified),
2584 "WORKER_TYPE_FRONTEND" => Ok(WorkerType::Frontend),
2585 "WORKER_TYPE_COMPUTE_NODE" => Ok(WorkerType::ComputeNode),
2586 "WORKER_TYPE_RISE_CTL" => Ok(WorkerType::RiseCtl),
2587 "WORKER_TYPE_COMPACTOR" => Ok(WorkerType::Compactor),
2588 "WORKER_TYPE_META" => Ok(WorkerType::Meta),
2589 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2590 }
2591 }
2592 }
2593 deserializer.deserialize_any(GeneratedVisitor)
2594 }
2595}