1use crate::meta::*;
2impl serde::Serialize for ActivateWorkerNodeRequest {
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.host.is_some() {
11 len += 1;
12 }
13 if self.node_id != 0 {
14 len += 1;
15 }
16 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeRequest", len)?;
17 if let Some(v) = self.host.as_ref() {
18 struct_ser.serialize_field("host", v)?;
19 }
20 if self.node_id != 0 {
21 struct_ser.serialize_field("nodeId", &self.node_id)?;
22 }
23 struct_ser.end()
24 }
25}
26impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeRequest {
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 "host",
34 "node_id",
35 "nodeId",
36 ];
37
38 #[allow(clippy::enum_variant_names)]
39 enum GeneratedField {
40 Host,
41 NodeId,
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 "host" => Ok(GeneratedField::Host),
64 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
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 = ActivateWorkerNodeRequest;
75
76 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77 formatter.write_str("struct meta.ActivateWorkerNodeRequest")
78 }
79
80 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeRequest, V::Error>
81 where
82 V: serde::de::MapAccess<'de>,
83 {
84 let mut host__ = None;
85 let mut node_id__ = None;
86 while let Some(k) = map_.next_key()? {
87 match k {
88 GeneratedField::Host => {
89 if host__.is_some() {
90 return Err(serde::de::Error::duplicate_field("host"));
91 }
92 host__ = map_.next_value()?;
93 }
94 GeneratedField::NodeId => {
95 if node_id__.is_some() {
96 return Err(serde::de::Error::duplicate_field("nodeId"));
97 }
98 node_id__ =
99 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
100 ;
101 }
102 }
103 }
104 Ok(ActivateWorkerNodeRequest {
105 host: host__,
106 node_id: node_id__.unwrap_or_default(),
107 })
108 }
109 }
110 deserializer.deserialize_struct("meta.ActivateWorkerNodeRequest", FIELDS, GeneratedVisitor)
111 }
112}
113impl serde::Serialize for ActivateWorkerNodeResponse {
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.status.is_some() {
122 len += 1;
123 }
124 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeResponse", len)?;
125 if let Some(v) = self.status.as_ref() {
126 struct_ser.serialize_field("status", v)?;
127 }
128 struct_ser.end()
129 }
130}
131impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeResponse {
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 "status",
139 ];
140
141 #[allow(clippy::enum_variant_names)]
142 enum GeneratedField {
143 Status,
144 }
145 impl<'de> serde::Deserialize<'de> for GeneratedField {
146 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
147 where
148 D: serde::Deserializer<'de>,
149 {
150 struct GeneratedVisitor;
151
152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
153 type Value = GeneratedField;
154
155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
156 write!(formatter, "expected one of: {:?}", &FIELDS)
157 }
158
159 #[allow(unused_variables)]
160 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
161 where
162 E: serde::de::Error,
163 {
164 match value {
165 "status" => Ok(GeneratedField::Status),
166 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
167 }
168 }
169 }
170 deserializer.deserialize_identifier(GeneratedVisitor)
171 }
172 }
173 struct GeneratedVisitor;
174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
175 type Value = ActivateWorkerNodeResponse;
176
177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
178 formatter.write_str("struct meta.ActivateWorkerNodeResponse")
179 }
180
181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeResponse, V::Error>
182 where
183 V: serde::de::MapAccess<'de>,
184 {
185 let mut status__ = None;
186 while let Some(k) = map_.next_key()? {
187 match k {
188 GeneratedField::Status => {
189 if status__.is_some() {
190 return Err(serde::de::Error::duplicate_field("status"));
191 }
192 status__ = map_.next_value()?;
193 }
194 }
195 }
196 Ok(ActivateWorkerNodeResponse {
197 status: status__,
198 })
199 }
200 }
201 deserializer.deserialize_struct("meta.ActivateWorkerNodeResponse", FIELDS, GeneratedVisitor)
202 }
203}
204impl serde::Serialize for ActorCountPerParallelism {
205 #[allow(deprecated)]
206 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
207 where
208 S: serde::Serializer,
209 {
210 use serde::ser::SerializeStruct;
211 let mut len = 0;
212 if !self.worker_id_to_actor_count.is_empty() {
213 len += 1;
214 }
215 if self.hard_limit != 0 {
216 len += 1;
217 }
218 if self.soft_limit != 0 {
219 len += 1;
220 }
221 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism", len)?;
222 if !self.worker_id_to_actor_count.is_empty() {
223 struct_ser.serialize_field("workerIdToActorCount", &self.worker_id_to_actor_count)?;
224 }
225 if self.hard_limit != 0 {
226 #[allow(clippy::needless_borrow)]
227 #[allow(clippy::needless_borrows_for_generic_args)]
228 struct_ser.serialize_field("hardLimit", ToString::to_string(&self.hard_limit).as_str())?;
229 }
230 if self.soft_limit != 0 {
231 #[allow(clippy::needless_borrow)]
232 #[allow(clippy::needless_borrows_for_generic_args)]
233 struct_ser.serialize_field("softLimit", ToString::to_string(&self.soft_limit).as_str())?;
234 }
235 struct_ser.end()
236 }
237}
238impl<'de> serde::Deserialize<'de> for ActorCountPerParallelism {
239 #[allow(deprecated)]
240 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
241 where
242 D: serde::Deserializer<'de>,
243 {
244 const FIELDS: &[&str] = &[
245 "worker_id_to_actor_count",
246 "workerIdToActorCount",
247 "hard_limit",
248 "hardLimit",
249 "soft_limit",
250 "softLimit",
251 ];
252
253 #[allow(clippy::enum_variant_names)]
254 enum GeneratedField {
255 WorkerIdToActorCount,
256 HardLimit,
257 SoftLimit,
258 }
259 impl<'de> serde::Deserialize<'de> for GeneratedField {
260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
261 where
262 D: serde::Deserializer<'de>,
263 {
264 struct GeneratedVisitor;
265
266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
267 type Value = GeneratedField;
268
269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
270 write!(formatter, "expected one of: {:?}", &FIELDS)
271 }
272
273 #[allow(unused_variables)]
274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
275 where
276 E: serde::de::Error,
277 {
278 match value {
279 "workerIdToActorCount" | "worker_id_to_actor_count" => Ok(GeneratedField::WorkerIdToActorCount),
280 "hardLimit" | "hard_limit" => Ok(GeneratedField::HardLimit),
281 "softLimit" | "soft_limit" => Ok(GeneratedField::SoftLimit),
282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
283 }
284 }
285 }
286 deserializer.deserialize_identifier(GeneratedVisitor)
287 }
288 }
289 struct GeneratedVisitor;
290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
291 type Value = ActorCountPerParallelism;
292
293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
294 formatter.write_str("struct meta.ActorCountPerParallelism")
295 }
296
297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorCountPerParallelism, V::Error>
298 where
299 V: serde::de::MapAccess<'de>,
300 {
301 let mut worker_id_to_actor_count__ = None;
302 let mut hard_limit__ = None;
303 let mut soft_limit__ = None;
304 while let Some(k) = map_.next_key()? {
305 match k {
306 GeneratedField::WorkerIdToActorCount => {
307 if worker_id_to_actor_count__.is_some() {
308 return Err(serde::de::Error::duplicate_field("workerIdToActorCount"));
309 }
310 worker_id_to_actor_count__ = Some(
311 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
312 .into_iter().map(|(k,v)| (k.0, v)).collect()
313 );
314 }
315 GeneratedField::HardLimit => {
316 if hard_limit__.is_some() {
317 return Err(serde::de::Error::duplicate_field("hardLimit"));
318 }
319 hard_limit__ =
320 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
321 ;
322 }
323 GeneratedField::SoftLimit => {
324 if soft_limit__.is_some() {
325 return Err(serde::de::Error::duplicate_field("softLimit"));
326 }
327 soft_limit__ =
328 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
329 ;
330 }
331 }
332 }
333 Ok(ActorCountPerParallelism {
334 worker_id_to_actor_count: worker_id_to_actor_count__.unwrap_or_default(),
335 hard_limit: hard_limit__.unwrap_or_default(),
336 soft_limit: soft_limit__.unwrap_or_default(),
337 })
338 }
339 }
340 deserializer.deserialize_struct("meta.ActorCountPerParallelism", FIELDS, GeneratedVisitor)
341 }
342}
343impl serde::Serialize for actor_count_per_parallelism::WorkerActorCount {
344 #[allow(deprecated)]
345 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
346 where
347 S: serde::Serializer,
348 {
349 use serde::ser::SerializeStruct;
350 let mut len = 0;
351 if self.actor_count != 0 {
352 len += 1;
353 }
354 if self.parallelism != 0 {
355 len += 1;
356 }
357 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", len)?;
358 if self.actor_count != 0 {
359 #[allow(clippy::needless_borrow)]
360 #[allow(clippy::needless_borrows_for_generic_args)]
361 struct_ser.serialize_field("actorCount", ToString::to_string(&self.actor_count).as_str())?;
362 }
363 if self.parallelism != 0 {
364 #[allow(clippy::needless_borrow)]
365 #[allow(clippy::needless_borrows_for_generic_args)]
366 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
367 }
368 struct_ser.end()
369 }
370}
371impl<'de> serde::Deserialize<'de> for actor_count_per_parallelism::WorkerActorCount {
372 #[allow(deprecated)]
373 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
374 where
375 D: serde::Deserializer<'de>,
376 {
377 const FIELDS: &[&str] = &[
378 "actor_count",
379 "actorCount",
380 "parallelism",
381 ];
382
383 #[allow(clippy::enum_variant_names)]
384 enum GeneratedField {
385 ActorCount,
386 Parallelism,
387 }
388 impl<'de> serde::Deserialize<'de> for GeneratedField {
389 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
390 where
391 D: serde::Deserializer<'de>,
392 {
393 struct GeneratedVisitor;
394
395 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
396 type Value = GeneratedField;
397
398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
399 write!(formatter, "expected one of: {:?}", &FIELDS)
400 }
401
402 #[allow(unused_variables)]
403 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
404 where
405 E: serde::de::Error,
406 {
407 match value {
408 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
409 "parallelism" => Ok(GeneratedField::Parallelism),
410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
411 }
412 }
413 }
414 deserializer.deserialize_identifier(GeneratedVisitor)
415 }
416 }
417 struct GeneratedVisitor;
418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
419 type Value = actor_count_per_parallelism::WorkerActorCount;
420
421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
422 formatter.write_str("struct meta.ActorCountPerParallelism.WorkerActorCount")
423 }
424
425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<actor_count_per_parallelism::WorkerActorCount, V::Error>
426 where
427 V: serde::de::MapAccess<'de>,
428 {
429 let mut actor_count__ = None;
430 let mut parallelism__ = None;
431 while let Some(k) = map_.next_key()? {
432 match k {
433 GeneratedField::ActorCount => {
434 if actor_count__.is_some() {
435 return Err(serde::de::Error::duplicate_field("actorCount"));
436 }
437 actor_count__ =
438 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
439 ;
440 }
441 GeneratedField::Parallelism => {
442 if parallelism__.is_some() {
443 return Err(serde::de::Error::duplicate_field("parallelism"));
444 }
445 parallelism__ =
446 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
447 ;
448 }
449 }
450 }
451 Ok(actor_count_per_parallelism::WorkerActorCount {
452 actor_count: actor_count__.unwrap_or_default(),
453 parallelism: parallelism__.unwrap_or_default(),
454 })
455 }
456 }
457 deserializer.deserialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", FIELDS, GeneratedVisitor)
458 }
459}
460impl serde::Serialize for ActorIds {
461 #[allow(deprecated)]
462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
463 where
464 S: serde::Serializer,
465 {
466 use serde::ser::SerializeStruct;
467 let mut len = 0;
468 if !self.ids.is_empty() {
469 len += 1;
470 }
471 let mut struct_ser = serializer.serialize_struct("meta.ActorIds", len)?;
472 if !self.ids.is_empty() {
473 struct_ser.serialize_field("ids", &self.ids)?;
474 }
475 struct_ser.end()
476 }
477}
478impl<'de> serde::Deserialize<'de> for ActorIds {
479 #[allow(deprecated)]
480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
481 where
482 D: serde::Deserializer<'de>,
483 {
484 const FIELDS: &[&str] = &[
485 "ids",
486 ];
487
488 #[allow(clippy::enum_variant_names)]
489 enum GeneratedField {
490 Ids,
491 }
492 impl<'de> serde::Deserialize<'de> for GeneratedField {
493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
494 where
495 D: serde::Deserializer<'de>,
496 {
497 struct GeneratedVisitor;
498
499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
500 type Value = GeneratedField;
501
502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
503 write!(formatter, "expected one of: {:?}", &FIELDS)
504 }
505
506 #[allow(unused_variables)]
507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
508 where
509 E: serde::de::Error,
510 {
511 match value {
512 "ids" => Ok(GeneratedField::Ids),
513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
514 }
515 }
516 }
517 deserializer.deserialize_identifier(GeneratedVisitor)
518 }
519 }
520 struct GeneratedVisitor;
521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
522 type Value = ActorIds;
523
524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
525 formatter.write_str("struct meta.ActorIds")
526 }
527
528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorIds, V::Error>
529 where
530 V: serde::de::MapAccess<'de>,
531 {
532 let mut ids__ = None;
533 while let Some(k) = map_.next_key()? {
534 match k {
535 GeneratedField::Ids => {
536 if ids__.is_some() {
537 return Err(serde::de::Error::duplicate_field("ids"));
538 }
539 ids__ =
540 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
541 .into_iter().map(|x| x.0).collect())
542 ;
543 }
544 }
545 }
546 Ok(ActorIds {
547 ids: ids__.unwrap_or_default(),
548 })
549 }
550 }
551 deserializer.deserialize_struct("meta.ActorIds", FIELDS, GeneratedVisitor)
552 }
553}
554impl serde::Serialize for ActorLocation {
555 #[allow(deprecated)]
556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
557 where
558 S: serde::Serializer,
559 {
560 use serde::ser::SerializeStruct;
561 let mut len = 0;
562 if self.node.is_some() {
563 len += 1;
564 }
565 if !self.actors.is_empty() {
566 len += 1;
567 }
568 let mut struct_ser = serializer.serialize_struct("meta.ActorLocation", len)?;
569 if let Some(v) = self.node.as_ref() {
570 struct_ser.serialize_field("node", v)?;
571 }
572 if !self.actors.is_empty() {
573 struct_ser.serialize_field("actors", &self.actors)?;
574 }
575 struct_ser.end()
576 }
577}
578impl<'de> serde::Deserialize<'de> for ActorLocation {
579 #[allow(deprecated)]
580 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
581 where
582 D: serde::Deserializer<'de>,
583 {
584 const FIELDS: &[&str] = &[
585 "node",
586 "actors",
587 ];
588
589 #[allow(clippy::enum_variant_names)]
590 enum GeneratedField {
591 Node,
592 Actors,
593 }
594 impl<'de> serde::Deserialize<'de> for GeneratedField {
595 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
596 where
597 D: serde::Deserializer<'de>,
598 {
599 struct GeneratedVisitor;
600
601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
602 type Value = GeneratedField;
603
604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
605 write!(formatter, "expected one of: {:?}", &FIELDS)
606 }
607
608 #[allow(unused_variables)]
609 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
610 where
611 E: serde::de::Error,
612 {
613 match value {
614 "node" => Ok(GeneratedField::Node),
615 "actors" => Ok(GeneratedField::Actors),
616 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
617 }
618 }
619 }
620 deserializer.deserialize_identifier(GeneratedVisitor)
621 }
622 }
623 struct GeneratedVisitor;
624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
625 type Value = ActorLocation;
626
627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
628 formatter.write_str("struct meta.ActorLocation")
629 }
630
631 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorLocation, V::Error>
632 where
633 V: serde::de::MapAccess<'de>,
634 {
635 let mut node__ = None;
636 let mut actors__ = None;
637 while let Some(k) = map_.next_key()? {
638 match k {
639 GeneratedField::Node => {
640 if node__.is_some() {
641 return Err(serde::de::Error::duplicate_field("node"));
642 }
643 node__ = map_.next_value()?;
644 }
645 GeneratedField::Actors => {
646 if actors__.is_some() {
647 return Err(serde::de::Error::duplicate_field("actors"));
648 }
649 actors__ = Some(map_.next_value()?);
650 }
651 }
652 }
653 Ok(ActorLocation {
654 node: node__,
655 actors: actors__.unwrap_or_default(),
656 })
657 }
658 }
659 deserializer.deserialize_struct("meta.ActorLocation", FIELDS, GeneratedVisitor)
660 }
661}
662impl serde::Serialize for AddEventLogRequest {
663 #[allow(deprecated)]
664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
665 where
666 S: serde::Serializer,
667 {
668 use serde::ser::SerializeStruct;
669 let mut len = 0;
670 if self.event.is_some() {
671 len += 1;
672 }
673 let mut struct_ser = serializer.serialize_struct("meta.AddEventLogRequest", len)?;
674 if let Some(v) = self.event.as_ref() {
675 match v {
676 add_event_log_request::Event::WorkerNodePanic(v) => {
677 struct_ser.serialize_field("workerNodePanic", v)?;
678 }
679 add_event_log_request::Event::SinkFail(v) => {
680 struct_ser.serialize_field("sinkFail", v)?;
681 }
682 }
683 }
684 struct_ser.end()
685 }
686}
687impl<'de> serde::Deserialize<'de> for AddEventLogRequest {
688 #[allow(deprecated)]
689 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
690 where
691 D: serde::Deserializer<'de>,
692 {
693 const FIELDS: &[&str] = &[
694 "worker_node_panic",
695 "workerNodePanic",
696 "sink_fail",
697 "sinkFail",
698 ];
699
700 #[allow(clippy::enum_variant_names)]
701 enum GeneratedField {
702 WorkerNodePanic,
703 SinkFail,
704 }
705 impl<'de> serde::Deserialize<'de> for GeneratedField {
706 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
707 where
708 D: serde::Deserializer<'de>,
709 {
710 struct GeneratedVisitor;
711
712 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
713 type Value = GeneratedField;
714
715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
716 write!(formatter, "expected one of: {:?}", &FIELDS)
717 }
718
719 #[allow(unused_variables)]
720 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
721 where
722 E: serde::de::Error,
723 {
724 match value {
725 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
726 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
727 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
728 }
729 }
730 }
731 deserializer.deserialize_identifier(GeneratedVisitor)
732 }
733 }
734 struct GeneratedVisitor;
735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
736 type Value = AddEventLogRequest;
737
738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
739 formatter.write_str("struct meta.AddEventLogRequest")
740 }
741
742 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogRequest, V::Error>
743 where
744 V: serde::de::MapAccess<'de>,
745 {
746 let mut event__ = None;
747 while let Some(k) = map_.next_key()? {
748 match k {
749 GeneratedField::WorkerNodePanic => {
750 if event__.is_some() {
751 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
752 }
753 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::WorkerNodePanic)
754;
755 }
756 GeneratedField::SinkFail => {
757 if event__.is_some() {
758 return Err(serde::de::Error::duplicate_field("sinkFail"));
759 }
760 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::SinkFail)
761;
762 }
763 }
764 }
765 Ok(AddEventLogRequest {
766 event: event__,
767 })
768 }
769 }
770 deserializer.deserialize_struct("meta.AddEventLogRequest", FIELDS, GeneratedVisitor)
771 }
772}
773impl serde::Serialize for AddEventLogResponse {
774 #[allow(deprecated)]
775 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
776 where
777 S: serde::Serializer,
778 {
779 use serde::ser::SerializeStruct;
780 let len = 0;
781 let struct_ser = serializer.serialize_struct("meta.AddEventLogResponse", len)?;
782 struct_ser.end()
783 }
784}
785impl<'de> serde::Deserialize<'de> for AddEventLogResponse {
786 #[allow(deprecated)]
787 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
788 where
789 D: serde::Deserializer<'de>,
790 {
791 const FIELDS: &[&str] = &[
792 ];
793
794 #[allow(clippy::enum_variant_names)]
795 enum GeneratedField {
796 }
797 impl<'de> serde::Deserialize<'de> for GeneratedField {
798 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
799 where
800 D: serde::Deserializer<'de>,
801 {
802 struct GeneratedVisitor;
803
804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
805 type Value = GeneratedField;
806
807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
808 write!(formatter, "expected one of: {:?}", &FIELDS)
809 }
810
811 #[allow(unused_variables)]
812 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
813 where
814 E: serde::de::Error,
815 {
816 Err(serde::de::Error::unknown_field(value, FIELDS))
817 }
818 }
819 deserializer.deserialize_identifier(GeneratedVisitor)
820 }
821 }
822 struct GeneratedVisitor;
823 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
824 type Value = AddEventLogResponse;
825
826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
827 formatter.write_str("struct meta.AddEventLogResponse")
828 }
829
830 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogResponse, V::Error>
831 where
832 V: serde::de::MapAccess<'de>,
833 {
834 while map_.next_key::<GeneratedField>()?.is_some() {
835 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
836 }
837 Ok(AddEventLogResponse {
838 })
839 }
840 }
841 deserializer.deserialize_struct("meta.AddEventLogResponse", FIELDS, GeneratedVisitor)
842 }
843}
844impl serde::Serialize for AddWorkerNodeRequest {
845 #[allow(deprecated)]
846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
847 where
848 S: serde::Serializer,
849 {
850 use serde::ser::SerializeStruct;
851 let mut len = 0;
852 if self.worker_type != 0 {
853 len += 1;
854 }
855 if self.host.is_some() {
856 len += 1;
857 }
858 if self.resource.is_some() {
859 len += 1;
860 }
861 if self.property.is_some() {
862 len += 1;
863 }
864 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeRequest", len)?;
865 if self.worker_type != 0 {
866 let v = super::common::WorkerType::try_from(self.worker_type)
867 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
868 struct_ser.serialize_field("workerType", &v)?;
869 }
870 if let Some(v) = self.host.as_ref() {
871 struct_ser.serialize_field("host", v)?;
872 }
873 if let Some(v) = self.resource.as_ref() {
874 struct_ser.serialize_field("resource", v)?;
875 }
876 if let Some(v) = self.property.as_ref() {
877 struct_ser.serialize_field("property", v)?;
878 }
879 struct_ser.end()
880 }
881}
882impl<'de> serde::Deserialize<'de> for AddWorkerNodeRequest {
883 #[allow(deprecated)]
884 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
885 where
886 D: serde::Deserializer<'de>,
887 {
888 const FIELDS: &[&str] = &[
889 "worker_type",
890 "workerType",
891 "host",
892 "resource",
893 "property",
894 ];
895
896 #[allow(clippy::enum_variant_names)]
897 enum GeneratedField {
898 WorkerType,
899 Host,
900 Resource,
901 Property,
902 }
903 impl<'de> serde::Deserialize<'de> for GeneratedField {
904 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
905 where
906 D: serde::Deserializer<'de>,
907 {
908 struct GeneratedVisitor;
909
910 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
911 type Value = GeneratedField;
912
913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
914 write!(formatter, "expected one of: {:?}", &FIELDS)
915 }
916
917 #[allow(unused_variables)]
918 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
919 where
920 E: serde::de::Error,
921 {
922 match value {
923 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
924 "host" => Ok(GeneratedField::Host),
925 "resource" => Ok(GeneratedField::Resource),
926 "property" => Ok(GeneratedField::Property),
927 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
928 }
929 }
930 }
931 deserializer.deserialize_identifier(GeneratedVisitor)
932 }
933 }
934 struct GeneratedVisitor;
935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
936 type Value = AddWorkerNodeRequest;
937
938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
939 formatter.write_str("struct meta.AddWorkerNodeRequest")
940 }
941
942 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeRequest, V::Error>
943 where
944 V: serde::de::MapAccess<'de>,
945 {
946 let mut worker_type__ = None;
947 let mut host__ = None;
948 let mut resource__ = None;
949 let mut property__ = None;
950 while let Some(k) = map_.next_key()? {
951 match k {
952 GeneratedField::WorkerType => {
953 if worker_type__.is_some() {
954 return Err(serde::de::Error::duplicate_field("workerType"));
955 }
956 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
957 }
958 GeneratedField::Host => {
959 if host__.is_some() {
960 return Err(serde::de::Error::duplicate_field("host"));
961 }
962 host__ = map_.next_value()?;
963 }
964 GeneratedField::Resource => {
965 if resource__.is_some() {
966 return Err(serde::de::Error::duplicate_field("resource"));
967 }
968 resource__ = map_.next_value()?;
969 }
970 GeneratedField::Property => {
971 if property__.is_some() {
972 return Err(serde::de::Error::duplicate_field("property"));
973 }
974 property__ = map_.next_value()?;
975 }
976 }
977 }
978 Ok(AddWorkerNodeRequest {
979 worker_type: worker_type__.unwrap_or_default(),
980 host: host__,
981 resource: resource__,
982 property: property__,
983 })
984 }
985 }
986 deserializer.deserialize_struct("meta.AddWorkerNodeRequest", FIELDS, GeneratedVisitor)
987 }
988}
989impl serde::Serialize for AddWorkerNodeResponse {
990 #[allow(deprecated)]
991 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
992 where
993 S: serde::Serializer,
994 {
995 use serde::ser::SerializeStruct;
996 let mut len = 0;
997 if self.node_id.is_some() {
998 len += 1;
999 }
1000 if !self.cluster_id.is_empty() {
1001 len += 1;
1002 }
1003 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeResponse", len)?;
1004 if let Some(v) = self.node_id.as_ref() {
1005 struct_ser.serialize_field("nodeId", v)?;
1006 }
1007 if !self.cluster_id.is_empty() {
1008 struct_ser.serialize_field("clusterId", &self.cluster_id)?;
1009 }
1010 struct_ser.end()
1011 }
1012}
1013impl<'de> serde::Deserialize<'de> for AddWorkerNodeResponse {
1014 #[allow(deprecated)]
1015 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1016 where
1017 D: serde::Deserializer<'de>,
1018 {
1019 const FIELDS: &[&str] = &[
1020 "node_id",
1021 "nodeId",
1022 "cluster_id",
1023 "clusterId",
1024 ];
1025
1026 #[allow(clippy::enum_variant_names)]
1027 enum GeneratedField {
1028 NodeId,
1029 ClusterId,
1030 }
1031 impl<'de> serde::Deserialize<'de> for GeneratedField {
1032 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1033 where
1034 D: serde::Deserializer<'de>,
1035 {
1036 struct GeneratedVisitor;
1037
1038 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1039 type Value = GeneratedField;
1040
1041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1042 write!(formatter, "expected one of: {:?}", &FIELDS)
1043 }
1044
1045 #[allow(unused_variables)]
1046 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1047 where
1048 E: serde::de::Error,
1049 {
1050 match value {
1051 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
1052 "clusterId" | "cluster_id" => Ok(GeneratedField::ClusterId),
1053 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1054 }
1055 }
1056 }
1057 deserializer.deserialize_identifier(GeneratedVisitor)
1058 }
1059 }
1060 struct GeneratedVisitor;
1061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1062 type Value = AddWorkerNodeResponse;
1063
1064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1065 formatter.write_str("struct meta.AddWorkerNodeResponse")
1066 }
1067
1068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeResponse, V::Error>
1069 where
1070 V: serde::de::MapAccess<'de>,
1071 {
1072 let mut node_id__ = None;
1073 let mut cluster_id__ = None;
1074 while let Some(k) = map_.next_key()? {
1075 match k {
1076 GeneratedField::NodeId => {
1077 if node_id__.is_some() {
1078 return Err(serde::de::Error::duplicate_field("nodeId"));
1079 }
1080 node_id__ =
1081 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1082 ;
1083 }
1084 GeneratedField::ClusterId => {
1085 if cluster_id__.is_some() {
1086 return Err(serde::de::Error::duplicate_field("clusterId"));
1087 }
1088 cluster_id__ = Some(map_.next_value()?);
1089 }
1090 }
1091 }
1092 Ok(AddWorkerNodeResponse {
1093 node_id: node_id__,
1094 cluster_id: cluster_id__.unwrap_or_default(),
1095 })
1096 }
1097 }
1098 deserializer.deserialize_struct("meta.AddWorkerNodeResponse", FIELDS, GeneratedVisitor)
1099 }
1100}
1101impl serde::Serialize for AlterConnectorPropsRequest {
1102 #[allow(deprecated)]
1103 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1104 where
1105 S: serde::Serializer,
1106 {
1107 use serde::ser::SerializeStruct;
1108 let mut len = 0;
1109 if self.object_id != 0 {
1110 len += 1;
1111 }
1112 if !self.changed_props.is_empty() {
1113 len += 1;
1114 }
1115 if !self.changed_secret_refs.is_empty() {
1116 len += 1;
1117 }
1118 if self.connector_conn_ref.is_some() {
1119 len += 1;
1120 }
1121 if self.object_type != 0 {
1122 len += 1;
1123 }
1124 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest", len)?;
1125 if self.object_id != 0 {
1126 struct_ser.serialize_field("objectId", &self.object_id)?;
1127 }
1128 if !self.changed_props.is_empty() {
1129 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1130 }
1131 if !self.changed_secret_refs.is_empty() {
1132 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1133 }
1134 if let Some(v) = self.connector_conn_ref.as_ref() {
1135 struct_ser.serialize_field("connectorConnRef", v)?;
1136 }
1137 if self.object_type != 0 {
1138 let v = alter_connector_props_request::AlterConnectorPropsObject::try_from(self.object_type)
1139 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
1140 struct_ser.serialize_field("objectType", &v)?;
1141 }
1142 struct_ser.end()
1143 }
1144}
1145impl<'de> serde::Deserialize<'de> for AlterConnectorPropsRequest {
1146 #[allow(deprecated)]
1147 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1148 where
1149 D: serde::Deserializer<'de>,
1150 {
1151 const FIELDS: &[&str] = &[
1152 "object_id",
1153 "objectId",
1154 "changed_props",
1155 "changedProps",
1156 "changed_secret_refs",
1157 "changedSecretRefs",
1158 "connector_conn_ref",
1159 "connectorConnRef",
1160 "object_type",
1161 "objectType",
1162 ];
1163
1164 #[allow(clippy::enum_variant_names)]
1165 enum GeneratedField {
1166 ObjectId,
1167 ChangedProps,
1168 ChangedSecretRefs,
1169 ConnectorConnRef,
1170 ObjectType,
1171 }
1172 impl<'de> serde::Deserialize<'de> for GeneratedField {
1173 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1174 where
1175 D: serde::Deserializer<'de>,
1176 {
1177 struct GeneratedVisitor;
1178
1179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1180 type Value = GeneratedField;
1181
1182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1183 write!(formatter, "expected one of: {:?}", &FIELDS)
1184 }
1185
1186 #[allow(unused_variables)]
1187 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1188 where
1189 E: serde::de::Error,
1190 {
1191 match value {
1192 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
1193 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1194 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1195 "connectorConnRef" | "connector_conn_ref" => Ok(GeneratedField::ConnectorConnRef),
1196 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
1197 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1198 }
1199 }
1200 }
1201 deserializer.deserialize_identifier(GeneratedVisitor)
1202 }
1203 }
1204 struct GeneratedVisitor;
1205 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1206 type Value = AlterConnectorPropsRequest;
1207
1208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1209 formatter.write_str("struct meta.AlterConnectorPropsRequest")
1210 }
1211
1212 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsRequest, V::Error>
1213 where
1214 V: serde::de::MapAccess<'de>,
1215 {
1216 let mut object_id__ = None;
1217 let mut changed_props__ = None;
1218 let mut changed_secret_refs__ = None;
1219 let mut connector_conn_ref__ = None;
1220 let mut object_type__ = None;
1221 while let Some(k) = map_.next_key()? {
1222 match k {
1223 GeneratedField::ObjectId => {
1224 if object_id__.is_some() {
1225 return Err(serde::de::Error::duplicate_field("objectId"));
1226 }
1227 object_id__ =
1228 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1229 ;
1230 }
1231 GeneratedField::ChangedProps => {
1232 if changed_props__.is_some() {
1233 return Err(serde::de::Error::duplicate_field("changedProps"));
1234 }
1235 changed_props__ = Some(
1236 map_.next_value::<std::collections::HashMap<_, _>>()?
1237 );
1238 }
1239 GeneratedField::ChangedSecretRefs => {
1240 if changed_secret_refs__.is_some() {
1241 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1242 }
1243 changed_secret_refs__ = Some(
1244 map_.next_value::<std::collections::HashMap<_, _>>()?
1245 );
1246 }
1247 GeneratedField::ConnectorConnRef => {
1248 if connector_conn_ref__.is_some() {
1249 return Err(serde::de::Error::duplicate_field("connectorConnRef"));
1250 }
1251 connector_conn_ref__ =
1252 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1253 ;
1254 }
1255 GeneratedField::ObjectType => {
1256 if object_type__.is_some() {
1257 return Err(serde::de::Error::duplicate_field("objectType"));
1258 }
1259 object_type__ = Some(map_.next_value::<alter_connector_props_request::AlterConnectorPropsObject>()? as i32);
1260 }
1261 }
1262 }
1263 Ok(AlterConnectorPropsRequest {
1264 object_id: object_id__.unwrap_or_default(),
1265 changed_props: changed_props__.unwrap_or_default(),
1266 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1267 connector_conn_ref: connector_conn_ref__,
1268 object_type: object_type__.unwrap_or_default(),
1269 })
1270 }
1271 }
1272 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest", FIELDS, GeneratedVisitor)
1273 }
1274}
1275impl serde::Serialize for alter_connector_props_request::AlterConnectorPropsObject {
1276 #[allow(deprecated)]
1277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1278 where
1279 S: serde::Serializer,
1280 {
1281 let variant = match self {
1282 Self::Unspecified => "UNSPECIFIED",
1283 Self::Source => "SOURCE",
1284 Self::Sink => "SINK",
1285 Self::Connection => "CONNECTION",
1286 };
1287 serializer.serialize_str(variant)
1288 }
1289}
1290impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterConnectorPropsObject {
1291 #[allow(deprecated)]
1292 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1293 where
1294 D: serde::Deserializer<'de>,
1295 {
1296 const FIELDS: &[&str] = &[
1297 "UNSPECIFIED",
1298 "SOURCE",
1299 "SINK",
1300 "CONNECTION",
1301 ];
1302
1303 struct GeneratedVisitor;
1304
1305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1306 type Value = alter_connector_props_request::AlterConnectorPropsObject;
1307
1308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1309 write!(formatter, "expected one of: {:?}", &FIELDS)
1310 }
1311
1312 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1313 where
1314 E: serde::de::Error,
1315 {
1316 i32::try_from(v)
1317 .ok()
1318 .and_then(|x| x.try_into().ok())
1319 .ok_or_else(|| {
1320 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1321 })
1322 }
1323
1324 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1325 where
1326 E: serde::de::Error,
1327 {
1328 i32::try_from(v)
1329 .ok()
1330 .and_then(|x| x.try_into().ok())
1331 .ok_or_else(|| {
1332 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1333 })
1334 }
1335
1336 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1337 where
1338 E: serde::de::Error,
1339 {
1340 match value {
1341 "UNSPECIFIED" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Unspecified),
1342 "SOURCE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Source),
1343 "SINK" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Sink),
1344 "CONNECTION" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Connection),
1345 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1346 }
1347 }
1348 }
1349 deserializer.deserialize_any(GeneratedVisitor)
1350 }
1351}
1352impl serde::Serialize for AlterConnectorPropsResponse {
1353 #[allow(deprecated)]
1354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1355 where
1356 S: serde::Serializer,
1357 {
1358 use serde::ser::SerializeStruct;
1359 let len = 0;
1360 let struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsResponse", len)?;
1361 struct_ser.end()
1362 }
1363}
1364impl<'de> serde::Deserialize<'de> for AlterConnectorPropsResponse {
1365 #[allow(deprecated)]
1366 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1367 where
1368 D: serde::Deserializer<'de>,
1369 {
1370 const FIELDS: &[&str] = &[
1371 ];
1372
1373 #[allow(clippy::enum_variant_names)]
1374 enum GeneratedField {
1375 }
1376 impl<'de> serde::Deserialize<'de> for GeneratedField {
1377 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1378 where
1379 D: serde::Deserializer<'de>,
1380 {
1381 struct GeneratedVisitor;
1382
1383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1384 type Value = GeneratedField;
1385
1386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1387 write!(formatter, "expected one of: {:?}", &FIELDS)
1388 }
1389
1390 #[allow(unused_variables)]
1391 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1392 where
1393 E: serde::de::Error,
1394 {
1395 Err(serde::de::Error::unknown_field(value, FIELDS))
1396 }
1397 }
1398 deserializer.deserialize_identifier(GeneratedVisitor)
1399 }
1400 }
1401 struct GeneratedVisitor;
1402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1403 type Value = AlterConnectorPropsResponse;
1404
1405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1406 formatter.write_str("struct meta.AlterConnectorPropsResponse")
1407 }
1408
1409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsResponse, V::Error>
1410 where
1411 V: serde::de::MapAccess<'de>,
1412 {
1413 while map_.next_key::<GeneratedField>()?.is_some() {
1414 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1415 }
1416 Ok(AlterConnectorPropsResponse {
1417 })
1418 }
1419 }
1420 deserializer.deserialize_struct("meta.AlterConnectorPropsResponse", FIELDS, GeneratedVisitor)
1421 }
1422}
1423impl serde::Serialize for ApplyThrottleRequest {
1424 #[allow(deprecated)]
1425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1426 where
1427 S: serde::Serializer,
1428 {
1429 use serde::ser::SerializeStruct;
1430 let mut len = 0;
1431 if self.kind != 0 {
1432 len += 1;
1433 }
1434 if self.id != 0 {
1435 len += 1;
1436 }
1437 if self.rate.is_some() {
1438 len += 1;
1439 }
1440 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1441 if self.kind != 0 {
1442 let v = ThrottleTarget::try_from(self.kind)
1443 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1444 struct_ser.serialize_field("kind", &v)?;
1445 }
1446 if self.id != 0 {
1447 struct_ser.serialize_field("id", &self.id)?;
1448 }
1449 if let Some(v) = self.rate.as_ref() {
1450 struct_ser.serialize_field("rate", v)?;
1451 }
1452 struct_ser.end()
1453 }
1454}
1455impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1456 #[allow(deprecated)]
1457 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1458 where
1459 D: serde::Deserializer<'de>,
1460 {
1461 const FIELDS: &[&str] = &[
1462 "kind",
1463 "id",
1464 "rate",
1465 ];
1466
1467 #[allow(clippy::enum_variant_names)]
1468 enum GeneratedField {
1469 Kind,
1470 Id,
1471 Rate,
1472 }
1473 impl<'de> serde::Deserialize<'de> for GeneratedField {
1474 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1475 where
1476 D: serde::Deserializer<'de>,
1477 {
1478 struct GeneratedVisitor;
1479
1480 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1481 type Value = GeneratedField;
1482
1483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1484 write!(formatter, "expected one of: {:?}", &FIELDS)
1485 }
1486
1487 #[allow(unused_variables)]
1488 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1489 where
1490 E: serde::de::Error,
1491 {
1492 match value {
1493 "kind" => Ok(GeneratedField::Kind),
1494 "id" => Ok(GeneratedField::Id),
1495 "rate" => Ok(GeneratedField::Rate),
1496 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1497 }
1498 }
1499 }
1500 deserializer.deserialize_identifier(GeneratedVisitor)
1501 }
1502 }
1503 struct GeneratedVisitor;
1504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1505 type Value = ApplyThrottleRequest;
1506
1507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1508 formatter.write_str("struct meta.ApplyThrottleRequest")
1509 }
1510
1511 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1512 where
1513 V: serde::de::MapAccess<'de>,
1514 {
1515 let mut kind__ = None;
1516 let mut id__ = None;
1517 let mut rate__ = None;
1518 while let Some(k) = map_.next_key()? {
1519 match k {
1520 GeneratedField::Kind => {
1521 if kind__.is_some() {
1522 return Err(serde::de::Error::duplicate_field("kind"));
1523 }
1524 kind__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1525 }
1526 GeneratedField::Id => {
1527 if id__.is_some() {
1528 return Err(serde::de::Error::duplicate_field("id"));
1529 }
1530 id__ =
1531 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1532 ;
1533 }
1534 GeneratedField::Rate => {
1535 if rate__.is_some() {
1536 return Err(serde::de::Error::duplicate_field("rate"));
1537 }
1538 rate__ =
1539 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1540 ;
1541 }
1542 }
1543 }
1544 Ok(ApplyThrottleRequest {
1545 kind: kind__.unwrap_or_default(),
1546 id: id__.unwrap_or_default(),
1547 rate: rate__,
1548 })
1549 }
1550 }
1551 deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1552 }
1553}
1554impl serde::Serialize for ApplyThrottleResponse {
1555 #[allow(deprecated)]
1556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1557 where
1558 S: serde::Serializer,
1559 {
1560 use serde::ser::SerializeStruct;
1561 let mut len = 0;
1562 if self.status.is_some() {
1563 len += 1;
1564 }
1565 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1566 if let Some(v) = self.status.as_ref() {
1567 struct_ser.serialize_field("status", v)?;
1568 }
1569 struct_ser.end()
1570 }
1571}
1572impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1573 #[allow(deprecated)]
1574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1575 where
1576 D: serde::Deserializer<'de>,
1577 {
1578 const FIELDS: &[&str] = &[
1579 "status",
1580 ];
1581
1582 #[allow(clippy::enum_variant_names)]
1583 enum GeneratedField {
1584 Status,
1585 }
1586 impl<'de> serde::Deserialize<'de> for GeneratedField {
1587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1588 where
1589 D: serde::Deserializer<'de>,
1590 {
1591 struct GeneratedVisitor;
1592
1593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1594 type Value = GeneratedField;
1595
1596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1597 write!(formatter, "expected one of: {:?}", &FIELDS)
1598 }
1599
1600 #[allow(unused_variables)]
1601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1602 where
1603 E: serde::de::Error,
1604 {
1605 match value {
1606 "status" => Ok(GeneratedField::Status),
1607 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1608 }
1609 }
1610 }
1611 deserializer.deserialize_identifier(GeneratedVisitor)
1612 }
1613 }
1614 struct GeneratedVisitor;
1615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1616 type Value = ApplyThrottleResponse;
1617
1618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1619 formatter.write_str("struct meta.ApplyThrottleResponse")
1620 }
1621
1622 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
1623 where
1624 V: serde::de::MapAccess<'de>,
1625 {
1626 let mut status__ = None;
1627 while let Some(k) = map_.next_key()? {
1628 match k {
1629 GeneratedField::Status => {
1630 if status__.is_some() {
1631 return Err(serde::de::Error::duplicate_field("status"));
1632 }
1633 status__ = map_.next_value()?;
1634 }
1635 }
1636 }
1637 Ok(ApplyThrottleResponse {
1638 status: status__,
1639 })
1640 }
1641 }
1642 deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
1643 }
1644}
1645impl serde::Serialize for CancelCreatingJobsRequest {
1646 #[allow(deprecated)]
1647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1648 where
1649 S: serde::Serializer,
1650 {
1651 use serde::ser::SerializeStruct;
1652 let mut len = 0;
1653 if self.jobs.is_some() {
1654 len += 1;
1655 }
1656 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
1657 if let Some(v) = self.jobs.as_ref() {
1658 match v {
1659 cancel_creating_jobs_request::Jobs::Infos(v) => {
1660 struct_ser.serialize_field("infos", v)?;
1661 }
1662 cancel_creating_jobs_request::Jobs::Ids(v) => {
1663 struct_ser.serialize_field("ids", v)?;
1664 }
1665 }
1666 }
1667 struct_ser.end()
1668 }
1669}
1670impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
1671 #[allow(deprecated)]
1672 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1673 where
1674 D: serde::Deserializer<'de>,
1675 {
1676 const FIELDS: &[&str] = &[
1677 "infos",
1678 "ids",
1679 ];
1680
1681 #[allow(clippy::enum_variant_names)]
1682 enum GeneratedField {
1683 Infos,
1684 Ids,
1685 }
1686 impl<'de> serde::Deserialize<'de> for GeneratedField {
1687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1688 where
1689 D: serde::Deserializer<'de>,
1690 {
1691 struct GeneratedVisitor;
1692
1693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1694 type Value = GeneratedField;
1695
1696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1697 write!(formatter, "expected one of: {:?}", &FIELDS)
1698 }
1699
1700 #[allow(unused_variables)]
1701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1702 where
1703 E: serde::de::Error,
1704 {
1705 match value {
1706 "infos" => Ok(GeneratedField::Infos),
1707 "ids" => Ok(GeneratedField::Ids),
1708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1709 }
1710 }
1711 }
1712 deserializer.deserialize_identifier(GeneratedVisitor)
1713 }
1714 }
1715 struct GeneratedVisitor;
1716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1717 type Value = CancelCreatingJobsRequest;
1718
1719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1720 formatter.write_str("struct meta.CancelCreatingJobsRequest")
1721 }
1722
1723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
1724 where
1725 V: serde::de::MapAccess<'de>,
1726 {
1727 let mut jobs__ = None;
1728 while let Some(k) = map_.next_key()? {
1729 match k {
1730 GeneratedField::Infos => {
1731 if jobs__.is_some() {
1732 return Err(serde::de::Error::duplicate_field("infos"));
1733 }
1734 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
1735;
1736 }
1737 GeneratedField::Ids => {
1738 if jobs__.is_some() {
1739 return Err(serde::de::Error::duplicate_field("ids"));
1740 }
1741 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
1742;
1743 }
1744 }
1745 }
1746 Ok(CancelCreatingJobsRequest {
1747 jobs: jobs__,
1748 })
1749 }
1750 }
1751 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
1752 }
1753}
1754impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
1755 #[allow(deprecated)]
1756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1757 where
1758 S: serde::Serializer,
1759 {
1760 use serde::ser::SerializeStruct;
1761 let mut len = 0;
1762 if !self.job_ids.is_empty() {
1763 len += 1;
1764 }
1765 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
1766 if !self.job_ids.is_empty() {
1767 struct_ser.serialize_field("jobIds", &self.job_ids)?;
1768 }
1769 struct_ser.end()
1770 }
1771}
1772impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
1773 #[allow(deprecated)]
1774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1775 where
1776 D: serde::Deserializer<'de>,
1777 {
1778 const FIELDS: &[&str] = &[
1779 "job_ids",
1780 "jobIds",
1781 ];
1782
1783 #[allow(clippy::enum_variant_names)]
1784 enum GeneratedField {
1785 JobIds,
1786 }
1787 impl<'de> serde::Deserialize<'de> for GeneratedField {
1788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1789 where
1790 D: serde::Deserializer<'de>,
1791 {
1792 struct GeneratedVisitor;
1793
1794 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1795 type Value = GeneratedField;
1796
1797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1798 write!(formatter, "expected one of: {:?}", &FIELDS)
1799 }
1800
1801 #[allow(unused_variables)]
1802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1803 where
1804 E: serde::de::Error,
1805 {
1806 match value {
1807 "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
1808 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1809 }
1810 }
1811 }
1812 deserializer.deserialize_identifier(GeneratedVisitor)
1813 }
1814 }
1815 struct GeneratedVisitor;
1816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1817 type Value = cancel_creating_jobs_request::CreatingJobIds;
1818
1819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1820 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
1821 }
1822
1823 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
1824 where
1825 V: serde::de::MapAccess<'de>,
1826 {
1827 let mut job_ids__ = None;
1828 while let Some(k) = map_.next_key()? {
1829 match k {
1830 GeneratedField::JobIds => {
1831 if job_ids__.is_some() {
1832 return Err(serde::de::Error::duplicate_field("jobIds"));
1833 }
1834 job_ids__ =
1835 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1836 .into_iter().map(|x| x.0).collect())
1837 ;
1838 }
1839 }
1840 }
1841 Ok(cancel_creating_jobs_request::CreatingJobIds {
1842 job_ids: job_ids__.unwrap_or_default(),
1843 })
1844 }
1845 }
1846 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
1847 }
1848}
1849impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
1850 #[allow(deprecated)]
1851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1852 where
1853 S: serde::Serializer,
1854 {
1855 use serde::ser::SerializeStruct;
1856 let mut len = 0;
1857 if self.database_id != 0 {
1858 len += 1;
1859 }
1860 if self.schema_id != 0 {
1861 len += 1;
1862 }
1863 if !self.name.is_empty() {
1864 len += 1;
1865 }
1866 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
1867 if self.database_id != 0 {
1868 struct_ser.serialize_field("databaseId", &self.database_id)?;
1869 }
1870 if self.schema_id != 0 {
1871 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1872 }
1873 if !self.name.is_empty() {
1874 struct_ser.serialize_field("name", &self.name)?;
1875 }
1876 struct_ser.end()
1877 }
1878}
1879impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
1880 #[allow(deprecated)]
1881 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1882 where
1883 D: serde::Deserializer<'de>,
1884 {
1885 const FIELDS: &[&str] = &[
1886 "database_id",
1887 "databaseId",
1888 "schema_id",
1889 "schemaId",
1890 "name",
1891 ];
1892
1893 #[allow(clippy::enum_variant_names)]
1894 enum GeneratedField {
1895 DatabaseId,
1896 SchemaId,
1897 Name,
1898 }
1899 impl<'de> serde::Deserialize<'de> for GeneratedField {
1900 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1901 where
1902 D: serde::Deserializer<'de>,
1903 {
1904 struct GeneratedVisitor;
1905
1906 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1907 type Value = GeneratedField;
1908
1909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1910 write!(formatter, "expected one of: {:?}", &FIELDS)
1911 }
1912
1913 #[allow(unused_variables)]
1914 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1915 where
1916 E: serde::de::Error,
1917 {
1918 match value {
1919 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1920 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1921 "name" => Ok(GeneratedField::Name),
1922 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1923 }
1924 }
1925 }
1926 deserializer.deserialize_identifier(GeneratedVisitor)
1927 }
1928 }
1929 struct GeneratedVisitor;
1930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1931 type Value = cancel_creating_jobs_request::CreatingJobInfo;
1932
1933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1934 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
1935 }
1936
1937 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
1938 where
1939 V: serde::de::MapAccess<'de>,
1940 {
1941 let mut database_id__ = None;
1942 let mut schema_id__ = None;
1943 let mut name__ = None;
1944 while let Some(k) = map_.next_key()? {
1945 match k {
1946 GeneratedField::DatabaseId => {
1947 if database_id__.is_some() {
1948 return Err(serde::de::Error::duplicate_field("databaseId"));
1949 }
1950 database_id__ =
1951 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1952 ;
1953 }
1954 GeneratedField::SchemaId => {
1955 if schema_id__.is_some() {
1956 return Err(serde::de::Error::duplicate_field("schemaId"));
1957 }
1958 schema_id__ =
1959 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1960 ;
1961 }
1962 GeneratedField::Name => {
1963 if name__.is_some() {
1964 return Err(serde::de::Error::duplicate_field("name"));
1965 }
1966 name__ = Some(map_.next_value()?);
1967 }
1968 }
1969 }
1970 Ok(cancel_creating_jobs_request::CreatingJobInfo {
1971 database_id: database_id__.unwrap_or_default(),
1972 schema_id: schema_id__.unwrap_or_default(),
1973 name: name__.unwrap_or_default(),
1974 })
1975 }
1976 }
1977 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
1978 }
1979}
1980impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
1981 #[allow(deprecated)]
1982 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1983 where
1984 S: serde::Serializer,
1985 {
1986 use serde::ser::SerializeStruct;
1987 let mut len = 0;
1988 if !self.infos.is_empty() {
1989 len += 1;
1990 }
1991 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
1992 if !self.infos.is_empty() {
1993 struct_ser.serialize_field("infos", &self.infos)?;
1994 }
1995 struct_ser.end()
1996 }
1997}
1998impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
1999 #[allow(deprecated)]
2000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2001 where
2002 D: serde::Deserializer<'de>,
2003 {
2004 const FIELDS: &[&str] = &[
2005 "infos",
2006 ];
2007
2008 #[allow(clippy::enum_variant_names)]
2009 enum GeneratedField {
2010 Infos,
2011 }
2012 impl<'de> serde::Deserialize<'de> for GeneratedField {
2013 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2014 where
2015 D: serde::Deserializer<'de>,
2016 {
2017 struct GeneratedVisitor;
2018
2019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2020 type Value = GeneratedField;
2021
2022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2023 write!(formatter, "expected one of: {:?}", &FIELDS)
2024 }
2025
2026 #[allow(unused_variables)]
2027 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2028 where
2029 E: serde::de::Error,
2030 {
2031 match value {
2032 "infos" => Ok(GeneratedField::Infos),
2033 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2034 }
2035 }
2036 }
2037 deserializer.deserialize_identifier(GeneratedVisitor)
2038 }
2039 }
2040 struct GeneratedVisitor;
2041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2042 type Value = cancel_creating_jobs_request::CreatingJobInfos;
2043
2044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2045 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2046 }
2047
2048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2049 where
2050 V: serde::de::MapAccess<'de>,
2051 {
2052 let mut infos__ = None;
2053 while let Some(k) = map_.next_key()? {
2054 match k {
2055 GeneratedField::Infos => {
2056 if infos__.is_some() {
2057 return Err(serde::de::Error::duplicate_field("infos"));
2058 }
2059 infos__ = Some(map_.next_value()?);
2060 }
2061 }
2062 }
2063 Ok(cancel_creating_jobs_request::CreatingJobInfos {
2064 infos: infos__.unwrap_or_default(),
2065 })
2066 }
2067 }
2068 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2069 }
2070}
2071impl serde::Serialize for CancelCreatingJobsResponse {
2072 #[allow(deprecated)]
2073 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2074 where
2075 S: serde::Serializer,
2076 {
2077 use serde::ser::SerializeStruct;
2078 let mut len = 0;
2079 if self.status.is_some() {
2080 len += 1;
2081 }
2082 if !self.canceled_jobs.is_empty() {
2083 len += 1;
2084 }
2085 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2086 if let Some(v) = self.status.as_ref() {
2087 struct_ser.serialize_field("status", v)?;
2088 }
2089 if !self.canceled_jobs.is_empty() {
2090 struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2091 }
2092 struct_ser.end()
2093 }
2094}
2095impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2096 #[allow(deprecated)]
2097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2098 where
2099 D: serde::Deserializer<'de>,
2100 {
2101 const FIELDS: &[&str] = &[
2102 "status",
2103 "canceled_jobs",
2104 "canceledJobs",
2105 ];
2106
2107 #[allow(clippy::enum_variant_names)]
2108 enum GeneratedField {
2109 Status,
2110 CanceledJobs,
2111 }
2112 impl<'de> serde::Deserialize<'de> for GeneratedField {
2113 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2114 where
2115 D: serde::Deserializer<'de>,
2116 {
2117 struct GeneratedVisitor;
2118
2119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2120 type Value = GeneratedField;
2121
2122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2123 write!(formatter, "expected one of: {:?}", &FIELDS)
2124 }
2125
2126 #[allow(unused_variables)]
2127 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2128 where
2129 E: serde::de::Error,
2130 {
2131 match value {
2132 "status" => Ok(GeneratedField::Status),
2133 "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2134 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2135 }
2136 }
2137 }
2138 deserializer.deserialize_identifier(GeneratedVisitor)
2139 }
2140 }
2141 struct GeneratedVisitor;
2142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2143 type Value = CancelCreatingJobsResponse;
2144
2145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2146 formatter.write_str("struct meta.CancelCreatingJobsResponse")
2147 }
2148
2149 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2150 where
2151 V: serde::de::MapAccess<'de>,
2152 {
2153 let mut status__ = None;
2154 let mut canceled_jobs__ = None;
2155 while let Some(k) = map_.next_key()? {
2156 match k {
2157 GeneratedField::Status => {
2158 if status__.is_some() {
2159 return Err(serde::de::Error::duplicate_field("status"));
2160 }
2161 status__ = map_.next_value()?;
2162 }
2163 GeneratedField::CanceledJobs => {
2164 if canceled_jobs__.is_some() {
2165 return Err(serde::de::Error::duplicate_field("canceledJobs"));
2166 }
2167 canceled_jobs__ =
2168 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2169 .into_iter().map(|x| x.0).collect())
2170 ;
2171 }
2172 }
2173 }
2174 Ok(CancelCreatingJobsResponse {
2175 status: status__,
2176 canceled_jobs: canceled_jobs__.unwrap_or_default(),
2177 })
2178 }
2179 }
2180 deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2181 }
2182}
2183impl serde::Serialize for ClusterLimit {
2184 #[allow(deprecated)]
2185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2186 where
2187 S: serde::Serializer,
2188 {
2189 use serde::ser::SerializeStruct;
2190 let mut len = 0;
2191 if self.limit.is_some() {
2192 len += 1;
2193 }
2194 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2195 if let Some(v) = self.limit.as_ref() {
2196 match v {
2197 cluster_limit::Limit::ActorCount(v) => {
2198 struct_ser.serialize_field("actorCount", v)?;
2199 }
2200 }
2201 }
2202 struct_ser.end()
2203 }
2204}
2205impl<'de> serde::Deserialize<'de> for ClusterLimit {
2206 #[allow(deprecated)]
2207 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2208 where
2209 D: serde::Deserializer<'de>,
2210 {
2211 const FIELDS: &[&str] = &[
2212 "actor_count",
2213 "actorCount",
2214 ];
2215
2216 #[allow(clippy::enum_variant_names)]
2217 enum GeneratedField {
2218 ActorCount,
2219 }
2220 impl<'de> serde::Deserialize<'de> for GeneratedField {
2221 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2222 where
2223 D: serde::Deserializer<'de>,
2224 {
2225 struct GeneratedVisitor;
2226
2227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2228 type Value = GeneratedField;
2229
2230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2231 write!(formatter, "expected one of: {:?}", &FIELDS)
2232 }
2233
2234 #[allow(unused_variables)]
2235 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2236 where
2237 E: serde::de::Error,
2238 {
2239 match value {
2240 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2241 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2242 }
2243 }
2244 }
2245 deserializer.deserialize_identifier(GeneratedVisitor)
2246 }
2247 }
2248 struct GeneratedVisitor;
2249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2250 type Value = ClusterLimit;
2251
2252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2253 formatter.write_str("struct meta.ClusterLimit")
2254 }
2255
2256 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2257 where
2258 V: serde::de::MapAccess<'de>,
2259 {
2260 let mut limit__ = None;
2261 while let Some(k) = map_.next_key()? {
2262 match k {
2263 GeneratedField::ActorCount => {
2264 if limit__.is_some() {
2265 return Err(serde::de::Error::duplicate_field("actorCount"));
2266 }
2267 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2268;
2269 }
2270 }
2271 }
2272 Ok(ClusterLimit {
2273 limit: limit__,
2274 })
2275 }
2276 }
2277 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2278 }
2279}
2280impl serde::Serialize for DeleteWorkerNodeRequest {
2281 #[allow(deprecated)]
2282 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2283 where
2284 S: serde::Serializer,
2285 {
2286 use serde::ser::SerializeStruct;
2287 let mut len = 0;
2288 if self.host.is_some() {
2289 len += 1;
2290 }
2291 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2292 if let Some(v) = self.host.as_ref() {
2293 struct_ser.serialize_field("host", v)?;
2294 }
2295 struct_ser.end()
2296 }
2297}
2298impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2299 #[allow(deprecated)]
2300 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2301 where
2302 D: serde::Deserializer<'de>,
2303 {
2304 const FIELDS: &[&str] = &[
2305 "host",
2306 ];
2307
2308 #[allow(clippy::enum_variant_names)]
2309 enum GeneratedField {
2310 Host,
2311 }
2312 impl<'de> serde::Deserialize<'de> for GeneratedField {
2313 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2314 where
2315 D: serde::Deserializer<'de>,
2316 {
2317 struct GeneratedVisitor;
2318
2319 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2320 type Value = GeneratedField;
2321
2322 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2323 write!(formatter, "expected one of: {:?}", &FIELDS)
2324 }
2325
2326 #[allow(unused_variables)]
2327 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2328 where
2329 E: serde::de::Error,
2330 {
2331 match value {
2332 "host" => Ok(GeneratedField::Host),
2333 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2334 }
2335 }
2336 }
2337 deserializer.deserialize_identifier(GeneratedVisitor)
2338 }
2339 }
2340 struct GeneratedVisitor;
2341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2342 type Value = DeleteWorkerNodeRequest;
2343
2344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2345 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2346 }
2347
2348 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2349 where
2350 V: serde::de::MapAccess<'de>,
2351 {
2352 let mut host__ = None;
2353 while let Some(k) = map_.next_key()? {
2354 match k {
2355 GeneratedField::Host => {
2356 if host__.is_some() {
2357 return Err(serde::de::Error::duplicate_field("host"));
2358 }
2359 host__ = map_.next_value()?;
2360 }
2361 }
2362 }
2363 Ok(DeleteWorkerNodeRequest {
2364 host: host__,
2365 })
2366 }
2367 }
2368 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2369 }
2370}
2371impl serde::Serialize for DeleteWorkerNodeResponse {
2372 #[allow(deprecated)]
2373 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2374 where
2375 S: serde::Serializer,
2376 {
2377 use serde::ser::SerializeStruct;
2378 let mut len = 0;
2379 if self.status.is_some() {
2380 len += 1;
2381 }
2382 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2383 if let Some(v) = self.status.as_ref() {
2384 struct_ser.serialize_field("status", v)?;
2385 }
2386 struct_ser.end()
2387 }
2388}
2389impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2390 #[allow(deprecated)]
2391 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2392 where
2393 D: serde::Deserializer<'de>,
2394 {
2395 const FIELDS: &[&str] = &[
2396 "status",
2397 ];
2398
2399 #[allow(clippy::enum_variant_names)]
2400 enum GeneratedField {
2401 Status,
2402 }
2403 impl<'de> serde::Deserialize<'de> for GeneratedField {
2404 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2405 where
2406 D: serde::Deserializer<'de>,
2407 {
2408 struct GeneratedVisitor;
2409
2410 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2411 type Value = GeneratedField;
2412
2413 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2414 write!(formatter, "expected one of: {:?}", &FIELDS)
2415 }
2416
2417 #[allow(unused_variables)]
2418 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2419 where
2420 E: serde::de::Error,
2421 {
2422 match value {
2423 "status" => Ok(GeneratedField::Status),
2424 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2425 }
2426 }
2427 }
2428 deserializer.deserialize_identifier(GeneratedVisitor)
2429 }
2430 }
2431 struct GeneratedVisitor;
2432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2433 type Value = DeleteWorkerNodeResponse;
2434
2435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2436 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2437 }
2438
2439 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2440 where
2441 V: serde::de::MapAccess<'de>,
2442 {
2443 let mut status__ = None;
2444 while let Some(k) = map_.next_key()? {
2445 match k {
2446 GeneratedField::Status => {
2447 if status__.is_some() {
2448 return Err(serde::de::Error::duplicate_field("status"));
2449 }
2450 status__ = map_.next_value()?;
2451 }
2452 }
2453 }
2454 Ok(DeleteWorkerNodeResponse {
2455 status: status__,
2456 })
2457 }
2458 }
2459 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2460 }
2461}
2462impl serde::Serialize for EventLog {
2463 #[allow(deprecated)]
2464 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2465 where
2466 S: serde::Serializer,
2467 {
2468 use serde::ser::SerializeStruct;
2469 let mut len = 0;
2470 if self.unique_id.is_some() {
2471 len += 1;
2472 }
2473 if self.timestamp.is_some() {
2474 len += 1;
2475 }
2476 if self.event.is_some() {
2477 len += 1;
2478 }
2479 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2480 if let Some(v) = self.unique_id.as_ref() {
2481 struct_ser.serialize_field("uniqueId", v)?;
2482 }
2483 if let Some(v) = self.timestamp.as_ref() {
2484 #[allow(clippy::needless_borrow)]
2485 #[allow(clippy::needless_borrows_for_generic_args)]
2486 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2487 }
2488 if let Some(v) = self.event.as_ref() {
2489 match v {
2490 event_log::Event::CreateStreamJobFail(v) => {
2491 struct_ser.serialize_field("createStreamJobFail", v)?;
2492 }
2493 event_log::Event::DirtyStreamJobClear(v) => {
2494 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2495 }
2496 event_log::Event::MetaNodeStart(v) => {
2497 struct_ser.serialize_field("metaNodeStart", v)?;
2498 }
2499 event_log::Event::BarrierComplete(v) => {
2500 struct_ser.serialize_field("barrierComplete", v)?;
2501 }
2502 event_log::Event::InjectBarrierFail(v) => {
2503 struct_ser.serialize_field("injectBarrierFail", v)?;
2504 }
2505 event_log::Event::CollectBarrierFail(v) => {
2506 struct_ser.serialize_field("collectBarrierFail", v)?;
2507 }
2508 event_log::Event::WorkerNodePanic(v) => {
2509 struct_ser.serialize_field("workerNodePanic", v)?;
2510 }
2511 event_log::Event::AutoSchemaChangeFail(v) => {
2512 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2513 }
2514 event_log::Event::SinkFail(v) => {
2515 struct_ser.serialize_field("sinkFail", v)?;
2516 }
2517 event_log::Event::Recovery(v) => {
2518 struct_ser.serialize_field("recovery", v)?;
2519 }
2520 }
2521 }
2522 struct_ser.end()
2523 }
2524}
2525impl<'de> serde::Deserialize<'de> for EventLog {
2526 #[allow(deprecated)]
2527 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2528 where
2529 D: serde::Deserializer<'de>,
2530 {
2531 const FIELDS: &[&str] = &[
2532 "unique_id",
2533 "uniqueId",
2534 "timestamp",
2535 "create_stream_job_fail",
2536 "createStreamJobFail",
2537 "dirty_stream_job_clear",
2538 "dirtyStreamJobClear",
2539 "meta_node_start",
2540 "metaNodeStart",
2541 "barrier_complete",
2542 "barrierComplete",
2543 "inject_barrier_fail",
2544 "injectBarrierFail",
2545 "collect_barrier_fail",
2546 "collectBarrierFail",
2547 "worker_node_panic",
2548 "workerNodePanic",
2549 "auto_schema_change_fail",
2550 "autoSchemaChangeFail",
2551 "sink_fail",
2552 "sinkFail",
2553 "recovery",
2554 ];
2555
2556 #[allow(clippy::enum_variant_names)]
2557 enum GeneratedField {
2558 UniqueId,
2559 Timestamp,
2560 CreateStreamJobFail,
2561 DirtyStreamJobClear,
2562 MetaNodeStart,
2563 BarrierComplete,
2564 InjectBarrierFail,
2565 CollectBarrierFail,
2566 WorkerNodePanic,
2567 AutoSchemaChangeFail,
2568 SinkFail,
2569 Recovery,
2570 }
2571 impl<'de> serde::Deserialize<'de> for GeneratedField {
2572 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2573 where
2574 D: serde::Deserializer<'de>,
2575 {
2576 struct GeneratedVisitor;
2577
2578 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2579 type Value = GeneratedField;
2580
2581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2582 write!(formatter, "expected one of: {:?}", &FIELDS)
2583 }
2584
2585 #[allow(unused_variables)]
2586 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2587 where
2588 E: serde::de::Error,
2589 {
2590 match value {
2591 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2592 "timestamp" => Ok(GeneratedField::Timestamp),
2593 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2594 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2595 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2596 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2597 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2598 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2599 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2600 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
2601 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
2602 "recovery" => Ok(GeneratedField::Recovery),
2603 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2604 }
2605 }
2606 }
2607 deserializer.deserialize_identifier(GeneratedVisitor)
2608 }
2609 }
2610 struct GeneratedVisitor;
2611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2612 type Value = EventLog;
2613
2614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2615 formatter.write_str("struct meta.EventLog")
2616 }
2617
2618 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
2619 where
2620 V: serde::de::MapAccess<'de>,
2621 {
2622 let mut unique_id__ = None;
2623 let mut timestamp__ = None;
2624 let mut event__ = None;
2625 while let Some(k) = map_.next_key()? {
2626 match k {
2627 GeneratedField::UniqueId => {
2628 if unique_id__.is_some() {
2629 return Err(serde::de::Error::duplicate_field("uniqueId"));
2630 }
2631 unique_id__ = map_.next_value()?;
2632 }
2633 GeneratedField::Timestamp => {
2634 if timestamp__.is_some() {
2635 return Err(serde::de::Error::duplicate_field("timestamp"));
2636 }
2637 timestamp__ =
2638 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2639 ;
2640 }
2641 GeneratedField::CreateStreamJobFail => {
2642 if event__.is_some() {
2643 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
2644 }
2645 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
2646;
2647 }
2648 GeneratedField::DirtyStreamJobClear => {
2649 if event__.is_some() {
2650 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
2651 }
2652 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
2653;
2654 }
2655 GeneratedField::MetaNodeStart => {
2656 if event__.is_some() {
2657 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
2658 }
2659 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
2660;
2661 }
2662 GeneratedField::BarrierComplete => {
2663 if event__.is_some() {
2664 return Err(serde::de::Error::duplicate_field("barrierComplete"));
2665 }
2666 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
2667;
2668 }
2669 GeneratedField::InjectBarrierFail => {
2670 if event__.is_some() {
2671 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
2672 }
2673 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
2674;
2675 }
2676 GeneratedField::CollectBarrierFail => {
2677 if event__.is_some() {
2678 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
2679 }
2680 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
2681;
2682 }
2683 GeneratedField::WorkerNodePanic => {
2684 if event__.is_some() {
2685 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
2686 }
2687 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
2688;
2689 }
2690 GeneratedField::AutoSchemaChangeFail => {
2691 if event__.is_some() {
2692 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
2693 }
2694 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
2695;
2696 }
2697 GeneratedField::SinkFail => {
2698 if event__.is_some() {
2699 return Err(serde::de::Error::duplicate_field("sinkFail"));
2700 }
2701 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
2702;
2703 }
2704 GeneratedField::Recovery => {
2705 if event__.is_some() {
2706 return Err(serde::de::Error::duplicate_field("recovery"));
2707 }
2708 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
2709;
2710 }
2711 }
2712 }
2713 Ok(EventLog {
2714 unique_id: unique_id__,
2715 timestamp: timestamp__,
2716 event: event__,
2717 })
2718 }
2719 }
2720 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
2721 }
2722}
2723impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
2724 #[allow(deprecated)]
2725 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2726 where
2727 S: serde::Serializer,
2728 {
2729 use serde::ser::SerializeStruct;
2730 let mut len = 0;
2731 if self.table_id != 0 {
2732 len += 1;
2733 }
2734 if !self.table_name.is_empty() {
2735 len += 1;
2736 }
2737 if !self.cdc_table_id.is_empty() {
2738 len += 1;
2739 }
2740 if !self.upstream_ddl.is_empty() {
2741 len += 1;
2742 }
2743 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
2744 if self.table_id != 0 {
2745 struct_ser.serialize_field("tableId", &self.table_id)?;
2746 }
2747 if !self.table_name.is_empty() {
2748 struct_ser.serialize_field("tableName", &self.table_name)?;
2749 }
2750 if !self.cdc_table_id.is_empty() {
2751 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
2752 }
2753 if !self.upstream_ddl.is_empty() {
2754 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
2755 }
2756 struct_ser.end()
2757 }
2758}
2759impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
2760 #[allow(deprecated)]
2761 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2762 where
2763 D: serde::Deserializer<'de>,
2764 {
2765 const FIELDS: &[&str] = &[
2766 "table_id",
2767 "tableId",
2768 "table_name",
2769 "tableName",
2770 "cdc_table_id",
2771 "cdcTableId",
2772 "upstream_ddl",
2773 "upstreamDdl",
2774 ];
2775
2776 #[allow(clippy::enum_variant_names)]
2777 enum GeneratedField {
2778 TableId,
2779 TableName,
2780 CdcTableId,
2781 UpstreamDdl,
2782 }
2783 impl<'de> serde::Deserialize<'de> for GeneratedField {
2784 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2785 where
2786 D: serde::Deserializer<'de>,
2787 {
2788 struct GeneratedVisitor;
2789
2790 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2791 type Value = GeneratedField;
2792
2793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2794 write!(formatter, "expected one of: {:?}", &FIELDS)
2795 }
2796
2797 #[allow(unused_variables)]
2798 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2799 where
2800 E: serde::de::Error,
2801 {
2802 match value {
2803 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2804 "tableName" | "table_name" => Ok(GeneratedField::TableName),
2805 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
2806 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
2807 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2808 }
2809 }
2810 }
2811 deserializer.deserialize_identifier(GeneratedVisitor)
2812 }
2813 }
2814 struct GeneratedVisitor;
2815 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2816 type Value = event_log::EventAutoSchemaChangeFail;
2817
2818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2819 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
2820 }
2821
2822 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
2823 where
2824 V: serde::de::MapAccess<'de>,
2825 {
2826 let mut table_id__ = None;
2827 let mut table_name__ = None;
2828 let mut cdc_table_id__ = None;
2829 let mut upstream_ddl__ = None;
2830 while let Some(k) = map_.next_key()? {
2831 match k {
2832 GeneratedField::TableId => {
2833 if table_id__.is_some() {
2834 return Err(serde::de::Error::duplicate_field("tableId"));
2835 }
2836 table_id__ =
2837 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2838 ;
2839 }
2840 GeneratedField::TableName => {
2841 if table_name__.is_some() {
2842 return Err(serde::de::Error::duplicate_field("tableName"));
2843 }
2844 table_name__ = Some(map_.next_value()?);
2845 }
2846 GeneratedField::CdcTableId => {
2847 if cdc_table_id__.is_some() {
2848 return Err(serde::de::Error::duplicate_field("cdcTableId"));
2849 }
2850 cdc_table_id__ = Some(map_.next_value()?);
2851 }
2852 GeneratedField::UpstreamDdl => {
2853 if upstream_ddl__.is_some() {
2854 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
2855 }
2856 upstream_ddl__ = Some(map_.next_value()?);
2857 }
2858 }
2859 }
2860 Ok(event_log::EventAutoSchemaChangeFail {
2861 table_id: table_id__.unwrap_or_default(),
2862 table_name: table_name__.unwrap_or_default(),
2863 cdc_table_id: cdc_table_id__.unwrap_or_default(),
2864 upstream_ddl: upstream_ddl__.unwrap_or_default(),
2865 })
2866 }
2867 }
2868 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
2869 }
2870}
2871impl serde::Serialize for event_log::EventBarrierComplete {
2872 #[allow(deprecated)]
2873 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2874 where
2875 S: serde::Serializer,
2876 {
2877 use serde::ser::SerializeStruct;
2878 let mut len = 0;
2879 if self.prev_epoch != 0 {
2880 len += 1;
2881 }
2882 if self.cur_epoch != 0 {
2883 len += 1;
2884 }
2885 if self.duration_sec != 0. {
2886 len += 1;
2887 }
2888 if !self.command.is_empty() {
2889 len += 1;
2890 }
2891 if !self.barrier_kind.is_empty() {
2892 len += 1;
2893 }
2894 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
2895 if self.prev_epoch != 0 {
2896 #[allow(clippy::needless_borrow)]
2897 #[allow(clippy::needless_borrows_for_generic_args)]
2898 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
2899 }
2900 if self.cur_epoch != 0 {
2901 #[allow(clippy::needless_borrow)]
2902 #[allow(clippy::needless_borrows_for_generic_args)]
2903 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
2904 }
2905 if self.duration_sec != 0. {
2906 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
2907 }
2908 if !self.command.is_empty() {
2909 struct_ser.serialize_field("command", &self.command)?;
2910 }
2911 if !self.barrier_kind.is_empty() {
2912 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
2913 }
2914 struct_ser.end()
2915 }
2916}
2917impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
2918 #[allow(deprecated)]
2919 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2920 where
2921 D: serde::Deserializer<'de>,
2922 {
2923 const FIELDS: &[&str] = &[
2924 "prev_epoch",
2925 "prevEpoch",
2926 "cur_epoch",
2927 "curEpoch",
2928 "duration_sec",
2929 "durationSec",
2930 "command",
2931 "barrier_kind",
2932 "barrierKind",
2933 ];
2934
2935 #[allow(clippy::enum_variant_names)]
2936 enum GeneratedField {
2937 PrevEpoch,
2938 CurEpoch,
2939 DurationSec,
2940 Command,
2941 BarrierKind,
2942 }
2943 impl<'de> serde::Deserialize<'de> for GeneratedField {
2944 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2945 where
2946 D: serde::Deserializer<'de>,
2947 {
2948 struct GeneratedVisitor;
2949
2950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2951 type Value = GeneratedField;
2952
2953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2954 write!(formatter, "expected one of: {:?}", &FIELDS)
2955 }
2956
2957 #[allow(unused_variables)]
2958 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2959 where
2960 E: serde::de::Error,
2961 {
2962 match value {
2963 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
2964 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
2965 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
2966 "command" => Ok(GeneratedField::Command),
2967 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
2968 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2969 }
2970 }
2971 }
2972 deserializer.deserialize_identifier(GeneratedVisitor)
2973 }
2974 }
2975 struct GeneratedVisitor;
2976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2977 type Value = event_log::EventBarrierComplete;
2978
2979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2980 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
2981 }
2982
2983 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
2984 where
2985 V: serde::de::MapAccess<'de>,
2986 {
2987 let mut prev_epoch__ = None;
2988 let mut cur_epoch__ = None;
2989 let mut duration_sec__ = None;
2990 let mut command__ = None;
2991 let mut barrier_kind__ = None;
2992 while let Some(k) = map_.next_key()? {
2993 match k {
2994 GeneratedField::PrevEpoch => {
2995 if prev_epoch__.is_some() {
2996 return Err(serde::de::Error::duplicate_field("prevEpoch"));
2997 }
2998 prev_epoch__ =
2999 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3000 ;
3001 }
3002 GeneratedField::CurEpoch => {
3003 if cur_epoch__.is_some() {
3004 return Err(serde::de::Error::duplicate_field("curEpoch"));
3005 }
3006 cur_epoch__ =
3007 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3008 ;
3009 }
3010 GeneratedField::DurationSec => {
3011 if duration_sec__.is_some() {
3012 return Err(serde::de::Error::duplicate_field("durationSec"));
3013 }
3014 duration_sec__ =
3015 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3016 ;
3017 }
3018 GeneratedField::Command => {
3019 if command__.is_some() {
3020 return Err(serde::de::Error::duplicate_field("command"));
3021 }
3022 command__ = Some(map_.next_value()?);
3023 }
3024 GeneratedField::BarrierKind => {
3025 if barrier_kind__.is_some() {
3026 return Err(serde::de::Error::duplicate_field("barrierKind"));
3027 }
3028 barrier_kind__ = Some(map_.next_value()?);
3029 }
3030 }
3031 }
3032 Ok(event_log::EventBarrierComplete {
3033 prev_epoch: prev_epoch__.unwrap_or_default(),
3034 cur_epoch: cur_epoch__.unwrap_or_default(),
3035 duration_sec: duration_sec__.unwrap_or_default(),
3036 command: command__.unwrap_or_default(),
3037 barrier_kind: barrier_kind__.unwrap_or_default(),
3038 })
3039 }
3040 }
3041 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3042 }
3043}
3044impl serde::Serialize for event_log::EventCollectBarrierFail {
3045 #[allow(deprecated)]
3046 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3047 where
3048 S: serde::Serializer,
3049 {
3050 use serde::ser::SerializeStruct;
3051 let mut len = 0;
3052 if !self.error.is_empty() {
3053 len += 1;
3054 }
3055 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3056 if !self.error.is_empty() {
3057 struct_ser.serialize_field("error", &self.error)?;
3058 }
3059 struct_ser.end()
3060 }
3061}
3062impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3063 #[allow(deprecated)]
3064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3065 where
3066 D: serde::Deserializer<'de>,
3067 {
3068 const FIELDS: &[&str] = &[
3069 "error",
3070 ];
3071
3072 #[allow(clippy::enum_variant_names)]
3073 enum GeneratedField {
3074 Error,
3075 }
3076 impl<'de> serde::Deserialize<'de> for GeneratedField {
3077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3078 where
3079 D: serde::Deserializer<'de>,
3080 {
3081 struct GeneratedVisitor;
3082
3083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3084 type Value = GeneratedField;
3085
3086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3087 write!(formatter, "expected one of: {:?}", &FIELDS)
3088 }
3089
3090 #[allow(unused_variables)]
3091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3092 where
3093 E: serde::de::Error,
3094 {
3095 match value {
3096 "error" => Ok(GeneratedField::Error),
3097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3098 }
3099 }
3100 }
3101 deserializer.deserialize_identifier(GeneratedVisitor)
3102 }
3103 }
3104 struct GeneratedVisitor;
3105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3106 type Value = event_log::EventCollectBarrierFail;
3107
3108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3109 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3110 }
3111
3112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3113 where
3114 V: serde::de::MapAccess<'de>,
3115 {
3116 let mut error__ = None;
3117 while let Some(k) = map_.next_key()? {
3118 match k {
3119 GeneratedField::Error => {
3120 if error__.is_some() {
3121 return Err(serde::de::Error::duplicate_field("error"));
3122 }
3123 error__ = Some(map_.next_value()?);
3124 }
3125 }
3126 }
3127 Ok(event_log::EventCollectBarrierFail {
3128 error: error__.unwrap_or_default(),
3129 })
3130 }
3131 }
3132 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3133 }
3134}
3135impl serde::Serialize for event_log::EventCreateStreamJobFail {
3136 #[allow(deprecated)]
3137 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3138 where
3139 S: serde::Serializer,
3140 {
3141 use serde::ser::SerializeStruct;
3142 let mut len = 0;
3143 if self.id != 0 {
3144 len += 1;
3145 }
3146 if !self.name.is_empty() {
3147 len += 1;
3148 }
3149 if !self.definition.is_empty() {
3150 len += 1;
3151 }
3152 if !self.error.is_empty() {
3153 len += 1;
3154 }
3155 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3156 if self.id != 0 {
3157 struct_ser.serialize_field("id", &self.id)?;
3158 }
3159 if !self.name.is_empty() {
3160 struct_ser.serialize_field("name", &self.name)?;
3161 }
3162 if !self.definition.is_empty() {
3163 struct_ser.serialize_field("definition", &self.definition)?;
3164 }
3165 if !self.error.is_empty() {
3166 struct_ser.serialize_field("error", &self.error)?;
3167 }
3168 struct_ser.end()
3169 }
3170}
3171impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3172 #[allow(deprecated)]
3173 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3174 where
3175 D: serde::Deserializer<'de>,
3176 {
3177 const FIELDS: &[&str] = &[
3178 "id",
3179 "name",
3180 "definition",
3181 "error",
3182 ];
3183
3184 #[allow(clippy::enum_variant_names)]
3185 enum GeneratedField {
3186 Id,
3187 Name,
3188 Definition,
3189 Error,
3190 }
3191 impl<'de> serde::Deserialize<'de> for GeneratedField {
3192 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3193 where
3194 D: serde::Deserializer<'de>,
3195 {
3196 struct GeneratedVisitor;
3197
3198 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3199 type Value = GeneratedField;
3200
3201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3202 write!(formatter, "expected one of: {:?}", &FIELDS)
3203 }
3204
3205 #[allow(unused_variables)]
3206 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3207 where
3208 E: serde::de::Error,
3209 {
3210 match value {
3211 "id" => Ok(GeneratedField::Id),
3212 "name" => Ok(GeneratedField::Name),
3213 "definition" => Ok(GeneratedField::Definition),
3214 "error" => Ok(GeneratedField::Error),
3215 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3216 }
3217 }
3218 }
3219 deserializer.deserialize_identifier(GeneratedVisitor)
3220 }
3221 }
3222 struct GeneratedVisitor;
3223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3224 type Value = event_log::EventCreateStreamJobFail;
3225
3226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3227 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3228 }
3229
3230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3231 where
3232 V: serde::de::MapAccess<'de>,
3233 {
3234 let mut id__ = None;
3235 let mut name__ = None;
3236 let mut definition__ = None;
3237 let mut error__ = None;
3238 while let Some(k) = map_.next_key()? {
3239 match k {
3240 GeneratedField::Id => {
3241 if id__.is_some() {
3242 return Err(serde::de::Error::duplicate_field("id"));
3243 }
3244 id__ =
3245 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3246 ;
3247 }
3248 GeneratedField::Name => {
3249 if name__.is_some() {
3250 return Err(serde::de::Error::duplicate_field("name"));
3251 }
3252 name__ = Some(map_.next_value()?);
3253 }
3254 GeneratedField::Definition => {
3255 if definition__.is_some() {
3256 return Err(serde::de::Error::duplicate_field("definition"));
3257 }
3258 definition__ = Some(map_.next_value()?);
3259 }
3260 GeneratedField::Error => {
3261 if error__.is_some() {
3262 return Err(serde::de::Error::duplicate_field("error"));
3263 }
3264 error__ = Some(map_.next_value()?);
3265 }
3266 }
3267 }
3268 Ok(event_log::EventCreateStreamJobFail {
3269 id: id__.unwrap_or_default(),
3270 name: name__.unwrap_or_default(),
3271 definition: definition__.unwrap_or_default(),
3272 error: error__.unwrap_or_default(),
3273 })
3274 }
3275 }
3276 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3277 }
3278}
3279impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3280 #[allow(deprecated)]
3281 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3282 where
3283 S: serde::Serializer,
3284 {
3285 use serde::ser::SerializeStruct;
3286 let mut len = 0;
3287 if self.id != 0 {
3288 len += 1;
3289 }
3290 if !self.name.is_empty() {
3291 len += 1;
3292 }
3293 if !self.definition.is_empty() {
3294 len += 1;
3295 }
3296 if !self.error.is_empty() {
3297 len += 1;
3298 }
3299 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3300 if self.id != 0 {
3301 struct_ser.serialize_field("id", &self.id)?;
3302 }
3303 if !self.name.is_empty() {
3304 struct_ser.serialize_field("name", &self.name)?;
3305 }
3306 if !self.definition.is_empty() {
3307 struct_ser.serialize_field("definition", &self.definition)?;
3308 }
3309 if !self.error.is_empty() {
3310 struct_ser.serialize_field("error", &self.error)?;
3311 }
3312 struct_ser.end()
3313 }
3314}
3315impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3316 #[allow(deprecated)]
3317 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3318 where
3319 D: serde::Deserializer<'de>,
3320 {
3321 const FIELDS: &[&str] = &[
3322 "id",
3323 "name",
3324 "definition",
3325 "error",
3326 ];
3327
3328 #[allow(clippy::enum_variant_names)]
3329 enum GeneratedField {
3330 Id,
3331 Name,
3332 Definition,
3333 Error,
3334 }
3335 impl<'de> serde::Deserialize<'de> for GeneratedField {
3336 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3337 where
3338 D: serde::Deserializer<'de>,
3339 {
3340 struct GeneratedVisitor;
3341
3342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3343 type Value = GeneratedField;
3344
3345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3346 write!(formatter, "expected one of: {:?}", &FIELDS)
3347 }
3348
3349 #[allow(unused_variables)]
3350 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3351 where
3352 E: serde::de::Error,
3353 {
3354 match value {
3355 "id" => Ok(GeneratedField::Id),
3356 "name" => Ok(GeneratedField::Name),
3357 "definition" => Ok(GeneratedField::Definition),
3358 "error" => Ok(GeneratedField::Error),
3359 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3360 }
3361 }
3362 }
3363 deserializer.deserialize_identifier(GeneratedVisitor)
3364 }
3365 }
3366 struct GeneratedVisitor;
3367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3368 type Value = event_log::EventDirtyStreamJobClear;
3369
3370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3371 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3372 }
3373
3374 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3375 where
3376 V: serde::de::MapAccess<'de>,
3377 {
3378 let mut id__ = None;
3379 let mut name__ = None;
3380 let mut definition__ = None;
3381 let mut error__ = None;
3382 while let Some(k) = map_.next_key()? {
3383 match k {
3384 GeneratedField::Id => {
3385 if id__.is_some() {
3386 return Err(serde::de::Error::duplicate_field("id"));
3387 }
3388 id__ =
3389 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3390 ;
3391 }
3392 GeneratedField::Name => {
3393 if name__.is_some() {
3394 return Err(serde::de::Error::duplicate_field("name"));
3395 }
3396 name__ = Some(map_.next_value()?);
3397 }
3398 GeneratedField::Definition => {
3399 if definition__.is_some() {
3400 return Err(serde::de::Error::duplicate_field("definition"));
3401 }
3402 definition__ = Some(map_.next_value()?);
3403 }
3404 GeneratedField::Error => {
3405 if error__.is_some() {
3406 return Err(serde::de::Error::duplicate_field("error"));
3407 }
3408 error__ = Some(map_.next_value()?);
3409 }
3410 }
3411 }
3412 Ok(event_log::EventDirtyStreamJobClear {
3413 id: id__.unwrap_or_default(),
3414 name: name__.unwrap_or_default(),
3415 definition: definition__.unwrap_or_default(),
3416 error: error__.unwrap_or_default(),
3417 })
3418 }
3419 }
3420 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3421 }
3422}
3423impl serde::Serialize for event_log::EventInjectBarrierFail {
3424 #[allow(deprecated)]
3425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3426 where
3427 S: serde::Serializer,
3428 {
3429 use serde::ser::SerializeStruct;
3430 let mut len = 0;
3431 if self.prev_epoch != 0 {
3432 len += 1;
3433 }
3434 if self.cur_epoch != 0 {
3435 len += 1;
3436 }
3437 if !self.error.is_empty() {
3438 len += 1;
3439 }
3440 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3441 if self.prev_epoch != 0 {
3442 #[allow(clippy::needless_borrow)]
3443 #[allow(clippy::needless_borrows_for_generic_args)]
3444 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3445 }
3446 if self.cur_epoch != 0 {
3447 #[allow(clippy::needless_borrow)]
3448 #[allow(clippy::needless_borrows_for_generic_args)]
3449 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3450 }
3451 if !self.error.is_empty() {
3452 struct_ser.serialize_field("error", &self.error)?;
3453 }
3454 struct_ser.end()
3455 }
3456}
3457impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3458 #[allow(deprecated)]
3459 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3460 where
3461 D: serde::Deserializer<'de>,
3462 {
3463 const FIELDS: &[&str] = &[
3464 "prev_epoch",
3465 "prevEpoch",
3466 "cur_epoch",
3467 "curEpoch",
3468 "error",
3469 ];
3470
3471 #[allow(clippy::enum_variant_names)]
3472 enum GeneratedField {
3473 PrevEpoch,
3474 CurEpoch,
3475 Error,
3476 }
3477 impl<'de> serde::Deserialize<'de> for GeneratedField {
3478 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3479 where
3480 D: serde::Deserializer<'de>,
3481 {
3482 struct GeneratedVisitor;
3483
3484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3485 type Value = GeneratedField;
3486
3487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3488 write!(formatter, "expected one of: {:?}", &FIELDS)
3489 }
3490
3491 #[allow(unused_variables)]
3492 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3493 where
3494 E: serde::de::Error,
3495 {
3496 match value {
3497 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3498 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3499 "error" => Ok(GeneratedField::Error),
3500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3501 }
3502 }
3503 }
3504 deserializer.deserialize_identifier(GeneratedVisitor)
3505 }
3506 }
3507 struct GeneratedVisitor;
3508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3509 type Value = event_log::EventInjectBarrierFail;
3510
3511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3512 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3513 }
3514
3515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3516 where
3517 V: serde::de::MapAccess<'de>,
3518 {
3519 let mut prev_epoch__ = None;
3520 let mut cur_epoch__ = None;
3521 let mut error__ = None;
3522 while let Some(k) = map_.next_key()? {
3523 match k {
3524 GeneratedField::PrevEpoch => {
3525 if prev_epoch__.is_some() {
3526 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3527 }
3528 prev_epoch__ =
3529 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3530 ;
3531 }
3532 GeneratedField::CurEpoch => {
3533 if cur_epoch__.is_some() {
3534 return Err(serde::de::Error::duplicate_field("curEpoch"));
3535 }
3536 cur_epoch__ =
3537 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3538 ;
3539 }
3540 GeneratedField::Error => {
3541 if error__.is_some() {
3542 return Err(serde::de::Error::duplicate_field("error"));
3543 }
3544 error__ = Some(map_.next_value()?);
3545 }
3546 }
3547 }
3548 Ok(event_log::EventInjectBarrierFail {
3549 prev_epoch: prev_epoch__.unwrap_or_default(),
3550 cur_epoch: cur_epoch__.unwrap_or_default(),
3551 error: error__.unwrap_or_default(),
3552 })
3553 }
3554 }
3555 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3556 }
3557}
3558impl serde::Serialize for event_log::EventMetaNodeStart {
3559 #[allow(deprecated)]
3560 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3561 where
3562 S: serde::Serializer,
3563 {
3564 use serde::ser::SerializeStruct;
3565 let mut len = 0;
3566 if !self.advertise_addr.is_empty() {
3567 len += 1;
3568 }
3569 if !self.listen_addr.is_empty() {
3570 len += 1;
3571 }
3572 if !self.opts.is_empty() {
3573 len += 1;
3574 }
3575 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
3576 if !self.advertise_addr.is_empty() {
3577 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
3578 }
3579 if !self.listen_addr.is_empty() {
3580 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
3581 }
3582 if !self.opts.is_empty() {
3583 struct_ser.serialize_field("opts", &self.opts)?;
3584 }
3585 struct_ser.end()
3586 }
3587}
3588impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
3589 #[allow(deprecated)]
3590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3591 where
3592 D: serde::Deserializer<'de>,
3593 {
3594 const FIELDS: &[&str] = &[
3595 "advertise_addr",
3596 "advertiseAddr",
3597 "listen_addr",
3598 "listenAddr",
3599 "opts",
3600 ];
3601
3602 #[allow(clippy::enum_variant_names)]
3603 enum GeneratedField {
3604 AdvertiseAddr,
3605 ListenAddr,
3606 Opts,
3607 }
3608 impl<'de> serde::Deserialize<'de> for GeneratedField {
3609 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3610 where
3611 D: serde::Deserializer<'de>,
3612 {
3613 struct GeneratedVisitor;
3614
3615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3616 type Value = GeneratedField;
3617
3618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3619 write!(formatter, "expected one of: {:?}", &FIELDS)
3620 }
3621
3622 #[allow(unused_variables)]
3623 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3624 where
3625 E: serde::de::Error,
3626 {
3627 match value {
3628 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
3629 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
3630 "opts" => Ok(GeneratedField::Opts),
3631 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3632 }
3633 }
3634 }
3635 deserializer.deserialize_identifier(GeneratedVisitor)
3636 }
3637 }
3638 struct GeneratedVisitor;
3639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3640 type Value = event_log::EventMetaNodeStart;
3641
3642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3643 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
3644 }
3645
3646 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
3647 where
3648 V: serde::de::MapAccess<'de>,
3649 {
3650 let mut advertise_addr__ = None;
3651 let mut listen_addr__ = None;
3652 let mut opts__ = None;
3653 while let Some(k) = map_.next_key()? {
3654 match k {
3655 GeneratedField::AdvertiseAddr => {
3656 if advertise_addr__.is_some() {
3657 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
3658 }
3659 advertise_addr__ = Some(map_.next_value()?);
3660 }
3661 GeneratedField::ListenAddr => {
3662 if listen_addr__.is_some() {
3663 return Err(serde::de::Error::duplicate_field("listenAddr"));
3664 }
3665 listen_addr__ = Some(map_.next_value()?);
3666 }
3667 GeneratedField::Opts => {
3668 if opts__.is_some() {
3669 return Err(serde::de::Error::duplicate_field("opts"));
3670 }
3671 opts__ = Some(map_.next_value()?);
3672 }
3673 }
3674 }
3675 Ok(event_log::EventMetaNodeStart {
3676 advertise_addr: advertise_addr__.unwrap_or_default(),
3677 listen_addr: listen_addr__.unwrap_or_default(),
3678 opts: opts__.unwrap_or_default(),
3679 })
3680 }
3681 }
3682 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
3683 }
3684}
3685impl serde::Serialize for event_log::EventRecovery {
3686 #[allow(deprecated)]
3687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3688 where
3689 S: serde::Serializer,
3690 {
3691 use serde::ser::SerializeStruct;
3692 let mut len = 0;
3693 if self.recovery_event.is_some() {
3694 len += 1;
3695 }
3696 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
3697 if let Some(v) = self.recovery_event.as_ref() {
3698 match v {
3699 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
3700 struct_ser.serialize_field("globalStart", v)?;
3701 }
3702 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
3703 struct_ser.serialize_field("globalSuccess", v)?;
3704 }
3705 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
3706 struct_ser.serialize_field("globalFailure", v)?;
3707 }
3708 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
3709 struct_ser.serialize_field("databaseStart", v)?;
3710 }
3711 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
3712 struct_ser.serialize_field("databaseFailure", v)?;
3713 }
3714 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
3715 struct_ser.serialize_field("databaseSuccess", v)?;
3716 }
3717 }
3718 }
3719 struct_ser.end()
3720 }
3721}
3722impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
3723 #[allow(deprecated)]
3724 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3725 where
3726 D: serde::Deserializer<'de>,
3727 {
3728 const FIELDS: &[&str] = &[
3729 "global_start",
3730 "globalStart",
3731 "global_success",
3732 "globalSuccess",
3733 "global_failure",
3734 "globalFailure",
3735 "database_start",
3736 "databaseStart",
3737 "database_failure",
3738 "databaseFailure",
3739 "database_success",
3740 "databaseSuccess",
3741 ];
3742
3743 #[allow(clippy::enum_variant_names)]
3744 enum GeneratedField {
3745 GlobalStart,
3746 GlobalSuccess,
3747 GlobalFailure,
3748 DatabaseStart,
3749 DatabaseFailure,
3750 DatabaseSuccess,
3751 }
3752 impl<'de> serde::Deserialize<'de> for GeneratedField {
3753 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3754 where
3755 D: serde::Deserializer<'de>,
3756 {
3757 struct GeneratedVisitor;
3758
3759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3760 type Value = GeneratedField;
3761
3762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3763 write!(formatter, "expected one of: {:?}", &FIELDS)
3764 }
3765
3766 #[allow(unused_variables)]
3767 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3768 where
3769 E: serde::de::Error,
3770 {
3771 match value {
3772 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
3773 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
3774 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
3775 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
3776 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
3777 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
3778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3779 }
3780 }
3781 }
3782 deserializer.deserialize_identifier(GeneratedVisitor)
3783 }
3784 }
3785 struct GeneratedVisitor;
3786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3787 type Value = event_log::EventRecovery;
3788
3789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3790 formatter.write_str("struct meta.EventLog.EventRecovery")
3791 }
3792
3793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
3794 where
3795 V: serde::de::MapAccess<'de>,
3796 {
3797 let mut recovery_event__ = None;
3798 while let Some(k) = map_.next_key()? {
3799 match k {
3800 GeneratedField::GlobalStart => {
3801 if recovery_event__.is_some() {
3802 return Err(serde::de::Error::duplicate_field("globalStart"));
3803 }
3804 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
3805;
3806 }
3807 GeneratedField::GlobalSuccess => {
3808 if recovery_event__.is_some() {
3809 return Err(serde::de::Error::duplicate_field("globalSuccess"));
3810 }
3811 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
3812;
3813 }
3814 GeneratedField::GlobalFailure => {
3815 if recovery_event__.is_some() {
3816 return Err(serde::de::Error::duplicate_field("globalFailure"));
3817 }
3818 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
3819;
3820 }
3821 GeneratedField::DatabaseStart => {
3822 if recovery_event__.is_some() {
3823 return Err(serde::de::Error::duplicate_field("databaseStart"));
3824 }
3825 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
3826;
3827 }
3828 GeneratedField::DatabaseFailure => {
3829 if recovery_event__.is_some() {
3830 return Err(serde::de::Error::duplicate_field("databaseFailure"));
3831 }
3832 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
3833;
3834 }
3835 GeneratedField::DatabaseSuccess => {
3836 if recovery_event__.is_some() {
3837 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
3838 }
3839 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
3840;
3841 }
3842 }
3843 }
3844 Ok(event_log::EventRecovery {
3845 recovery_event: recovery_event__,
3846 })
3847 }
3848 }
3849 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
3850 }
3851}
3852impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
3853 #[allow(deprecated)]
3854 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3855 where
3856 S: serde::Serializer,
3857 {
3858 use serde::ser::SerializeStruct;
3859 let mut len = 0;
3860 if self.database_id != 0 {
3861 len += 1;
3862 }
3863 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
3864 if self.database_id != 0 {
3865 struct_ser.serialize_field("databaseId", &self.database_id)?;
3866 }
3867 struct_ser.end()
3868 }
3869}
3870impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
3871 #[allow(deprecated)]
3872 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3873 where
3874 D: serde::Deserializer<'de>,
3875 {
3876 const FIELDS: &[&str] = &[
3877 "database_id",
3878 "databaseId",
3879 ];
3880
3881 #[allow(clippy::enum_variant_names)]
3882 enum GeneratedField {
3883 DatabaseId,
3884 }
3885 impl<'de> serde::Deserialize<'de> for GeneratedField {
3886 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3887 where
3888 D: serde::Deserializer<'de>,
3889 {
3890 struct GeneratedVisitor;
3891
3892 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3893 type Value = GeneratedField;
3894
3895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3896 write!(formatter, "expected one of: {:?}", &FIELDS)
3897 }
3898
3899 #[allow(unused_variables)]
3900 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3901 where
3902 E: serde::de::Error,
3903 {
3904 match value {
3905 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3906 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3907 }
3908 }
3909 }
3910 deserializer.deserialize_identifier(GeneratedVisitor)
3911 }
3912 }
3913 struct GeneratedVisitor;
3914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3915 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
3916
3917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3918 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
3919 }
3920
3921 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
3922 where
3923 V: serde::de::MapAccess<'de>,
3924 {
3925 let mut database_id__ = None;
3926 while let Some(k) = map_.next_key()? {
3927 match k {
3928 GeneratedField::DatabaseId => {
3929 if database_id__.is_some() {
3930 return Err(serde::de::Error::duplicate_field("databaseId"));
3931 }
3932 database_id__ =
3933 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3934 ;
3935 }
3936 }
3937 }
3938 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
3939 database_id: database_id__.unwrap_or_default(),
3940 })
3941 }
3942 }
3943 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
3944 }
3945}
3946impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
3947 #[allow(deprecated)]
3948 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3949 where
3950 S: serde::Serializer,
3951 {
3952 use serde::ser::SerializeStruct;
3953 let mut len = 0;
3954 if self.database_id != 0 {
3955 len += 1;
3956 }
3957 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
3958 if self.database_id != 0 {
3959 struct_ser.serialize_field("databaseId", &self.database_id)?;
3960 }
3961 struct_ser.end()
3962 }
3963}
3964impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
3965 #[allow(deprecated)]
3966 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3967 where
3968 D: serde::Deserializer<'de>,
3969 {
3970 const FIELDS: &[&str] = &[
3971 "database_id",
3972 "databaseId",
3973 ];
3974
3975 #[allow(clippy::enum_variant_names)]
3976 enum GeneratedField {
3977 DatabaseId,
3978 }
3979 impl<'de> serde::Deserialize<'de> for GeneratedField {
3980 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3981 where
3982 D: serde::Deserializer<'de>,
3983 {
3984 struct GeneratedVisitor;
3985
3986 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3987 type Value = GeneratedField;
3988
3989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3990 write!(formatter, "expected one of: {:?}", &FIELDS)
3991 }
3992
3993 #[allow(unused_variables)]
3994 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3995 where
3996 E: serde::de::Error,
3997 {
3998 match value {
3999 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4000 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4001 }
4002 }
4003 }
4004 deserializer.deserialize_identifier(GeneratedVisitor)
4005 }
4006 }
4007 struct GeneratedVisitor;
4008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4009 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4010
4011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4012 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4013 }
4014
4015 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4016 where
4017 V: serde::de::MapAccess<'de>,
4018 {
4019 let mut database_id__ = None;
4020 while let Some(k) = map_.next_key()? {
4021 match k {
4022 GeneratedField::DatabaseId => {
4023 if database_id__.is_some() {
4024 return Err(serde::de::Error::duplicate_field("databaseId"));
4025 }
4026 database_id__ =
4027 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4028 ;
4029 }
4030 }
4031 }
4032 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4033 database_id: database_id__.unwrap_or_default(),
4034 })
4035 }
4036 }
4037 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4038 }
4039}
4040impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4041 #[allow(deprecated)]
4042 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4043 where
4044 S: serde::Serializer,
4045 {
4046 use serde::ser::SerializeStruct;
4047 let mut len = 0;
4048 if self.database_id != 0 {
4049 len += 1;
4050 }
4051 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4052 if self.database_id != 0 {
4053 struct_ser.serialize_field("databaseId", &self.database_id)?;
4054 }
4055 struct_ser.end()
4056 }
4057}
4058impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4059 #[allow(deprecated)]
4060 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4061 where
4062 D: serde::Deserializer<'de>,
4063 {
4064 const FIELDS: &[&str] = &[
4065 "database_id",
4066 "databaseId",
4067 ];
4068
4069 #[allow(clippy::enum_variant_names)]
4070 enum GeneratedField {
4071 DatabaseId,
4072 }
4073 impl<'de> serde::Deserialize<'de> for GeneratedField {
4074 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4075 where
4076 D: serde::Deserializer<'de>,
4077 {
4078 struct GeneratedVisitor;
4079
4080 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4081 type Value = GeneratedField;
4082
4083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4084 write!(formatter, "expected one of: {:?}", &FIELDS)
4085 }
4086
4087 #[allow(unused_variables)]
4088 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4089 where
4090 E: serde::de::Error,
4091 {
4092 match value {
4093 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4094 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4095 }
4096 }
4097 }
4098 deserializer.deserialize_identifier(GeneratedVisitor)
4099 }
4100 }
4101 struct GeneratedVisitor;
4102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4103 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4104
4105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4106 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4107 }
4108
4109 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4110 where
4111 V: serde::de::MapAccess<'de>,
4112 {
4113 let mut database_id__ = None;
4114 while let Some(k) = map_.next_key()? {
4115 match k {
4116 GeneratedField::DatabaseId => {
4117 if database_id__.is_some() {
4118 return Err(serde::de::Error::duplicate_field("databaseId"));
4119 }
4120 database_id__ =
4121 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4122 ;
4123 }
4124 }
4125 }
4126 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4127 database_id: database_id__.unwrap_or_default(),
4128 })
4129 }
4130 }
4131 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4132 }
4133}
4134impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4135 #[allow(deprecated)]
4136 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4137 where
4138 S: serde::Serializer,
4139 {
4140 use serde::ser::SerializeStruct;
4141 let mut len = 0;
4142 if !self.reason.is_empty() {
4143 len += 1;
4144 }
4145 if !self.error.is_empty() {
4146 len += 1;
4147 }
4148 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4149 if !self.reason.is_empty() {
4150 struct_ser.serialize_field("reason", &self.reason)?;
4151 }
4152 if !self.error.is_empty() {
4153 struct_ser.serialize_field("error", &self.error)?;
4154 }
4155 struct_ser.end()
4156 }
4157}
4158impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4159 #[allow(deprecated)]
4160 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4161 where
4162 D: serde::Deserializer<'de>,
4163 {
4164 const FIELDS: &[&str] = &[
4165 "reason",
4166 "error",
4167 ];
4168
4169 #[allow(clippy::enum_variant_names)]
4170 enum GeneratedField {
4171 Reason,
4172 Error,
4173 }
4174 impl<'de> serde::Deserialize<'de> for GeneratedField {
4175 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4176 where
4177 D: serde::Deserializer<'de>,
4178 {
4179 struct GeneratedVisitor;
4180
4181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4182 type Value = GeneratedField;
4183
4184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4185 write!(formatter, "expected one of: {:?}", &FIELDS)
4186 }
4187
4188 #[allow(unused_variables)]
4189 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4190 where
4191 E: serde::de::Error,
4192 {
4193 match value {
4194 "reason" => Ok(GeneratedField::Reason),
4195 "error" => Ok(GeneratedField::Error),
4196 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4197 }
4198 }
4199 }
4200 deserializer.deserialize_identifier(GeneratedVisitor)
4201 }
4202 }
4203 struct GeneratedVisitor;
4204 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4205 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4206
4207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4208 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4209 }
4210
4211 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4212 where
4213 V: serde::de::MapAccess<'de>,
4214 {
4215 let mut reason__ = None;
4216 let mut error__ = None;
4217 while let Some(k) = map_.next_key()? {
4218 match k {
4219 GeneratedField::Reason => {
4220 if reason__.is_some() {
4221 return Err(serde::de::Error::duplicate_field("reason"));
4222 }
4223 reason__ = Some(map_.next_value()?);
4224 }
4225 GeneratedField::Error => {
4226 if error__.is_some() {
4227 return Err(serde::de::Error::duplicate_field("error"));
4228 }
4229 error__ = Some(map_.next_value()?);
4230 }
4231 }
4232 }
4233 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4234 reason: reason__.unwrap_or_default(),
4235 error: error__.unwrap_or_default(),
4236 })
4237 }
4238 }
4239 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4240 }
4241}
4242impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4243 #[allow(deprecated)]
4244 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4245 where
4246 S: serde::Serializer,
4247 {
4248 use serde::ser::SerializeStruct;
4249 let mut len = 0;
4250 if !self.reason.is_empty() {
4251 len += 1;
4252 }
4253 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4254 if !self.reason.is_empty() {
4255 struct_ser.serialize_field("reason", &self.reason)?;
4256 }
4257 struct_ser.end()
4258 }
4259}
4260impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4261 #[allow(deprecated)]
4262 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4263 where
4264 D: serde::Deserializer<'de>,
4265 {
4266 const FIELDS: &[&str] = &[
4267 "reason",
4268 ];
4269
4270 #[allow(clippy::enum_variant_names)]
4271 enum GeneratedField {
4272 Reason,
4273 }
4274 impl<'de> serde::Deserialize<'de> for GeneratedField {
4275 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4276 where
4277 D: serde::Deserializer<'de>,
4278 {
4279 struct GeneratedVisitor;
4280
4281 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4282 type Value = GeneratedField;
4283
4284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4285 write!(formatter, "expected one of: {:?}", &FIELDS)
4286 }
4287
4288 #[allow(unused_variables)]
4289 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4290 where
4291 E: serde::de::Error,
4292 {
4293 match value {
4294 "reason" => Ok(GeneratedField::Reason),
4295 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4296 }
4297 }
4298 }
4299 deserializer.deserialize_identifier(GeneratedVisitor)
4300 }
4301 }
4302 struct GeneratedVisitor;
4303 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4304 type Value = event_log::event_recovery::GlobalRecoveryStart;
4305
4306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4307 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4308 }
4309
4310 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4311 where
4312 V: serde::de::MapAccess<'de>,
4313 {
4314 let mut reason__ = None;
4315 while let Some(k) = map_.next_key()? {
4316 match k {
4317 GeneratedField::Reason => {
4318 if reason__.is_some() {
4319 return Err(serde::de::Error::duplicate_field("reason"));
4320 }
4321 reason__ = Some(map_.next_value()?);
4322 }
4323 }
4324 }
4325 Ok(event_log::event_recovery::GlobalRecoveryStart {
4326 reason: reason__.unwrap_or_default(),
4327 })
4328 }
4329 }
4330 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4331 }
4332}
4333impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4334 #[allow(deprecated)]
4335 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4336 where
4337 S: serde::Serializer,
4338 {
4339 use serde::ser::SerializeStruct;
4340 let mut len = 0;
4341 if !self.reason.is_empty() {
4342 len += 1;
4343 }
4344 if self.duration_secs != 0. {
4345 len += 1;
4346 }
4347 if !self.running_database_ids.is_empty() {
4348 len += 1;
4349 }
4350 if !self.recovering_database_ids.is_empty() {
4351 len += 1;
4352 }
4353 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4354 if !self.reason.is_empty() {
4355 struct_ser.serialize_field("reason", &self.reason)?;
4356 }
4357 if self.duration_secs != 0. {
4358 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4359 }
4360 if !self.running_database_ids.is_empty() {
4361 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4362 }
4363 if !self.recovering_database_ids.is_empty() {
4364 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4365 }
4366 struct_ser.end()
4367 }
4368}
4369impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4370 #[allow(deprecated)]
4371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4372 where
4373 D: serde::Deserializer<'de>,
4374 {
4375 const FIELDS: &[&str] = &[
4376 "reason",
4377 "duration_secs",
4378 "durationSecs",
4379 "running_database_ids",
4380 "runningDatabaseIds",
4381 "recovering_database_ids",
4382 "recoveringDatabaseIds",
4383 ];
4384
4385 #[allow(clippy::enum_variant_names)]
4386 enum GeneratedField {
4387 Reason,
4388 DurationSecs,
4389 RunningDatabaseIds,
4390 RecoveringDatabaseIds,
4391 }
4392 impl<'de> serde::Deserialize<'de> for GeneratedField {
4393 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4394 where
4395 D: serde::Deserializer<'de>,
4396 {
4397 struct GeneratedVisitor;
4398
4399 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4400 type Value = GeneratedField;
4401
4402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4403 write!(formatter, "expected one of: {:?}", &FIELDS)
4404 }
4405
4406 #[allow(unused_variables)]
4407 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4408 where
4409 E: serde::de::Error,
4410 {
4411 match value {
4412 "reason" => Ok(GeneratedField::Reason),
4413 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4414 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4415 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4416 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4417 }
4418 }
4419 }
4420 deserializer.deserialize_identifier(GeneratedVisitor)
4421 }
4422 }
4423 struct GeneratedVisitor;
4424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4425 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4426
4427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4428 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4429 }
4430
4431 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4432 where
4433 V: serde::de::MapAccess<'de>,
4434 {
4435 let mut reason__ = None;
4436 let mut duration_secs__ = None;
4437 let mut running_database_ids__ = None;
4438 let mut recovering_database_ids__ = None;
4439 while let Some(k) = map_.next_key()? {
4440 match k {
4441 GeneratedField::Reason => {
4442 if reason__.is_some() {
4443 return Err(serde::de::Error::duplicate_field("reason"));
4444 }
4445 reason__ = Some(map_.next_value()?);
4446 }
4447 GeneratedField::DurationSecs => {
4448 if duration_secs__.is_some() {
4449 return Err(serde::de::Error::duplicate_field("durationSecs"));
4450 }
4451 duration_secs__ =
4452 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4453 ;
4454 }
4455 GeneratedField::RunningDatabaseIds => {
4456 if running_database_ids__.is_some() {
4457 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4458 }
4459 running_database_ids__ =
4460 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4461 .into_iter().map(|x| x.0).collect())
4462 ;
4463 }
4464 GeneratedField::RecoveringDatabaseIds => {
4465 if recovering_database_ids__.is_some() {
4466 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4467 }
4468 recovering_database_ids__ =
4469 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4470 .into_iter().map(|x| x.0).collect())
4471 ;
4472 }
4473 }
4474 }
4475 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4476 reason: reason__.unwrap_or_default(),
4477 duration_secs: duration_secs__.unwrap_or_default(),
4478 running_database_ids: running_database_ids__.unwrap_or_default(),
4479 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4480 })
4481 }
4482 }
4483 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4484 }
4485}
4486impl serde::Serialize for event_log::EventSinkFail {
4487 #[allow(deprecated)]
4488 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4489 where
4490 S: serde::Serializer,
4491 {
4492 use serde::ser::SerializeStruct;
4493 let mut len = 0;
4494 if self.sink_id != 0 {
4495 len += 1;
4496 }
4497 if !self.sink_name.is_empty() {
4498 len += 1;
4499 }
4500 if !self.connector.is_empty() {
4501 len += 1;
4502 }
4503 if !self.error.is_empty() {
4504 len += 1;
4505 }
4506 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4507 if self.sink_id != 0 {
4508 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4509 }
4510 if !self.sink_name.is_empty() {
4511 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4512 }
4513 if !self.connector.is_empty() {
4514 struct_ser.serialize_field("connector", &self.connector)?;
4515 }
4516 if !self.error.is_empty() {
4517 struct_ser.serialize_field("error", &self.error)?;
4518 }
4519 struct_ser.end()
4520 }
4521}
4522impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4523 #[allow(deprecated)]
4524 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4525 where
4526 D: serde::Deserializer<'de>,
4527 {
4528 const FIELDS: &[&str] = &[
4529 "sink_id",
4530 "sinkId",
4531 "sink_name",
4532 "sinkName",
4533 "connector",
4534 "error",
4535 ];
4536
4537 #[allow(clippy::enum_variant_names)]
4538 enum GeneratedField {
4539 SinkId,
4540 SinkName,
4541 Connector,
4542 Error,
4543 }
4544 impl<'de> serde::Deserialize<'de> for GeneratedField {
4545 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4546 where
4547 D: serde::Deserializer<'de>,
4548 {
4549 struct GeneratedVisitor;
4550
4551 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4552 type Value = GeneratedField;
4553
4554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4555 write!(formatter, "expected one of: {:?}", &FIELDS)
4556 }
4557
4558 #[allow(unused_variables)]
4559 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4560 where
4561 E: serde::de::Error,
4562 {
4563 match value {
4564 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4565 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
4566 "connector" => Ok(GeneratedField::Connector),
4567 "error" => Ok(GeneratedField::Error),
4568 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4569 }
4570 }
4571 }
4572 deserializer.deserialize_identifier(GeneratedVisitor)
4573 }
4574 }
4575 struct GeneratedVisitor;
4576 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4577 type Value = event_log::EventSinkFail;
4578
4579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4580 formatter.write_str("struct meta.EventLog.EventSinkFail")
4581 }
4582
4583 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
4584 where
4585 V: serde::de::MapAccess<'de>,
4586 {
4587 let mut sink_id__ = None;
4588 let mut sink_name__ = None;
4589 let mut connector__ = None;
4590 let mut error__ = None;
4591 while let Some(k) = map_.next_key()? {
4592 match k {
4593 GeneratedField::SinkId => {
4594 if sink_id__.is_some() {
4595 return Err(serde::de::Error::duplicate_field("sinkId"));
4596 }
4597 sink_id__ =
4598 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4599 ;
4600 }
4601 GeneratedField::SinkName => {
4602 if sink_name__.is_some() {
4603 return Err(serde::de::Error::duplicate_field("sinkName"));
4604 }
4605 sink_name__ = Some(map_.next_value()?);
4606 }
4607 GeneratedField::Connector => {
4608 if connector__.is_some() {
4609 return Err(serde::de::Error::duplicate_field("connector"));
4610 }
4611 connector__ = Some(map_.next_value()?);
4612 }
4613 GeneratedField::Error => {
4614 if error__.is_some() {
4615 return Err(serde::de::Error::duplicate_field("error"));
4616 }
4617 error__ = Some(map_.next_value()?);
4618 }
4619 }
4620 }
4621 Ok(event_log::EventSinkFail {
4622 sink_id: sink_id__.unwrap_or_default(),
4623 sink_name: sink_name__.unwrap_or_default(),
4624 connector: connector__.unwrap_or_default(),
4625 error: error__.unwrap_or_default(),
4626 })
4627 }
4628 }
4629 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
4630 }
4631}
4632impl serde::Serialize for event_log::EventWorkerNodePanic {
4633 #[allow(deprecated)]
4634 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4635 where
4636 S: serde::Serializer,
4637 {
4638 use serde::ser::SerializeStruct;
4639 let mut len = 0;
4640 if self.worker_id != 0 {
4641 len += 1;
4642 }
4643 if self.worker_type != 0 {
4644 len += 1;
4645 }
4646 if self.host_addr.is_some() {
4647 len += 1;
4648 }
4649 if !self.panic_info.is_empty() {
4650 len += 1;
4651 }
4652 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
4653 if self.worker_id != 0 {
4654 struct_ser.serialize_field("workerId", &self.worker_id)?;
4655 }
4656 if self.worker_type != 0 {
4657 let v = super::common::WorkerType::try_from(self.worker_type)
4658 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
4659 struct_ser.serialize_field("workerType", &v)?;
4660 }
4661 if let Some(v) = self.host_addr.as_ref() {
4662 struct_ser.serialize_field("hostAddr", v)?;
4663 }
4664 if !self.panic_info.is_empty() {
4665 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
4666 }
4667 struct_ser.end()
4668 }
4669}
4670impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
4671 #[allow(deprecated)]
4672 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4673 where
4674 D: serde::Deserializer<'de>,
4675 {
4676 const FIELDS: &[&str] = &[
4677 "worker_id",
4678 "workerId",
4679 "worker_type",
4680 "workerType",
4681 "host_addr",
4682 "hostAddr",
4683 "panic_info",
4684 "panicInfo",
4685 ];
4686
4687 #[allow(clippy::enum_variant_names)]
4688 enum GeneratedField {
4689 WorkerId,
4690 WorkerType,
4691 HostAddr,
4692 PanicInfo,
4693 }
4694 impl<'de> serde::Deserialize<'de> for GeneratedField {
4695 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4696 where
4697 D: serde::Deserializer<'de>,
4698 {
4699 struct GeneratedVisitor;
4700
4701 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4702 type Value = GeneratedField;
4703
4704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4705 write!(formatter, "expected one of: {:?}", &FIELDS)
4706 }
4707
4708 #[allow(unused_variables)]
4709 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4710 where
4711 E: serde::de::Error,
4712 {
4713 match value {
4714 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
4715 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
4716 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
4717 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
4718 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4719 }
4720 }
4721 }
4722 deserializer.deserialize_identifier(GeneratedVisitor)
4723 }
4724 }
4725 struct GeneratedVisitor;
4726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4727 type Value = event_log::EventWorkerNodePanic;
4728
4729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4730 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
4731 }
4732
4733 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
4734 where
4735 V: serde::de::MapAccess<'de>,
4736 {
4737 let mut worker_id__ = None;
4738 let mut worker_type__ = None;
4739 let mut host_addr__ = None;
4740 let mut panic_info__ = None;
4741 while let Some(k) = map_.next_key()? {
4742 match k {
4743 GeneratedField::WorkerId => {
4744 if worker_id__.is_some() {
4745 return Err(serde::de::Error::duplicate_field("workerId"));
4746 }
4747 worker_id__ =
4748 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4749 ;
4750 }
4751 GeneratedField::WorkerType => {
4752 if worker_type__.is_some() {
4753 return Err(serde::de::Error::duplicate_field("workerType"));
4754 }
4755 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
4756 }
4757 GeneratedField::HostAddr => {
4758 if host_addr__.is_some() {
4759 return Err(serde::de::Error::duplicate_field("hostAddr"));
4760 }
4761 host_addr__ = map_.next_value()?;
4762 }
4763 GeneratedField::PanicInfo => {
4764 if panic_info__.is_some() {
4765 return Err(serde::de::Error::duplicate_field("panicInfo"));
4766 }
4767 panic_info__ = Some(map_.next_value()?);
4768 }
4769 }
4770 }
4771 Ok(event_log::EventWorkerNodePanic {
4772 worker_id: worker_id__.unwrap_or_default(),
4773 worker_type: worker_type__.unwrap_or_default(),
4774 host_addr: host_addr__,
4775 panic_info: panic_info__.unwrap_or_default(),
4776 })
4777 }
4778 }
4779 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
4780 }
4781}
4782impl serde::Serialize for FlushRequest {
4783 #[allow(deprecated)]
4784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4785 where
4786 S: serde::Serializer,
4787 {
4788 use serde::ser::SerializeStruct;
4789 let mut len = 0;
4790 if self.database_id != 0 {
4791 len += 1;
4792 }
4793 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
4794 if self.database_id != 0 {
4795 struct_ser.serialize_field("databaseId", &self.database_id)?;
4796 }
4797 struct_ser.end()
4798 }
4799}
4800impl<'de> serde::Deserialize<'de> for FlushRequest {
4801 #[allow(deprecated)]
4802 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4803 where
4804 D: serde::Deserializer<'de>,
4805 {
4806 const FIELDS: &[&str] = &[
4807 "database_id",
4808 "databaseId",
4809 ];
4810
4811 #[allow(clippy::enum_variant_names)]
4812 enum GeneratedField {
4813 DatabaseId,
4814 }
4815 impl<'de> serde::Deserialize<'de> for GeneratedField {
4816 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4817 where
4818 D: serde::Deserializer<'de>,
4819 {
4820 struct GeneratedVisitor;
4821
4822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4823 type Value = GeneratedField;
4824
4825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4826 write!(formatter, "expected one of: {:?}", &FIELDS)
4827 }
4828
4829 #[allow(unused_variables)]
4830 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4831 where
4832 E: serde::de::Error,
4833 {
4834 match value {
4835 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4836 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4837 }
4838 }
4839 }
4840 deserializer.deserialize_identifier(GeneratedVisitor)
4841 }
4842 }
4843 struct GeneratedVisitor;
4844 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4845 type Value = FlushRequest;
4846
4847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4848 formatter.write_str("struct meta.FlushRequest")
4849 }
4850
4851 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
4852 where
4853 V: serde::de::MapAccess<'de>,
4854 {
4855 let mut database_id__ = None;
4856 while let Some(k) = map_.next_key()? {
4857 match k {
4858 GeneratedField::DatabaseId => {
4859 if database_id__.is_some() {
4860 return Err(serde::de::Error::duplicate_field("databaseId"));
4861 }
4862 database_id__ =
4863 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4864 ;
4865 }
4866 }
4867 }
4868 Ok(FlushRequest {
4869 database_id: database_id__.unwrap_or_default(),
4870 })
4871 }
4872 }
4873 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
4874 }
4875}
4876impl serde::Serialize for FlushResponse {
4877 #[allow(deprecated)]
4878 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4879 where
4880 S: serde::Serializer,
4881 {
4882 use serde::ser::SerializeStruct;
4883 let mut len = 0;
4884 if self.status.is_some() {
4885 len += 1;
4886 }
4887 if self.hummock_version_id != 0 {
4888 len += 1;
4889 }
4890 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
4891 if let Some(v) = self.status.as_ref() {
4892 struct_ser.serialize_field("status", v)?;
4893 }
4894 if self.hummock_version_id != 0 {
4895 #[allow(clippy::needless_borrow)]
4896 #[allow(clippy::needless_borrows_for_generic_args)]
4897 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
4898 }
4899 struct_ser.end()
4900 }
4901}
4902impl<'de> serde::Deserialize<'de> for FlushResponse {
4903 #[allow(deprecated)]
4904 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4905 where
4906 D: serde::Deserializer<'de>,
4907 {
4908 const FIELDS: &[&str] = &[
4909 "status",
4910 "hummock_version_id",
4911 "hummockVersionId",
4912 ];
4913
4914 #[allow(clippy::enum_variant_names)]
4915 enum GeneratedField {
4916 Status,
4917 HummockVersionId,
4918 }
4919 impl<'de> serde::Deserialize<'de> for GeneratedField {
4920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4921 where
4922 D: serde::Deserializer<'de>,
4923 {
4924 struct GeneratedVisitor;
4925
4926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4927 type Value = GeneratedField;
4928
4929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4930 write!(formatter, "expected one of: {:?}", &FIELDS)
4931 }
4932
4933 #[allow(unused_variables)]
4934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4935 where
4936 E: serde::de::Error,
4937 {
4938 match value {
4939 "status" => Ok(GeneratedField::Status),
4940 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
4941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4942 }
4943 }
4944 }
4945 deserializer.deserialize_identifier(GeneratedVisitor)
4946 }
4947 }
4948 struct GeneratedVisitor;
4949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4950 type Value = FlushResponse;
4951
4952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4953 formatter.write_str("struct meta.FlushResponse")
4954 }
4955
4956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
4957 where
4958 V: serde::de::MapAccess<'de>,
4959 {
4960 let mut status__ = None;
4961 let mut hummock_version_id__ = None;
4962 while let Some(k) = map_.next_key()? {
4963 match k {
4964 GeneratedField::Status => {
4965 if status__.is_some() {
4966 return Err(serde::de::Error::duplicate_field("status"));
4967 }
4968 status__ = map_.next_value()?;
4969 }
4970 GeneratedField::HummockVersionId => {
4971 if hummock_version_id__.is_some() {
4972 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
4973 }
4974 hummock_version_id__ =
4975 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4976 ;
4977 }
4978 }
4979 }
4980 Ok(FlushResponse {
4981 status: status__,
4982 hummock_version_id: hummock_version_id__.unwrap_or_default(),
4983 })
4984 }
4985 }
4986 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
4987 }
4988}
4989impl serde::Serialize for FragmentDistribution {
4990 #[allow(deprecated)]
4991 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4992 where
4993 S: serde::Serializer,
4994 {
4995 use serde::ser::SerializeStruct;
4996 let mut len = 0;
4997 if self.fragment_id != 0 {
4998 len += 1;
4999 }
5000 if self.table_id != 0 {
5001 len += 1;
5002 }
5003 if self.distribution_type != 0 {
5004 len += 1;
5005 }
5006 if !self.state_table_ids.is_empty() {
5007 len += 1;
5008 }
5009 if !self.upstream_fragment_ids.is_empty() {
5010 len += 1;
5011 }
5012 if self.fragment_type_mask != 0 {
5013 len += 1;
5014 }
5015 if self.parallelism != 0 {
5016 len += 1;
5017 }
5018 if self.vnode_count != 0 {
5019 len += 1;
5020 }
5021 if self.node.is_some() {
5022 len += 1;
5023 }
5024 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5025 if self.fragment_id != 0 {
5026 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5027 }
5028 if self.table_id != 0 {
5029 struct_ser.serialize_field("tableId", &self.table_id)?;
5030 }
5031 if self.distribution_type != 0 {
5032 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5033 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5034 struct_ser.serialize_field("distributionType", &v)?;
5035 }
5036 if !self.state_table_ids.is_empty() {
5037 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5038 }
5039 if !self.upstream_fragment_ids.is_empty() {
5040 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5041 }
5042 if self.fragment_type_mask != 0 {
5043 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5044 }
5045 if self.parallelism != 0 {
5046 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5047 }
5048 if self.vnode_count != 0 {
5049 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5050 }
5051 if let Some(v) = self.node.as_ref() {
5052 struct_ser.serialize_field("node", v)?;
5053 }
5054 struct_ser.end()
5055 }
5056}
5057impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5058 #[allow(deprecated)]
5059 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5060 where
5061 D: serde::Deserializer<'de>,
5062 {
5063 const FIELDS: &[&str] = &[
5064 "fragment_id",
5065 "fragmentId",
5066 "table_id",
5067 "tableId",
5068 "distribution_type",
5069 "distributionType",
5070 "state_table_ids",
5071 "stateTableIds",
5072 "upstream_fragment_ids",
5073 "upstreamFragmentIds",
5074 "fragment_type_mask",
5075 "fragmentTypeMask",
5076 "parallelism",
5077 "vnode_count",
5078 "vnodeCount",
5079 "node",
5080 ];
5081
5082 #[allow(clippy::enum_variant_names)]
5083 enum GeneratedField {
5084 FragmentId,
5085 TableId,
5086 DistributionType,
5087 StateTableIds,
5088 UpstreamFragmentIds,
5089 FragmentTypeMask,
5090 Parallelism,
5091 VnodeCount,
5092 Node,
5093 }
5094 impl<'de> serde::Deserialize<'de> for GeneratedField {
5095 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5096 where
5097 D: serde::Deserializer<'de>,
5098 {
5099 struct GeneratedVisitor;
5100
5101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5102 type Value = GeneratedField;
5103
5104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5105 write!(formatter, "expected one of: {:?}", &FIELDS)
5106 }
5107
5108 #[allow(unused_variables)]
5109 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5110 where
5111 E: serde::de::Error,
5112 {
5113 match value {
5114 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5115 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5116 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5117 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5118 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5119 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5120 "parallelism" => Ok(GeneratedField::Parallelism),
5121 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5122 "node" => Ok(GeneratedField::Node),
5123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5124 }
5125 }
5126 }
5127 deserializer.deserialize_identifier(GeneratedVisitor)
5128 }
5129 }
5130 struct GeneratedVisitor;
5131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5132 type Value = FragmentDistribution;
5133
5134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5135 formatter.write_str("struct meta.FragmentDistribution")
5136 }
5137
5138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5139 where
5140 V: serde::de::MapAccess<'de>,
5141 {
5142 let mut fragment_id__ = None;
5143 let mut table_id__ = None;
5144 let mut distribution_type__ = None;
5145 let mut state_table_ids__ = None;
5146 let mut upstream_fragment_ids__ = None;
5147 let mut fragment_type_mask__ = None;
5148 let mut parallelism__ = None;
5149 let mut vnode_count__ = None;
5150 let mut node__ = None;
5151 while let Some(k) = map_.next_key()? {
5152 match k {
5153 GeneratedField::FragmentId => {
5154 if fragment_id__.is_some() {
5155 return Err(serde::de::Error::duplicate_field("fragmentId"));
5156 }
5157 fragment_id__ =
5158 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5159 ;
5160 }
5161 GeneratedField::TableId => {
5162 if table_id__.is_some() {
5163 return Err(serde::de::Error::duplicate_field("tableId"));
5164 }
5165 table_id__ =
5166 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5167 ;
5168 }
5169 GeneratedField::DistributionType => {
5170 if distribution_type__.is_some() {
5171 return Err(serde::de::Error::duplicate_field("distributionType"));
5172 }
5173 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5174 }
5175 GeneratedField::StateTableIds => {
5176 if state_table_ids__.is_some() {
5177 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5178 }
5179 state_table_ids__ =
5180 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5181 .into_iter().map(|x| x.0).collect())
5182 ;
5183 }
5184 GeneratedField::UpstreamFragmentIds => {
5185 if upstream_fragment_ids__.is_some() {
5186 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5187 }
5188 upstream_fragment_ids__ =
5189 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5190 .into_iter().map(|x| x.0).collect())
5191 ;
5192 }
5193 GeneratedField::FragmentTypeMask => {
5194 if fragment_type_mask__.is_some() {
5195 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5196 }
5197 fragment_type_mask__ =
5198 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5199 ;
5200 }
5201 GeneratedField::Parallelism => {
5202 if parallelism__.is_some() {
5203 return Err(serde::de::Error::duplicate_field("parallelism"));
5204 }
5205 parallelism__ =
5206 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5207 ;
5208 }
5209 GeneratedField::VnodeCount => {
5210 if vnode_count__.is_some() {
5211 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5212 }
5213 vnode_count__ =
5214 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5215 ;
5216 }
5217 GeneratedField::Node => {
5218 if node__.is_some() {
5219 return Err(serde::de::Error::duplicate_field("node"));
5220 }
5221 node__ = map_.next_value()?;
5222 }
5223 }
5224 }
5225 Ok(FragmentDistribution {
5226 fragment_id: fragment_id__.unwrap_or_default(),
5227 table_id: table_id__.unwrap_or_default(),
5228 distribution_type: distribution_type__.unwrap_or_default(),
5229 state_table_ids: state_table_ids__.unwrap_or_default(),
5230 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5231 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5232 parallelism: parallelism__.unwrap_or_default(),
5233 vnode_count: vnode_count__.unwrap_or_default(),
5234 node: node__,
5235 })
5236 }
5237 }
5238 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5239 }
5240}
5241impl serde::Serialize for FragmentIdToActorIdMap {
5242 #[allow(deprecated)]
5243 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5244 where
5245 S: serde::Serializer,
5246 {
5247 use serde::ser::SerializeStruct;
5248 let mut len = 0;
5249 if !self.map.is_empty() {
5250 len += 1;
5251 }
5252 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5253 if !self.map.is_empty() {
5254 struct_ser.serialize_field("map", &self.map)?;
5255 }
5256 struct_ser.end()
5257 }
5258}
5259impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5260 #[allow(deprecated)]
5261 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5262 where
5263 D: serde::Deserializer<'de>,
5264 {
5265 const FIELDS: &[&str] = &[
5266 "map",
5267 ];
5268
5269 #[allow(clippy::enum_variant_names)]
5270 enum GeneratedField {
5271 Map,
5272 }
5273 impl<'de> serde::Deserialize<'de> for GeneratedField {
5274 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5275 where
5276 D: serde::Deserializer<'de>,
5277 {
5278 struct GeneratedVisitor;
5279
5280 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5281 type Value = GeneratedField;
5282
5283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5284 write!(formatter, "expected one of: {:?}", &FIELDS)
5285 }
5286
5287 #[allow(unused_variables)]
5288 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5289 where
5290 E: serde::de::Error,
5291 {
5292 match value {
5293 "map" => Ok(GeneratedField::Map),
5294 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5295 }
5296 }
5297 }
5298 deserializer.deserialize_identifier(GeneratedVisitor)
5299 }
5300 }
5301 struct GeneratedVisitor;
5302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5303 type Value = FragmentIdToActorIdMap;
5304
5305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5306 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5307 }
5308
5309 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5310 where
5311 V: serde::de::MapAccess<'de>,
5312 {
5313 let mut map__ = None;
5314 while let Some(k) = map_.next_key()? {
5315 match k {
5316 GeneratedField::Map => {
5317 if map__.is_some() {
5318 return Err(serde::de::Error::duplicate_field("map"));
5319 }
5320 map__ = Some(
5321 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5322 .into_iter().map(|(k,v)| (k.0, v)).collect()
5323 );
5324 }
5325 }
5326 }
5327 Ok(FragmentIdToActorIdMap {
5328 map: map__.unwrap_or_default(),
5329 })
5330 }
5331 }
5332 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5333 }
5334}
5335impl serde::Serialize for FragmentToRelationMap {
5336 #[allow(deprecated)]
5337 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5338 where
5339 S: serde::Serializer,
5340 {
5341 use serde::ser::SerializeStruct;
5342 let mut len = 0;
5343 if !self.in_map.is_empty() {
5344 len += 1;
5345 }
5346 if !self.out_map.is_empty() {
5347 len += 1;
5348 }
5349 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5350 if !self.in_map.is_empty() {
5351 struct_ser.serialize_field("inMap", &self.in_map)?;
5352 }
5353 if !self.out_map.is_empty() {
5354 struct_ser.serialize_field("outMap", &self.out_map)?;
5355 }
5356 struct_ser.end()
5357 }
5358}
5359impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5360 #[allow(deprecated)]
5361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5362 where
5363 D: serde::Deserializer<'de>,
5364 {
5365 const FIELDS: &[&str] = &[
5366 "in_map",
5367 "inMap",
5368 "out_map",
5369 "outMap",
5370 ];
5371
5372 #[allow(clippy::enum_variant_names)]
5373 enum GeneratedField {
5374 InMap,
5375 OutMap,
5376 }
5377 impl<'de> serde::Deserialize<'de> for GeneratedField {
5378 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5379 where
5380 D: serde::Deserializer<'de>,
5381 {
5382 struct GeneratedVisitor;
5383
5384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5385 type Value = GeneratedField;
5386
5387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5388 write!(formatter, "expected one of: {:?}", &FIELDS)
5389 }
5390
5391 #[allow(unused_variables)]
5392 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5393 where
5394 E: serde::de::Error,
5395 {
5396 match value {
5397 "inMap" | "in_map" => Ok(GeneratedField::InMap),
5398 "outMap" | "out_map" => Ok(GeneratedField::OutMap),
5399 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5400 }
5401 }
5402 }
5403 deserializer.deserialize_identifier(GeneratedVisitor)
5404 }
5405 }
5406 struct GeneratedVisitor;
5407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5408 type Value = FragmentToRelationMap;
5409
5410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5411 formatter.write_str("struct meta.FragmentToRelationMap")
5412 }
5413
5414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5415 where
5416 V: serde::de::MapAccess<'de>,
5417 {
5418 let mut in_map__ = None;
5419 let mut out_map__ = None;
5420 while let Some(k) = map_.next_key()? {
5421 match k {
5422 GeneratedField::InMap => {
5423 if in_map__.is_some() {
5424 return Err(serde::de::Error::duplicate_field("inMap"));
5425 }
5426 in_map__ = Some(
5427 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5428 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
5429 );
5430 }
5431 GeneratedField::OutMap => {
5432 if out_map__.is_some() {
5433 return Err(serde::de::Error::duplicate_field("outMap"));
5434 }
5435 out_map__ = Some(
5436 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5437 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
5438 );
5439 }
5440 }
5441 }
5442 Ok(FragmentToRelationMap {
5443 in_map: in_map__.unwrap_or_default(),
5444 out_map: out_map__.unwrap_or_default(),
5445 })
5446 }
5447 }
5448 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5449 }
5450}
5451impl serde::Serialize for FragmentWorkerSlotMapping {
5452 #[allow(deprecated)]
5453 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5454 where
5455 S: serde::Serializer,
5456 {
5457 use serde::ser::SerializeStruct;
5458 let mut len = 0;
5459 if self.fragment_id != 0 {
5460 len += 1;
5461 }
5462 if self.mapping.is_some() {
5463 len += 1;
5464 }
5465 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5466 if self.fragment_id != 0 {
5467 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5468 }
5469 if let Some(v) = self.mapping.as_ref() {
5470 struct_ser.serialize_field("mapping", v)?;
5471 }
5472 struct_ser.end()
5473 }
5474}
5475impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5476 #[allow(deprecated)]
5477 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5478 where
5479 D: serde::Deserializer<'de>,
5480 {
5481 const FIELDS: &[&str] = &[
5482 "fragment_id",
5483 "fragmentId",
5484 "mapping",
5485 ];
5486
5487 #[allow(clippy::enum_variant_names)]
5488 enum GeneratedField {
5489 FragmentId,
5490 Mapping,
5491 }
5492 impl<'de> serde::Deserialize<'de> for GeneratedField {
5493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5494 where
5495 D: serde::Deserializer<'de>,
5496 {
5497 struct GeneratedVisitor;
5498
5499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5500 type Value = GeneratedField;
5501
5502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5503 write!(formatter, "expected one of: {:?}", &FIELDS)
5504 }
5505
5506 #[allow(unused_variables)]
5507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5508 where
5509 E: serde::de::Error,
5510 {
5511 match value {
5512 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5513 "mapping" => Ok(GeneratedField::Mapping),
5514 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5515 }
5516 }
5517 }
5518 deserializer.deserialize_identifier(GeneratedVisitor)
5519 }
5520 }
5521 struct GeneratedVisitor;
5522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5523 type Value = FragmentWorkerSlotMapping;
5524
5525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5526 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5527 }
5528
5529 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5530 where
5531 V: serde::de::MapAccess<'de>,
5532 {
5533 let mut fragment_id__ = None;
5534 let mut mapping__ = None;
5535 while let Some(k) = map_.next_key()? {
5536 match k {
5537 GeneratedField::FragmentId => {
5538 if fragment_id__.is_some() {
5539 return Err(serde::de::Error::duplicate_field("fragmentId"));
5540 }
5541 fragment_id__ =
5542 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5543 ;
5544 }
5545 GeneratedField::Mapping => {
5546 if mapping__.is_some() {
5547 return Err(serde::de::Error::duplicate_field("mapping"));
5548 }
5549 mapping__ = map_.next_value()?;
5550 }
5551 }
5552 }
5553 Ok(FragmentWorkerSlotMapping {
5554 fragment_id: fragment_id__.unwrap_or_default(),
5555 mapping: mapping__,
5556 })
5557 }
5558 }
5559 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5560 }
5561}
5562impl serde::Serialize for FragmentWorkerSlotMappings {
5563 #[allow(deprecated)]
5564 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5565 where
5566 S: serde::Serializer,
5567 {
5568 use serde::ser::SerializeStruct;
5569 let mut len = 0;
5570 if !self.mappings.is_empty() {
5571 len += 1;
5572 }
5573 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
5574 if !self.mappings.is_empty() {
5575 struct_ser.serialize_field("mappings", &self.mappings)?;
5576 }
5577 struct_ser.end()
5578 }
5579}
5580impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
5581 #[allow(deprecated)]
5582 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5583 where
5584 D: serde::Deserializer<'de>,
5585 {
5586 const FIELDS: &[&str] = &[
5587 "mappings",
5588 ];
5589
5590 #[allow(clippy::enum_variant_names)]
5591 enum GeneratedField {
5592 Mappings,
5593 }
5594 impl<'de> serde::Deserialize<'de> for GeneratedField {
5595 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5596 where
5597 D: serde::Deserializer<'de>,
5598 {
5599 struct GeneratedVisitor;
5600
5601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5602 type Value = GeneratedField;
5603
5604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5605 write!(formatter, "expected one of: {:?}", &FIELDS)
5606 }
5607
5608 #[allow(unused_variables)]
5609 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5610 where
5611 E: serde::de::Error,
5612 {
5613 match value {
5614 "mappings" => Ok(GeneratedField::Mappings),
5615 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5616 }
5617 }
5618 }
5619 deserializer.deserialize_identifier(GeneratedVisitor)
5620 }
5621 }
5622 struct GeneratedVisitor;
5623 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5624 type Value = FragmentWorkerSlotMappings;
5625
5626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5627 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
5628 }
5629
5630 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
5631 where
5632 V: serde::de::MapAccess<'de>,
5633 {
5634 let mut mappings__ = None;
5635 while let Some(k) = map_.next_key()? {
5636 match k {
5637 GeneratedField::Mappings => {
5638 if mappings__.is_some() {
5639 return Err(serde::de::Error::duplicate_field("mappings"));
5640 }
5641 mappings__ = Some(map_.next_value()?);
5642 }
5643 }
5644 }
5645 Ok(FragmentWorkerSlotMappings {
5646 mappings: mappings__.unwrap_or_default(),
5647 })
5648 }
5649 }
5650 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
5651 }
5652}
5653impl serde::Serialize for GetClusterInfoRequest {
5654 #[allow(deprecated)]
5655 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5656 where
5657 S: serde::Serializer,
5658 {
5659 use serde::ser::SerializeStruct;
5660 let len = 0;
5661 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
5662 struct_ser.end()
5663 }
5664}
5665impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
5666 #[allow(deprecated)]
5667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5668 where
5669 D: serde::Deserializer<'de>,
5670 {
5671 const FIELDS: &[&str] = &[
5672 ];
5673
5674 #[allow(clippy::enum_variant_names)]
5675 enum GeneratedField {
5676 }
5677 impl<'de> serde::Deserialize<'de> for GeneratedField {
5678 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5679 where
5680 D: serde::Deserializer<'de>,
5681 {
5682 struct GeneratedVisitor;
5683
5684 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5685 type Value = GeneratedField;
5686
5687 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5688 write!(formatter, "expected one of: {:?}", &FIELDS)
5689 }
5690
5691 #[allow(unused_variables)]
5692 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5693 where
5694 E: serde::de::Error,
5695 {
5696 Err(serde::de::Error::unknown_field(value, FIELDS))
5697 }
5698 }
5699 deserializer.deserialize_identifier(GeneratedVisitor)
5700 }
5701 }
5702 struct GeneratedVisitor;
5703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5704 type Value = GetClusterInfoRequest;
5705
5706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5707 formatter.write_str("struct meta.GetClusterInfoRequest")
5708 }
5709
5710 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
5711 where
5712 V: serde::de::MapAccess<'de>,
5713 {
5714 while map_.next_key::<GeneratedField>()?.is_some() {
5715 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5716 }
5717 Ok(GetClusterInfoRequest {
5718 })
5719 }
5720 }
5721 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
5722 }
5723}
5724impl serde::Serialize for GetClusterInfoResponse {
5725 #[allow(deprecated)]
5726 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5727 where
5728 S: serde::Serializer,
5729 {
5730 use serde::ser::SerializeStruct;
5731 let mut len = 0;
5732 if !self.worker_nodes.is_empty() {
5733 len += 1;
5734 }
5735 if !self.table_fragments.is_empty() {
5736 len += 1;
5737 }
5738 if !self.actor_splits.is_empty() {
5739 len += 1;
5740 }
5741 if !self.source_infos.is_empty() {
5742 len += 1;
5743 }
5744 if self.revision != 0 {
5745 len += 1;
5746 }
5747 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
5748 if !self.worker_nodes.is_empty() {
5749 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
5750 }
5751 if !self.table_fragments.is_empty() {
5752 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
5753 }
5754 if !self.actor_splits.is_empty() {
5755 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
5756 }
5757 if !self.source_infos.is_empty() {
5758 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
5759 }
5760 if self.revision != 0 {
5761 #[allow(clippy::needless_borrow)]
5762 #[allow(clippy::needless_borrows_for_generic_args)]
5763 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
5764 }
5765 struct_ser.end()
5766 }
5767}
5768impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
5769 #[allow(deprecated)]
5770 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5771 where
5772 D: serde::Deserializer<'de>,
5773 {
5774 const FIELDS: &[&str] = &[
5775 "worker_nodes",
5776 "workerNodes",
5777 "table_fragments",
5778 "tableFragments",
5779 "actor_splits",
5780 "actorSplits",
5781 "source_infos",
5782 "sourceInfos",
5783 "revision",
5784 ];
5785
5786 #[allow(clippy::enum_variant_names)]
5787 enum GeneratedField {
5788 WorkerNodes,
5789 TableFragments,
5790 ActorSplits,
5791 SourceInfos,
5792 Revision,
5793 }
5794 impl<'de> serde::Deserialize<'de> for GeneratedField {
5795 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5796 where
5797 D: serde::Deserializer<'de>,
5798 {
5799 struct GeneratedVisitor;
5800
5801 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5802 type Value = GeneratedField;
5803
5804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5805 write!(formatter, "expected one of: {:?}", &FIELDS)
5806 }
5807
5808 #[allow(unused_variables)]
5809 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5810 where
5811 E: serde::de::Error,
5812 {
5813 match value {
5814 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
5815 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
5816 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
5817 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
5818 "revision" => Ok(GeneratedField::Revision),
5819 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5820 }
5821 }
5822 }
5823 deserializer.deserialize_identifier(GeneratedVisitor)
5824 }
5825 }
5826 struct GeneratedVisitor;
5827 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5828 type Value = GetClusterInfoResponse;
5829
5830 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5831 formatter.write_str("struct meta.GetClusterInfoResponse")
5832 }
5833
5834 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
5835 where
5836 V: serde::de::MapAccess<'de>,
5837 {
5838 let mut worker_nodes__ = None;
5839 let mut table_fragments__ = None;
5840 let mut actor_splits__ = None;
5841 let mut source_infos__ = None;
5842 let mut revision__ = None;
5843 while let Some(k) = map_.next_key()? {
5844 match k {
5845 GeneratedField::WorkerNodes => {
5846 if worker_nodes__.is_some() {
5847 return Err(serde::de::Error::duplicate_field("workerNodes"));
5848 }
5849 worker_nodes__ = Some(map_.next_value()?);
5850 }
5851 GeneratedField::TableFragments => {
5852 if table_fragments__.is_some() {
5853 return Err(serde::de::Error::duplicate_field("tableFragments"));
5854 }
5855 table_fragments__ = Some(map_.next_value()?);
5856 }
5857 GeneratedField::ActorSplits => {
5858 if actor_splits__.is_some() {
5859 return Err(serde::de::Error::duplicate_field("actorSplits"));
5860 }
5861 actor_splits__ = Some(
5862 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5863 .into_iter().map(|(k,v)| (k.0, v)).collect()
5864 );
5865 }
5866 GeneratedField::SourceInfos => {
5867 if source_infos__.is_some() {
5868 return Err(serde::de::Error::duplicate_field("sourceInfos"));
5869 }
5870 source_infos__ = Some(
5871 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5872 .into_iter().map(|(k,v)| (k.0, v)).collect()
5873 );
5874 }
5875 GeneratedField::Revision => {
5876 if revision__.is_some() {
5877 return Err(serde::de::Error::duplicate_field("revision"));
5878 }
5879 revision__ =
5880 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5881 ;
5882 }
5883 }
5884 }
5885 Ok(GetClusterInfoResponse {
5886 worker_nodes: worker_nodes__.unwrap_or_default(),
5887 table_fragments: table_fragments__.unwrap_or_default(),
5888 actor_splits: actor_splits__.unwrap_or_default(),
5889 source_infos: source_infos__.unwrap_or_default(),
5890 revision: revision__.unwrap_or_default(),
5891 })
5892 }
5893 }
5894 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
5895 }
5896}
5897impl serde::Serialize for GetClusterLimitsRequest {
5898 #[allow(deprecated)]
5899 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5900 where
5901 S: serde::Serializer,
5902 {
5903 use serde::ser::SerializeStruct;
5904 let len = 0;
5905 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
5906 struct_ser.end()
5907 }
5908}
5909impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
5910 #[allow(deprecated)]
5911 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5912 where
5913 D: serde::Deserializer<'de>,
5914 {
5915 const FIELDS: &[&str] = &[
5916 ];
5917
5918 #[allow(clippy::enum_variant_names)]
5919 enum GeneratedField {
5920 }
5921 impl<'de> serde::Deserialize<'de> for GeneratedField {
5922 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5923 where
5924 D: serde::Deserializer<'de>,
5925 {
5926 struct GeneratedVisitor;
5927
5928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5929 type Value = GeneratedField;
5930
5931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5932 write!(formatter, "expected one of: {:?}", &FIELDS)
5933 }
5934
5935 #[allow(unused_variables)]
5936 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5937 where
5938 E: serde::de::Error,
5939 {
5940 Err(serde::de::Error::unknown_field(value, FIELDS))
5941 }
5942 }
5943 deserializer.deserialize_identifier(GeneratedVisitor)
5944 }
5945 }
5946 struct GeneratedVisitor;
5947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5948 type Value = GetClusterLimitsRequest;
5949
5950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5951 formatter.write_str("struct meta.GetClusterLimitsRequest")
5952 }
5953
5954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
5955 where
5956 V: serde::de::MapAccess<'de>,
5957 {
5958 while map_.next_key::<GeneratedField>()?.is_some() {
5959 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5960 }
5961 Ok(GetClusterLimitsRequest {
5962 })
5963 }
5964 }
5965 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
5966 }
5967}
5968impl serde::Serialize for GetClusterLimitsResponse {
5969 #[allow(deprecated)]
5970 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5971 where
5972 S: serde::Serializer,
5973 {
5974 use serde::ser::SerializeStruct;
5975 let mut len = 0;
5976 if !self.active_limits.is_empty() {
5977 len += 1;
5978 }
5979 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
5980 if !self.active_limits.is_empty() {
5981 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
5982 }
5983 struct_ser.end()
5984 }
5985}
5986impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
5987 #[allow(deprecated)]
5988 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5989 where
5990 D: serde::Deserializer<'de>,
5991 {
5992 const FIELDS: &[&str] = &[
5993 "active_limits",
5994 "activeLimits",
5995 ];
5996
5997 #[allow(clippy::enum_variant_names)]
5998 enum GeneratedField {
5999 ActiveLimits,
6000 }
6001 impl<'de> serde::Deserialize<'de> for GeneratedField {
6002 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6003 where
6004 D: serde::Deserializer<'de>,
6005 {
6006 struct GeneratedVisitor;
6007
6008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6009 type Value = GeneratedField;
6010
6011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6012 write!(formatter, "expected one of: {:?}", &FIELDS)
6013 }
6014
6015 #[allow(unused_variables)]
6016 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6017 where
6018 E: serde::de::Error,
6019 {
6020 match value {
6021 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6022 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6023 }
6024 }
6025 }
6026 deserializer.deserialize_identifier(GeneratedVisitor)
6027 }
6028 }
6029 struct GeneratedVisitor;
6030 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6031 type Value = GetClusterLimitsResponse;
6032
6033 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6034 formatter.write_str("struct meta.GetClusterLimitsResponse")
6035 }
6036
6037 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6038 where
6039 V: serde::de::MapAccess<'de>,
6040 {
6041 let mut active_limits__ = None;
6042 while let Some(k) = map_.next_key()? {
6043 match k {
6044 GeneratedField::ActiveLimits => {
6045 if active_limits__.is_some() {
6046 return Err(serde::de::Error::duplicate_field("activeLimits"));
6047 }
6048 active_limits__ = Some(map_.next_value()?);
6049 }
6050 }
6051 }
6052 Ok(GetClusterLimitsResponse {
6053 active_limits: active_limits__.unwrap_or_default(),
6054 })
6055 }
6056 }
6057 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6058 }
6059}
6060impl serde::Serialize for GetClusterRecoveryStatusRequest {
6061 #[allow(deprecated)]
6062 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6063 where
6064 S: serde::Serializer,
6065 {
6066 use serde::ser::SerializeStruct;
6067 let len = 0;
6068 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6069 struct_ser.end()
6070 }
6071}
6072impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6073 #[allow(deprecated)]
6074 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6075 where
6076 D: serde::Deserializer<'de>,
6077 {
6078 const FIELDS: &[&str] = &[
6079 ];
6080
6081 #[allow(clippy::enum_variant_names)]
6082 enum GeneratedField {
6083 }
6084 impl<'de> serde::Deserialize<'de> for GeneratedField {
6085 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6086 where
6087 D: serde::Deserializer<'de>,
6088 {
6089 struct GeneratedVisitor;
6090
6091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6092 type Value = GeneratedField;
6093
6094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6095 write!(formatter, "expected one of: {:?}", &FIELDS)
6096 }
6097
6098 #[allow(unused_variables)]
6099 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6100 where
6101 E: serde::de::Error,
6102 {
6103 Err(serde::de::Error::unknown_field(value, FIELDS))
6104 }
6105 }
6106 deserializer.deserialize_identifier(GeneratedVisitor)
6107 }
6108 }
6109 struct GeneratedVisitor;
6110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6111 type Value = GetClusterRecoveryStatusRequest;
6112
6113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6114 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6115 }
6116
6117 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6118 where
6119 V: serde::de::MapAccess<'de>,
6120 {
6121 while map_.next_key::<GeneratedField>()?.is_some() {
6122 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6123 }
6124 Ok(GetClusterRecoveryStatusRequest {
6125 })
6126 }
6127 }
6128 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6129 }
6130}
6131impl serde::Serialize for GetClusterRecoveryStatusResponse {
6132 #[allow(deprecated)]
6133 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6134 where
6135 S: serde::Serializer,
6136 {
6137 use serde::ser::SerializeStruct;
6138 let mut len = 0;
6139 if self.status != 0 {
6140 len += 1;
6141 }
6142 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6143 if self.status != 0 {
6144 let v = RecoveryStatus::try_from(self.status)
6145 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6146 struct_ser.serialize_field("status", &v)?;
6147 }
6148 struct_ser.end()
6149 }
6150}
6151impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6152 #[allow(deprecated)]
6153 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6154 where
6155 D: serde::Deserializer<'de>,
6156 {
6157 const FIELDS: &[&str] = &[
6158 "status",
6159 ];
6160
6161 #[allow(clippy::enum_variant_names)]
6162 enum GeneratedField {
6163 Status,
6164 }
6165 impl<'de> serde::Deserialize<'de> for GeneratedField {
6166 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6167 where
6168 D: serde::Deserializer<'de>,
6169 {
6170 struct GeneratedVisitor;
6171
6172 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6173 type Value = GeneratedField;
6174
6175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6176 write!(formatter, "expected one of: {:?}", &FIELDS)
6177 }
6178
6179 #[allow(unused_variables)]
6180 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6181 where
6182 E: serde::de::Error,
6183 {
6184 match value {
6185 "status" => Ok(GeneratedField::Status),
6186 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6187 }
6188 }
6189 }
6190 deserializer.deserialize_identifier(GeneratedVisitor)
6191 }
6192 }
6193 struct GeneratedVisitor;
6194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6195 type Value = GetClusterRecoveryStatusResponse;
6196
6197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6198 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6199 }
6200
6201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6202 where
6203 V: serde::de::MapAccess<'de>,
6204 {
6205 let mut status__ = None;
6206 while let Some(k) = map_.next_key()? {
6207 match k {
6208 GeneratedField::Status => {
6209 if status__.is_some() {
6210 return Err(serde::de::Error::duplicate_field("status"));
6211 }
6212 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6213 }
6214 }
6215 }
6216 Ok(GetClusterRecoveryStatusResponse {
6217 status: status__.unwrap_or_default(),
6218 })
6219 }
6220 }
6221 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6222 }
6223}
6224impl serde::Serialize for GetFragmentByIdRequest {
6225 #[allow(deprecated)]
6226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6227 where
6228 S: serde::Serializer,
6229 {
6230 use serde::ser::SerializeStruct;
6231 let mut len = 0;
6232 if self.fragment_id != 0 {
6233 len += 1;
6234 }
6235 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6236 if self.fragment_id != 0 {
6237 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6238 }
6239 struct_ser.end()
6240 }
6241}
6242impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6243 #[allow(deprecated)]
6244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6245 where
6246 D: serde::Deserializer<'de>,
6247 {
6248 const FIELDS: &[&str] = &[
6249 "fragment_id",
6250 "fragmentId",
6251 ];
6252
6253 #[allow(clippy::enum_variant_names)]
6254 enum GeneratedField {
6255 FragmentId,
6256 }
6257 impl<'de> serde::Deserialize<'de> for GeneratedField {
6258 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6259 where
6260 D: serde::Deserializer<'de>,
6261 {
6262 struct GeneratedVisitor;
6263
6264 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6265 type Value = GeneratedField;
6266
6267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6268 write!(formatter, "expected one of: {:?}", &FIELDS)
6269 }
6270
6271 #[allow(unused_variables)]
6272 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6273 where
6274 E: serde::de::Error,
6275 {
6276 match value {
6277 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6278 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6279 }
6280 }
6281 }
6282 deserializer.deserialize_identifier(GeneratedVisitor)
6283 }
6284 }
6285 struct GeneratedVisitor;
6286 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6287 type Value = GetFragmentByIdRequest;
6288
6289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6290 formatter.write_str("struct meta.GetFragmentByIdRequest")
6291 }
6292
6293 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6294 where
6295 V: serde::de::MapAccess<'de>,
6296 {
6297 let mut fragment_id__ = None;
6298 while let Some(k) = map_.next_key()? {
6299 match k {
6300 GeneratedField::FragmentId => {
6301 if fragment_id__.is_some() {
6302 return Err(serde::de::Error::duplicate_field("fragmentId"));
6303 }
6304 fragment_id__ =
6305 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6306 ;
6307 }
6308 }
6309 }
6310 Ok(GetFragmentByIdRequest {
6311 fragment_id: fragment_id__.unwrap_or_default(),
6312 })
6313 }
6314 }
6315 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6316 }
6317}
6318impl serde::Serialize for GetFragmentByIdResponse {
6319 #[allow(deprecated)]
6320 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6321 where
6322 S: serde::Serializer,
6323 {
6324 use serde::ser::SerializeStruct;
6325 let mut len = 0;
6326 if self.distribution.is_some() {
6327 len += 1;
6328 }
6329 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6330 if let Some(v) = self.distribution.as_ref() {
6331 struct_ser.serialize_field("distribution", v)?;
6332 }
6333 struct_ser.end()
6334 }
6335}
6336impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6337 #[allow(deprecated)]
6338 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6339 where
6340 D: serde::Deserializer<'de>,
6341 {
6342 const FIELDS: &[&str] = &[
6343 "distribution",
6344 ];
6345
6346 #[allow(clippy::enum_variant_names)]
6347 enum GeneratedField {
6348 Distribution,
6349 }
6350 impl<'de> serde::Deserialize<'de> for GeneratedField {
6351 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6352 where
6353 D: serde::Deserializer<'de>,
6354 {
6355 struct GeneratedVisitor;
6356
6357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6358 type Value = GeneratedField;
6359
6360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6361 write!(formatter, "expected one of: {:?}", &FIELDS)
6362 }
6363
6364 #[allow(unused_variables)]
6365 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6366 where
6367 E: serde::de::Error,
6368 {
6369 match value {
6370 "distribution" => Ok(GeneratedField::Distribution),
6371 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6372 }
6373 }
6374 }
6375 deserializer.deserialize_identifier(GeneratedVisitor)
6376 }
6377 }
6378 struct GeneratedVisitor;
6379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6380 type Value = GetFragmentByIdResponse;
6381
6382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6383 formatter.write_str("struct meta.GetFragmentByIdResponse")
6384 }
6385
6386 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
6387 where
6388 V: serde::de::MapAccess<'de>,
6389 {
6390 let mut distribution__ = None;
6391 while let Some(k) = map_.next_key()? {
6392 match k {
6393 GeneratedField::Distribution => {
6394 if distribution__.is_some() {
6395 return Err(serde::de::Error::duplicate_field("distribution"));
6396 }
6397 distribution__ = map_.next_value()?;
6398 }
6399 }
6400 }
6401 Ok(GetFragmentByIdResponse {
6402 distribution: distribution__,
6403 })
6404 }
6405 }
6406 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
6407 }
6408}
6409impl serde::Serialize for GetMetaStoreInfoRequest {
6410 #[allow(deprecated)]
6411 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6412 where
6413 S: serde::Serializer,
6414 {
6415 use serde::ser::SerializeStruct;
6416 let len = 0;
6417 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
6418 struct_ser.end()
6419 }
6420}
6421impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
6422 #[allow(deprecated)]
6423 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6424 where
6425 D: serde::Deserializer<'de>,
6426 {
6427 const FIELDS: &[&str] = &[
6428 ];
6429
6430 #[allow(clippy::enum_variant_names)]
6431 enum GeneratedField {
6432 }
6433 impl<'de> serde::Deserialize<'de> for GeneratedField {
6434 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6435 where
6436 D: serde::Deserializer<'de>,
6437 {
6438 struct GeneratedVisitor;
6439
6440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6441 type Value = GeneratedField;
6442
6443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6444 write!(formatter, "expected one of: {:?}", &FIELDS)
6445 }
6446
6447 #[allow(unused_variables)]
6448 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6449 where
6450 E: serde::de::Error,
6451 {
6452 Err(serde::de::Error::unknown_field(value, FIELDS))
6453 }
6454 }
6455 deserializer.deserialize_identifier(GeneratedVisitor)
6456 }
6457 }
6458 struct GeneratedVisitor;
6459 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6460 type Value = GetMetaStoreInfoRequest;
6461
6462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6463 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
6464 }
6465
6466 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
6467 where
6468 V: serde::de::MapAccess<'de>,
6469 {
6470 while map_.next_key::<GeneratedField>()?.is_some() {
6471 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6472 }
6473 Ok(GetMetaStoreInfoRequest {
6474 })
6475 }
6476 }
6477 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
6478 }
6479}
6480impl serde::Serialize for GetMetaStoreInfoResponse {
6481 #[allow(deprecated)]
6482 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6483 where
6484 S: serde::Serializer,
6485 {
6486 use serde::ser::SerializeStruct;
6487 let mut len = 0;
6488 if !self.meta_store_endpoint.is_empty() {
6489 len += 1;
6490 }
6491 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
6492 if !self.meta_store_endpoint.is_empty() {
6493 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
6494 }
6495 struct_ser.end()
6496 }
6497}
6498impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
6499 #[allow(deprecated)]
6500 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6501 where
6502 D: serde::Deserializer<'de>,
6503 {
6504 const FIELDS: &[&str] = &[
6505 "meta_store_endpoint",
6506 "metaStoreEndpoint",
6507 ];
6508
6509 #[allow(clippy::enum_variant_names)]
6510 enum GeneratedField {
6511 MetaStoreEndpoint,
6512 }
6513 impl<'de> serde::Deserialize<'de> for GeneratedField {
6514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6515 where
6516 D: serde::Deserializer<'de>,
6517 {
6518 struct GeneratedVisitor;
6519
6520 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6521 type Value = GeneratedField;
6522
6523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6524 write!(formatter, "expected one of: {:?}", &FIELDS)
6525 }
6526
6527 #[allow(unused_variables)]
6528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6529 where
6530 E: serde::de::Error,
6531 {
6532 match value {
6533 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
6534 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6535 }
6536 }
6537 }
6538 deserializer.deserialize_identifier(GeneratedVisitor)
6539 }
6540 }
6541 struct GeneratedVisitor;
6542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6543 type Value = GetMetaStoreInfoResponse;
6544
6545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6546 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
6547 }
6548
6549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
6550 where
6551 V: serde::de::MapAccess<'de>,
6552 {
6553 let mut meta_store_endpoint__ = None;
6554 while let Some(k) = map_.next_key()? {
6555 match k {
6556 GeneratedField::MetaStoreEndpoint => {
6557 if meta_store_endpoint__.is_some() {
6558 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
6559 }
6560 meta_store_endpoint__ = Some(map_.next_value()?);
6561 }
6562 }
6563 }
6564 Ok(GetMetaStoreInfoResponse {
6565 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
6566 })
6567 }
6568 }
6569 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
6570 }
6571}
6572impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
6573 #[allow(deprecated)]
6574 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6575 where
6576 S: serde::Serializer,
6577 {
6578 use serde::ser::SerializeStruct;
6579 let len = 0;
6580 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
6581 struct_ser.end()
6582 }
6583}
6584impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
6585 #[allow(deprecated)]
6586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6587 where
6588 D: serde::Deserializer<'de>,
6589 {
6590 const FIELDS: &[&str] = &[
6591 ];
6592
6593 #[allow(clippy::enum_variant_names)]
6594 enum GeneratedField {
6595 }
6596 impl<'de> serde::Deserialize<'de> for GeneratedField {
6597 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6598 where
6599 D: serde::Deserializer<'de>,
6600 {
6601 struct GeneratedVisitor;
6602
6603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6604 type Value = GeneratedField;
6605
6606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6607 write!(formatter, "expected one of: {:?}", &FIELDS)
6608 }
6609
6610 #[allow(unused_variables)]
6611 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6612 where
6613 E: serde::de::Error,
6614 {
6615 Err(serde::de::Error::unknown_field(value, FIELDS))
6616 }
6617 }
6618 deserializer.deserialize_identifier(GeneratedVisitor)
6619 }
6620 }
6621 struct GeneratedVisitor;
6622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6623 type Value = GetServerlessStreamingJobsStatusRequest;
6624
6625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6626 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
6627 }
6628
6629 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
6630 where
6631 V: serde::de::MapAccess<'de>,
6632 {
6633 while map_.next_key::<GeneratedField>()?.is_some() {
6634 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6635 }
6636 Ok(GetServerlessStreamingJobsStatusRequest {
6637 })
6638 }
6639 }
6640 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
6641 }
6642}
6643impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
6644 #[allow(deprecated)]
6645 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6646 where
6647 S: serde::Serializer,
6648 {
6649 use serde::ser::SerializeStruct;
6650 let mut len = 0;
6651 if !self.streaming_job_statuses.is_empty() {
6652 len += 1;
6653 }
6654 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
6655 if !self.streaming_job_statuses.is_empty() {
6656 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
6657 }
6658 struct_ser.end()
6659 }
6660}
6661impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
6662 #[allow(deprecated)]
6663 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6664 where
6665 D: serde::Deserializer<'de>,
6666 {
6667 const FIELDS: &[&str] = &[
6668 "streaming_job_statuses",
6669 "streamingJobStatuses",
6670 ];
6671
6672 #[allow(clippy::enum_variant_names)]
6673 enum GeneratedField {
6674 StreamingJobStatuses,
6675 }
6676 impl<'de> serde::Deserialize<'de> for GeneratedField {
6677 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6678 where
6679 D: serde::Deserializer<'de>,
6680 {
6681 struct GeneratedVisitor;
6682
6683 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6684 type Value = GeneratedField;
6685
6686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6687 write!(formatter, "expected one of: {:?}", &FIELDS)
6688 }
6689
6690 #[allow(unused_variables)]
6691 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6692 where
6693 E: serde::de::Error,
6694 {
6695 match value {
6696 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
6697 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6698 }
6699 }
6700 }
6701 deserializer.deserialize_identifier(GeneratedVisitor)
6702 }
6703 }
6704 struct GeneratedVisitor;
6705 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6706 type Value = GetServerlessStreamingJobsStatusResponse;
6707
6708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6709 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
6710 }
6711
6712 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
6713 where
6714 V: serde::de::MapAccess<'de>,
6715 {
6716 let mut streaming_job_statuses__ = None;
6717 while let Some(k) = map_.next_key()? {
6718 match k {
6719 GeneratedField::StreamingJobStatuses => {
6720 if streaming_job_statuses__.is_some() {
6721 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
6722 }
6723 streaming_job_statuses__ = Some(map_.next_value()?);
6724 }
6725 }
6726 }
6727 Ok(GetServerlessStreamingJobsStatusResponse {
6728 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
6729 })
6730 }
6731 }
6732 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
6733 }
6734}
6735impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
6736 #[allow(deprecated)]
6737 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6738 where
6739 S: serde::Serializer,
6740 {
6741 use serde::ser::SerializeStruct;
6742 let mut len = 0;
6743 if self.table_id != 0 {
6744 len += 1;
6745 }
6746 if !self.node_label.is_empty() {
6747 len += 1;
6748 }
6749 if self.backfill_done {
6750 len += 1;
6751 }
6752 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
6753 if self.table_id != 0 {
6754 struct_ser.serialize_field("tableId", &self.table_id)?;
6755 }
6756 if !self.node_label.is_empty() {
6757 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
6758 }
6759 if self.backfill_done {
6760 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
6761 }
6762 struct_ser.end()
6763 }
6764}
6765impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
6766 #[allow(deprecated)]
6767 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6768 where
6769 D: serde::Deserializer<'de>,
6770 {
6771 const FIELDS: &[&str] = &[
6772 "table_id",
6773 "tableId",
6774 "node_label",
6775 "nodeLabel",
6776 "backfill_done",
6777 "backfillDone",
6778 ];
6779
6780 #[allow(clippy::enum_variant_names)]
6781 enum GeneratedField {
6782 TableId,
6783 NodeLabel,
6784 BackfillDone,
6785 }
6786 impl<'de> serde::Deserialize<'de> for GeneratedField {
6787 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6788 where
6789 D: serde::Deserializer<'de>,
6790 {
6791 struct GeneratedVisitor;
6792
6793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6794 type Value = GeneratedField;
6795
6796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6797 write!(formatter, "expected one of: {:?}", &FIELDS)
6798 }
6799
6800 #[allow(unused_variables)]
6801 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6802 where
6803 E: serde::de::Error,
6804 {
6805 match value {
6806 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6807 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
6808 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
6809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6810 }
6811 }
6812 }
6813 deserializer.deserialize_identifier(GeneratedVisitor)
6814 }
6815 }
6816 struct GeneratedVisitor;
6817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6818 type Value = get_serverless_streaming_jobs_status_response::Status;
6819
6820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6821 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
6822 }
6823
6824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
6825 where
6826 V: serde::de::MapAccess<'de>,
6827 {
6828 let mut table_id__ = None;
6829 let mut node_label__ = None;
6830 let mut backfill_done__ = None;
6831 while let Some(k) = map_.next_key()? {
6832 match k {
6833 GeneratedField::TableId => {
6834 if table_id__.is_some() {
6835 return Err(serde::de::Error::duplicate_field("tableId"));
6836 }
6837 table_id__ =
6838 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6839 ;
6840 }
6841 GeneratedField::NodeLabel => {
6842 if node_label__.is_some() {
6843 return Err(serde::de::Error::duplicate_field("nodeLabel"));
6844 }
6845 node_label__ = Some(map_.next_value()?);
6846 }
6847 GeneratedField::BackfillDone => {
6848 if backfill_done__.is_some() {
6849 return Err(serde::de::Error::duplicate_field("backfillDone"));
6850 }
6851 backfill_done__ = Some(map_.next_value()?);
6852 }
6853 }
6854 }
6855 Ok(get_serverless_streaming_jobs_status_response::Status {
6856 table_id: table_id__.unwrap_or_default(),
6857 node_label: node_label__.unwrap_or_default(),
6858 backfill_done: backfill_done__.unwrap_or_default(),
6859 })
6860 }
6861 }
6862 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
6863 }
6864}
6865impl serde::Serialize for GetServingVnodeMappingsRequest {
6866 #[allow(deprecated)]
6867 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6868 where
6869 S: serde::Serializer,
6870 {
6871 use serde::ser::SerializeStruct;
6872 let len = 0;
6873 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
6874 struct_ser.end()
6875 }
6876}
6877impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
6878 #[allow(deprecated)]
6879 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6880 where
6881 D: serde::Deserializer<'de>,
6882 {
6883 const FIELDS: &[&str] = &[
6884 ];
6885
6886 #[allow(clippy::enum_variant_names)]
6887 enum GeneratedField {
6888 }
6889 impl<'de> serde::Deserialize<'de> for GeneratedField {
6890 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6891 where
6892 D: serde::Deserializer<'de>,
6893 {
6894 struct GeneratedVisitor;
6895
6896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6897 type Value = GeneratedField;
6898
6899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6900 write!(formatter, "expected one of: {:?}", &FIELDS)
6901 }
6902
6903 #[allow(unused_variables)]
6904 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6905 where
6906 E: serde::de::Error,
6907 {
6908 Err(serde::de::Error::unknown_field(value, FIELDS))
6909 }
6910 }
6911 deserializer.deserialize_identifier(GeneratedVisitor)
6912 }
6913 }
6914 struct GeneratedVisitor;
6915 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6916 type Value = GetServingVnodeMappingsRequest;
6917
6918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6919 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
6920 }
6921
6922 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
6923 where
6924 V: serde::de::MapAccess<'de>,
6925 {
6926 while map_.next_key::<GeneratedField>()?.is_some() {
6927 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6928 }
6929 Ok(GetServingVnodeMappingsRequest {
6930 })
6931 }
6932 }
6933 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
6934 }
6935}
6936impl serde::Serialize for GetServingVnodeMappingsResponse {
6937 #[allow(deprecated)]
6938 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6939 where
6940 S: serde::Serializer,
6941 {
6942 use serde::ser::SerializeStruct;
6943 let mut len = 0;
6944 if !self.fragment_to_table.is_empty() {
6945 len += 1;
6946 }
6947 if !self.worker_slot_mappings.is_empty() {
6948 len += 1;
6949 }
6950 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
6951 if !self.fragment_to_table.is_empty() {
6952 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
6953 }
6954 if !self.worker_slot_mappings.is_empty() {
6955 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
6956 }
6957 struct_ser.end()
6958 }
6959}
6960impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
6961 #[allow(deprecated)]
6962 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6963 where
6964 D: serde::Deserializer<'de>,
6965 {
6966 const FIELDS: &[&str] = &[
6967 "fragment_to_table",
6968 "fragmentToTable",
6969 "worker_slot_mappings",
6970 "workerSlotMappings",
6971 ];
6972
6973 #[allow(clippy::enum_variant_names)]
6974 enum GeneratedField {
6975 FragmentToTable,
6976 WorkerSlotMappings,
6977 }
6978 impl<'de> serde::Deserialize<'de> for GeneratedField {
6979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6980 where
6981 D: serde::Deserializer<'de>,
6982 {
6983 struct GeneratedVisitor;
6984
6985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6986 type Value = GeneratedField;
6987
6988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6989 write!(formatter, "expected one of: {:?}", &FIELDS)
6990 }
6991
6992 #[allow(unused_variables)]
6993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6994 where
6995 E: serde::de::Error,
6996 {
6997 match value {
6998 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
6999 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7000 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7001 }
7002 }
7003 }
7004 deserializer.deserialize_identifier(GeneratedVisitor)
7005 }
7006 }
7007 struct GeneratedVisitor;
7008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7009 type Value = GetServingVnodeMappingsResponse;
7010
7011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7012 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7013 }
7014
7015 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7016 where
7017 V: serde::de::MapAccess<'de>,
7018 {
7019 let mut fragment_to_table__ = None;
7020 let mut worker_slot_mappings__ = None;
7021 while let Some(k) = map_.next_key()? {
7022 match k {
7023 GeneratedField::FragmentToTable => {
7024 if fragment_to_table__.is_some() {
7025 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7026 }
7027 fragment_to_table__ = Some(
7028 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7029 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
7030 );
7031 }
7032 GeneratedField::WorkerSlotMappings => {
7033 if worker_slot_mappings__.is_some() {
7034 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7035 }
7036 worker_slot_mappings__ = Some(map_.next_value()?);
7037 }
7038 }
7039 }
7040 Ok(GetServingVnodeMappingsResponse {
7041 fragment_to_table: fragment_to_table__.unwrap_or_default(),
7042 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7043 })
7044 }
7045 }
7046 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7047 }
7048}
7049impl serde::Serialize for GetSessionParamsRequest {
7050 #[allow(deprecated)]
7051 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7052 where
7053 S: serde::Serializer,
7054 {
7055 use serde::ser::SerializeStruct;
7056 let len = 0;
7057 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7058 struct_ser.end()
7059 }
7060}
7061impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7062 #[allow(deprecated)]
7063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7064 where
7065 D: serde::Deserializer<'de>,
7066 {
7067 const FIELDS: &[&str] = &[
7068 ];
7069
7070 #[allow(clippy::enum_variant_names)]
7071 enum GeneratedField {
7072 }
7073 impl<'de> serde::Deserialize<'de> for GeneratedField {
7074 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7075 where
7076 D: serde::Deserializer<'de>,
7077 {
7078 struct GeneratedVisitor;
7079
7080 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7081 type Value = GeneratedField;
7082
7083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7084 write!(formatter, "expected one of: {:?}", &FIELDS)
7085 }
7086
7087 #[allow(unused_variables)]
7088 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7089 where
7090 E: serde::de::Error,
7091 {
7092 Err(serde::de::Error::unknown_field(value, FIELDS))
7093 }
7094 }
7095 deserializer.deserialize_identifier(GeneratedVisitor)
7096 }
7097 }
7098 struct GeneratedVisitor;
7099 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7100 type Value = GetSessionParamsRequest;
7101
7102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7103 formatter.write_str("struct meta.GetSessionParamsRequest")
7104 }
7105
7106 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
7107 where
7108 V: serde::de::MapAccess<'de>,
7109 {
7110 while map_.next_key::<GeneratedField>()?.is_some() {
7111 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7112 }
7113 Ok(GetSessionParamsRequest {
7114 })
7115 }
7116 }
7117 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
7118 }
7119}
7120impl serde::Serialize for GetSessionParamsResponse {
7121 #[allow(deprecated)]
7122 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7123 where
7124 S: serde::Serializer,
7125 {
7126 use serde::ser::SerializeStruct;
7127 let mut len = 0;
7128 if !self.params.is_empty() {
7129 len += 1;
7130 }
7131 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
7132 if !self.params.is_empty() {
7133 struct_ser.serialize_field("params", &self.params)?;
7134 }
7135 struct_ser.end()
7136 }
7137}
7138impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
7139 #[allow(deprecated)]
7140 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7141 where
7142 D: serde::Deserializer<'de>,
7143 {
7144 const FIELDS: &[&str] = &[
7145 "params",
7146 ];
7147
7148 #[allow(clippy::enum_variant_names)]
7149 enum GeneratedField {
7150 Params,
7151 }
7152 impl<'de> serde::Deserialize<'de> for GeneratedField {
7153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7154 where
7155 D: serde::Deserializer<'de>,
7156 {
7157 struct GeneratedVisitor;
7158
7159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7160 type Value = GeneratedField;
7161
7162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7163 write!(formatter, "expected one of: {:?}", &FIELDS)
7164 }
7165
7166 #[allow(unused_variables)]
7167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7168 where
7169 E: serde::de::Error,
7170 {
7171 match value {
7172 "params" => Ok(GeneratedField::Params),
7173 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7174 }
7175 }
7176 }
7177 deserializer.deserialize_identifier(GeneratedVisitor)
7178 }
7179 }
7180 struct GeneratedVisitor;
7181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7182 type Value = GetSessionParamsResponse;
7183
7184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7185 formatter.write_str("struct meta.GetSessionParamsResponse")
7186 }
7187
7188 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
7189 where
7190 V: serde::de::MapAccess<'de>,
7191 {
7192 let mut params__ = None;
7193 while let Some(k) = map_.next_key()? {
7194 match k {
7195 GeneratedField::Params => {
7196 if params__.is_some() {
7197 return Err(serde::de::Error::duplicate_field("params"));
7198 }
7199 params__ = Some(map_.next_value()?);
7200 }
7201 }
7202 }
7203 Ok(GetSessionParamsResponse {
7204 params: params__.unwrap_or_default(),
7205 })
7206 }
7207 }
7208 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
7209 }
7210}
7211impl serde::Serialize for GetSystemParamsRequest {
7212 #[allow(deprecated)]
7213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7214 where
7215 S: serde::Serializer,
7216 {
7217 use serde::ser::SerializeStruct;
7218 let len = 0;
7219 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
7220 struct_ser.end()
7221 }
7222}
7223impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
7224 #[allow(deprecated)]
7225 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7226 where
7227 D: serde::Deserializer<'de>,
7228 {
7229 const FIELDS: &[&str] = &[
7230 ];
7231
7232 #[allow(clippy::enum_variant_names)]
7233 enum GeneratedField {
7234 }
7235 impl<'de> serde::Deserialize<'de> for GeneratedField {
7236 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7237 where
7238 D: serde::Deserializer<'de>,
7239 {
7240 struct GeneratedVisitor;
7241
7242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7243 type Value = GeneratedField;
7244
7245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7246 write!(formatter, "expected one of: {:?}", &FIELDS)
7247 }
7248
7249 #[allow(unused_variables)]
7250 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7251 where
7252 E: serde::de::Error,
7253 {
7254 Err(serde::de::Error::unknown_field(value, FIELDS))
7255 }
7256 }
7257 deserializer.deserialize_identifier(GeneratedVisitor)
7258 }
7259 }
7260 struct GeneratedVisitor;
7261 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7262 type Value = GetSystemParamsRequest;
7263
7264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7265 formatter.write_str("struct meta.GetSystemParamsRequest")
7266 }
7267
7268 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
7269 where
7270 V: serde::de::MapAccess<'de>,
7271 {
7272 while map_.next_key::<GeneratedField>()?.is_some() {
7273 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7274 }
7275 Ok(GetSystemParamsRequest {
7276 })
7277 }
7278 }
7279 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
7280 }
7281}
7282impl serde::Serialize for GetSystemParamsResponse {
7283 #[allow(deprecated)]
7284 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7285 where
7286 S: serde::Serializer,
7287 {
7288 use serde::ser::SerializeStruct;
7289 let mut len = 0;
7290 if self.params.is_some() {
7291 len += 1;
7292 }
7293 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
7294 if let Some(v) = self.params.as_ref() {
7295 struct_ser.serialize_field("params", v)?;
7296 }
7297 struct_ser.end()
7298 }
7299}
7300impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
7301 #[allow(deprecated)]
7302 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7303 where
7304 D: serde::Deserializer<'de>,
7305 {
7306 const FIELDS: &[&str] = &[
7307 "params",
7308 ];
7309
7310 #[allow(clippy::enum_variant_names)]
7311 enum GeneratedField {
7312 Params,
7313 }
7314 impl<'de> serde::Deserialize<'de> for GeneratedField {
7315 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7316 where
7317 D: serde::Deserializer<'de>,
7318 {
7319 struct GeneratedVisitor;
7320
7321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7322 type Value = GeneratedField;
7323
7324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7325 write!(formatter, "expected one of: {:?}", &FIELDS)
7326 }
7327
7328 #[allow(unused_variables)]
7329 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7330 where
7331 E: serde::de::Error,
7332 {
7333 match value {
7334 "params" => Ok(GeneratedField::Params),
7335 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7336 }
7337 }
7338 }
7339 deserializer.deserialize_identifier(GeneratedVisitor)
7340 }
7341 }
7342 struct GeneratedVisitor;
7343 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7344 type Value = GetSystemParamsResponse;
7345
7346 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7347 formatter.write_str("struct meta.GetSystemParamsResponse")
7348 }
7349
7350 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
7351 where
7352 V: serde::de::MapAccess<'de>,
7353 {
7354 let mut params__ = None;
7355 while let Some(k) = map_.next_key()? {
7356 match k {
7357 GeneratedField::Params => {
7358 if params__.is_some() {
7359 return Err(serde::de::Error::duplicate_field("params"));
7360 }
7361 params__ = map_.next_value()?;
7362 }
7363 }
7364 }
7365 Ok(GetSystemParamsResponse {
7366 params: params__,
7367 })
7368 }
7369 }
7370 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
7371 }
7372}
7373impl serde::Serialize for GetTelemetryInfoRequest {
7374 #[allow(deprecated)]
7375 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7376 where
7377 S: serde::Serializer,
7378 {
7379 use serde::ser::SerializeStruct;
7380 let len = 0;
7381 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
7382 struct_ser.end()
7383 }
7384}
7385impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
7386 #[allow(deprecated)]
7387 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7388 where
7389 D: serde::Deserializer<'de>,
7390 {
7391 const FIELDS: &[&str] = &[
7392 ];
7393
7394 #[allow(clippy::enum_variant_names)]
7395 enum GeneratedField {
7396 }
7397 impl<'de> serde::Deserialize<'de> for GeneratedField {
7398 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7399 where
7400 D: serde::Deserializer<'de>,
7401 {
7402 struct GeneratedVisitor;
7403
7404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7405 type Value = GeneratedField;
7406
7407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7408 write!(formatter, "expected one of: {:?}", &FIELDS)
7409 }
7410
7411 #[allow(unused_variables)]
7412 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7413 where
7414 E: serde::de::Error,
7415 {
7416 Err(serde::de::Error::unknown_field(value, FIELDS))
7417 }
7418 }
7419 deserializer.deserialize_identifier(GeneratedVisitor)
7420 }
7421 }
7422 struct GeneratedVisitor;
7423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7424 type Value = GetTelemetryInfoRequest;
7425
7426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7427 formatter.write_str("struct meta.GetTelemetryInfoRequest")
7428 }
7429
7430 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
7431 where
7432 V: serde::de::MapAccess<'de>,
7433 {
7434 while map_.next_key::<GeneratedField>()?.is_some() {
7435 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7436 }
7437 Ok(GetTelemetryInfoRequest {
7438 })
7439 }
7440 }
7441 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
7442 }
7443}
7444impl serde::Serialize for HeartbeatRequest {
7445 #[allow(deprecated)]
7446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7447 where
7448 S: serde::Serializer,
7449 {
7450 use serde::ser::SerializeStruct;
7451 let mut len = 0;
7452 if self.node_id != 0 {
7453 len += 1;
7454 }
7455 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
7456 if self.node_id != 0 {
7457 struct_ser.serialize_field("nodeId", &self.node_id)?;
7458 }
7459 struct_ser.end()
7460 }
7461}
7462impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
7463 #[allow(deprecated)]
7464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7465 where
7466 D: serde::Deserializer<'de>,
7467 {
7468 const FIELDS: &[&str] = &[
7469 "node_id",
7470 "nodeId",
7471 ];
7472
7473 #[allow(clippy::enum_variant_names)]
7474 enum GeneratedField {
7475 NodeId,
7476 }
7477 impl<'de> serde::Deserialize<'de> for GeneratedField {
7478 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7479 where
7480 D: serde::Deserializer<'de>,
7481 {
7482 struct GeneratedVisitor;
7483
7484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7485 type Value = GeneratedField;
7486
7487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7488 write!(formatter, "expected one of: {:?}", &FIELDS)
7489 }
7490
7491 #[allow(unused_variables)]
7492 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7493 where
7494 E: serde::de::Error,
7495 {
7496 match value {
7497 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
7498 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7499 }
7500 }
7501 }
7502 deserializer.deserialize_identifier(GeneratedVisitor)
7503 }
7504 }
7505 struct GeneratedVisitor;
7506 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7507 type Value = HeartbeatRequest;
7508
7509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7510 formatter.write_str("struct meta.HeartbeatRequest")
7511 }
7512
7513 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
7514 where
7515 V: serde::de::MapAccess<'de>,
7516 {
7517 let mut node_id__ = None;
7518 while let Some(k) = map_.next_key()? {
7519 match k {
7520 GeneratedField::NodeId => {
7521 if node_id__.is_some() {
7522 return Err(serde::de::Error::duplicate_field("nodeId"));
7523 }
7524 node_id__ =
7525 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7526 ;
7527 }
7528 }
7529 }
7530 Ok(HeartbeatRequest {
7531 node_id: node_id__.unwrap_or_default(),
7532 })
7533 }
7534 }
7535 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
7536 }
7537}
7538impl serde::Serialize for HeartbeatResponse {
7539 #[allow(deprecated)]
7540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7541 where
7542 S: serde::Serializer,
7543 {
7544 use serde::ser::SerializeStruct;
7545 let mut len = 0;
7546 if self.status.is_some() {
7547 len += 1;
7548 }
7549 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
7550 if let Some(v) = self.status.as_ref() {
7551 struct_ser.serialize_field("status", v)?;
7552 }
7553 struct_ser.end()
7554 }
7555}
7556impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
7557 #[allow(deprecated)]
7558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7559 where
7560 D: serde::Deserializer<'de>,
7561 {
7562 const FIELDS: &[&str] = &[
7563 "status",
7564 ];
7565
7566 #[allow(clippy::enum_variant_names)]
7567 enum GeneratedField {
7568 Status,
7569 }
7570 impl<'de> serde::Deserialize<'de> for GeneratedField {
7571 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7572 where
7573 D: serde::Deserializer<'de>,
7574 {
7575 struct GeneratedVisitor;
7576
7577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7578 type Value = GeneratedField;
7579
7580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7581 write!(formatter, "expected one of: {:?}", &FIELDS)
7582 }
7583
7584 #[allow(unused_variables)]
7585 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7586 where
7587 E: serde::de::Error,
7588 {
7589 match value {
7590 "status" => Ok(GeneratedField::Status),
7591 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7592 }
7593 }
7594 }
7595 deserializer.deserialize_identifier(GeneratedVisitor)
7596 }
7597 }
7598 struct GeneratedVisitor;
7599 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7600 type Value = HeartbeatResponse;
7601
7602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7603 formatter.write_str("struct meta.HeartbeatResponse")
7604 }
7605
7606 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
7607 where
7608 V: serde::de::MapAccess<'de>,
7609 {
7610 let mut status__ = None;
7611 while let Some(k) = map_.next_key()? {
7612 match k {
7613 GeneratedField::Status => {
7614 if status__.is_some() {
7615 return Err(serde::de::Error::duplicate_field("status"));
7616 }
7617 status__ = map_.next_value()?;
7618 }
7619 }
7620 }
7621 Ok(HeartbeatResponse {
7622 status: status__,
7623 })
7624 }
7625 }
7626 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
7627 }
7628}
7629impl serde::Serialize for ListActorSplitsRequest {
7630 #[allow(deprecated)]
7631 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7632 where
7633 S: serde::Serializer,
7634 {
7635 use serde::ser::SerializeStruct;
7636 let len = 0;
7637 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
7638 struct_ser.end()
7639 }
7640}
7641impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
7642 #[allow(deprecated)]
7643 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7644 where
7645 D: serde::Deserializer<'de>,
7646 {
7647 const FIELDS: &[&str] = &[
7648 ];
7649
7650 #[allow(clippy::enum_variant_names)]
7651 enum GeneratedField {
7652 }
7653 impl<'de> serde::Deserialize<'de> for GeneratedField {
7654 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7655 where
7656 D: serde::Deserializer<'de>,
7657 {
7658 struct GeneratedVisitor;
7659
7660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7661 type Value = GeneratedField;
7662
7663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7664 write!(formatter, "expected one of: {:?}", &FIELDS)
7665 }
7666
7667 #[allow(unused_variables)]
7668 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7669 where
7670 E: serde::de::Error,
7671 {
7672 Err(serde::de::Error::unknown_field(value, FIELDS))
7673 }
7674 }
7675 deserializer.deserialize_identifier(GeneratedVisitor)
7676 }
7677 }
7678 struct GeneratedVisitor;
7679 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7680 type Value = ListActorSplitsRequest;
7681
7682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7683 formatter.write_str("struct meta.ListActorSplitsRequest")
7684 }
7685
7686 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
7687 where
7688 V: serde::de::MapAccess<'de>,
7689 {
7690 while map_.next_key::<GeneratedField>()?.is_some() {
7691 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7692 }
7693 Ok(ListActorSplitsRequest {
7694 })
7695 }
7696 }
7697 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
7698 }
7699}
7700impl serde::Serialize for ListActorSplitsResponse {
7701 #[allow(deprecated)]
7702 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7703 where
7704 S: serde::Serializer,
7705 {
7706 use serde::ser::SerializeStruct;
7707 let mut len = 0;
7708 if !self.actor_splits.is_empty() {
7709 len += 1;
7710 }
7711 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
7712 if !self.actor_splits.is_empty() {
7713 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
7714 }
7715 struct_ser.end()
7716 }
7717}
7718impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
7719 #[allow(deprecated)]
7720 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7721 where
7722 D: serde::Deserializer<'de>,
7723 {
7724 const FIELDS: &[&str] = &[
7725 "actor_splits",
7726 "actorSplits",
7727 ];
7728
7729 #[allow(clippy::enum_variant_names)]
7730 enum GeneratedField {
7731 ActorSplits,
7732 }
7733 impl<'de> serde::Deserialize<'de> for GeneratedField {
7734 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7735 where
7736 D: serde::Deserializer<'de>,
7737 {
7738 struct GeneratedVisitor;
7739
7740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7741 type Value = GeneratedField;
7742
7743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7744 write!(formatter, "expected one of: {:?}", &FIELDS)
7745 }
7746
7747 #[allow(unused_variables)]
7748 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7749 where
7750 E: serde::de::Error,
7751 {
7752 match value {
7753 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
7754 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7755 }
7756 }
7757 }
7758 deserializer.deserialize_identifier(GeneratedVisitor)
7759 }
7760 }
7761 struct GeneratedVisitor;
7762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7763 type Value = ListActorSplitsResponse;
7764
7765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7766 formatter.write_str("struct meta.ListActorSplitsResponse")
7767 }
7768
7769 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
7770 where
7771 V: serde::de::MapAccess<'de>,
7772 {
7773 let mut actor_splits__ = None;
7774 while let Some(k) = map_.next_key()? {
7775 match k {
7776 GeneratedField::ActorSplits => {
7777 if actor_splits__.is_some() {
7778 return Err(serde::de::Error::duplicate_field("actorSplits"));
7779 }
7780 actor_splits__ = Some(map_.next_value()?);
7781 }
7782 }
7783 }
7784 Ok(ListActorSplitsResponse {
7785 actor_splits: actor_splits__.unwrap_or_default(),
7786 })
7787 }
7788 }
7789 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
7790 }
7791}
7792impl serde::Serialize for list_actor_splits_response::ActorSplit {
7793 #[allow(deprecated)]
7794 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7795 where
7796 S: serde::Serializer,
7797 {
7798 use serde::ser::SerializeStruct;
7799 let mut len = 0;
7800 if self.actor_id != 0 {
7801 len += 1;
7802 }
7803 if self.fragment_id != 0 {
7804 len += 1;
7805 }
7806 if self.source_id != 0 {
7807 len += 1;
7808 }
7809 if !self.split_id.is_empty() {
7810 len += 1;
7811 }
7812 if self.fragment_type != 0 {
7813 len += 1;
7814 }
7815 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
7816 if self.actor_id != 0 {
7817 struct_ser.serialize_field("actorId", &self.actor_id)?;
7818 }
7819 if self.fragment_id != 0 {
7820 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7821 }
7822 if self.source_id != 0 {
7823 struct_ser.serialize_field("sourceId", &self.source_id)?;
7824 }
7825 if !self.split_id.is_empty() {
7826 struct_ser.serialize_field("splitId", &self.split_id)?;
7827 }
7828 if self.fragment_type != 0 {
7829 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
7830 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
7831 struct_ser.serialize_field("fragmentType", &v)?;
7832 }
7833 struct_ser.end()
7834 }
7835}
7836impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
7837 #[allow(deprecated)]
7838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7839 where
7840 D: serde::Deserializer<'de>,
7841 {
7842 const FIELDS: &[&str] = &[
7843 "actor_id",
7844 "actorId",
7845 "fragment_id",
7846 "fragmentId",
7847 "source_id",
7848 "sourceId",
7849 "split_id",
7850 "splitId",
7851 "fragment_type",
7852 "fragmentType",
7853 ];
7854
7855 #[allow(clippy::enum_variant_names)]
7856 enum GeneratedField {
7857 ActorId,
7858 FragmentId,
7859 SourceId,
7860 SplitId,
7861 FragmentType,
7862 }
7863 impl<'de> serde::Deserialize<'de> for GeneratedField {
7864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7865 where
7866 D: serde::Deserializer<'de>,
7867 {
7868 struct GeneratedVisitor;
7869
7870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7871 type Value = GeneratedField;
7872
7873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7874 write!(formatter, "expected one of: {:?}", &FIELDS)
7875 }
7876
7877 #[allow(unused_variables)]
7878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7879 where
7880 E: serde::de::Error,
7881 {
7882 match value {
7883 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7884 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7885 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7886 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
7887 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
7888 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7889 }
7890 }
7891 }
7892 deserializer.deserialize_identifier(GeneratedVisitor)
7893 }
7894 }
7895 struct GeneratedVisitor;
7896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7897 type Value = list_actor_splits_response::ActorSplit;
7898
7899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7900 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
7901 }
7902
7903 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
7904 where
7905 V: serde::de::MapAccess<'de>,
7906 {
7907 let mut actor_id__ = None;
7908 let mut fragment_id__ = None;
7909 let mut source_id__ = None;
7910 let mut split_id__ = None;
7911 let mut fragment_type__ = None;
7912 while let Some(k) = map_.next_key()? {
7913 match k {
7914 GeneratedField::ActorId => {
7915 if actor_id__.is_some() {
7916 return Err(serde::de::Error::duplicate_field("actorId"));
7917 }
7918 actor_id__ =
7919 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7920 ;
7921 }
7922 GeneratedField::FragmentId => {
7923 if fragment_id__.is_some() {
7924 return Err(serde::de::Error::duplicate_field("fragmentId"));
7925 }
7926 fragment_id__ =
7927 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7928 ;
7929 }
7930 GeneratedField::SourceId => {
7931 if source_id__.is_some() {
7932 return Err(serde::de::Error::duplicate_field("sourceId"));
7933 }
7934 source_id__ =
7935 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7936 ;
7937 }
7938 GeneratedField::SplitId => {
7939 if split_id__.is_some() {
7940 return Err(serde::de::Error::duplicate_field("splitId"));
7941 }
7942 split_id__ = Some(map_.next_value()?);
7943 }
7944 GeneratedField::FragmentType => {
7945 if fragment_type__.is_some() {
7946 return Err(serde::de::Error::duplicate_field("fragmentType"));
7947 }
7948 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
7949 }
7950 }
7951 }
7952 Ok(list_actor_splits_response::ActorSplit {
7953 actor_id: actor_id__.unwrap_or_default(),
7954 fragment_id: fragment_id__.unwrap_or_default(),
7955 source_id: source_id__.unwrap_or_default(),
7956 split_id: split_id__.unwrap_or_default(),
7957 fragment_type: fragment_type__.unwrap_or_default(),
7958 })
7959 }
7960 }
7961 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
7962 }
7963}
7964impl serde::Serialize for list_actor_splits_response::FragmentType {
7965 #[allow(deprecated)]
7966 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7967 where
7968 S: serde::Serializer,
7969 {
7970 let variant = match self {
7971 Self::Unspecified => "UNSPECIFIED",
7972 Self::NonSharedSource => "NON_SHARED_SOURCE",
7973 Self::SharedSource => "SHARED_SOURCE",
7974 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
7975 };
7976 serializer.serialize_str(variant)
7977 }
7978}
7979impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
7980 #[allow(deprecated)]
7981 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7982 where
7983 D: serde::Deserializer<'de>,
7984 {
7985 const FIELDS: &[&str] = &[
7986 "UNSPECIFIED",
7987 "NON_SHARED_SOURCE",
7988 "SHARED_SOURCE",
7989 "SHARED_SOURCE_BACKFILL",
7990 ];
7991
7992 struct GeneratedVisitor;
7993
7994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7995 type Value = list_actor_splits_response::FragmentType;
7996
7997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7998 write!(formatter, "expected one of: {:?}", &FIELDS)
7999 }
8000
8001 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8002 where
8003 E: serde::de::Error,
8004 {
8005 i32::try_from(v)
8006 .ok()
8007 .and_then(|x| x.try_into().ok())
8008 .ok_or_else(|| {
8009 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8010 })
8011 }
8012
8013 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8014 where
8015 E: serde::de::Error,
8016 {
8017 i32::try_from(v)
8018 .ok()
8019 .and_then(|x| x.try_into().ok())
8020 .ok_or_else(|| {
8021 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8022 })
8023 }
8024
8025 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8026 where
8027 E: serde::de::Error,
8028 {
8029 match value {
8030 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
8031 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
8032 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
8033 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
8034 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8035 }
8036 }
8037 }
8038 deserializer.deserialize_any(GeneratedVisitor)
8039 }
8040}
8041impl serde::Serialize for ListActorStatesRequest {
8042 #[allow(deprecated)]
8043 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8044 where
8045 S: serde::Serializer,
8046 {
8047 use serde::ser::SerializeStruct;
8048 let len = 0;
8049 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
8050 struct_ser.end()
8051 }
8052}
8053impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
8054 #[allow(deprecated)]
8055 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8056 where
8057 D: serde::Deserializer<'de>,
8058 {
8059 const FIELDS: &[&str] = &[
8060 ];
8061
8062 #[allow(clippy::enum_variant_names)]
8063 enum GeneratedField {
8064 }
8065 impl<'de> serde::Deserialize<'de> for GeneratedField {
8066 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8067 where
8068 D: serde::Deserializer<'de>,
8069 {
8070 struct GeneratedVisitor;
8071
8072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8073 type Value = GeneratedField;
8074
8075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8076 write!(formatter, "expected one of: {:?}", &FIELDS)
8077 }
8078
8079 #[allow(unused_variables)]
8080 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8081 where
8082 E: serde::de::Error,
8083 {
8084 Err(serde::de::Error::unknown_field(value, FIELDS))
8085 }
8086 }
8087 deserializer.deserialize_identifier(GeneratedVisitor)
8088 }
8089 }
8090 struct GeneratedVisitor;
8091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8092 type Value = ListActorStatesRequest;
8093
8094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8095 formatter.write_str("struct meta.ListActorStatesRequest")
8096 }
8097
8098 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
8099 where
8100 V: serde::de::MapAccess<'de>,
8101 {
8102 while map_.next_key::<GeneratedField>()?.is_some() {
8103 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8104 }
8105 Ok(ListActorStatesRequest {
8106 })
8107 }
8108 }
8109 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
8110 }
8111}
8112impl serde::Serialize for ListActorStatesResponse {
8113 #[allow(deprecated)]
8114 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8115 where
8116 S: serde::Serializer,
8117 {
8118 use serde::ser::SerializeStruct;
8119 let mut len = 0;
8120 if !self.states.is_empty() {
8121 len += 1;
8122 }
8123 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
8124 if !self.states.is_empty() {
8125 struct_ser.serialize_field("states", &self.states)?;
8126 }
8127 struct_ser.end()
8128 }
8129}
8130impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
8131 #[allow(deprecated)]
8132 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8133 where
8134 D: serde::Deserializer<'de>,
8135 {
8136 const FIELDS: &[&str] = &[
8137 "states",
8138 ];
8139
8140 #[allow(clippy::enum_variant_names)]
8141 enum GeneratedField {
8142 States,
8143 }
8144 impl<'de> serde::Deserialize<'de> for GeneratedField {
8145 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8146 where
8147 D: serde::Deserializer<'de>,
8148 {
8149 struct GeneratedVisitor;
8150
8151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8152 type Value = GeneratedField;
8153
8154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8155 write!(formatter, "expected one of: {:?}", &FIELDS)
8156 }
8157
8158 #[allow(unused_variables)]
8159 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8160 where
8161 E: serde::de::Error,
8162 {
8163 match value {
8164 "states" => Ok(GeneratedField::States),
8165 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8166 }
8167 }
8168 }
8169 deserializer.deserialize_identifier(GeneratedVisitor)
8170 }
8171 }
8172 struct GeneratedVisitor;
8173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8174 type Value = ListActorStatesResponse;
8175
8176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8177 formatter.write_str("struct meta.ListActorStatesResponse")
8178 }
8179
8180 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
8181 where
8182 V: serde::de::MapAccess<'de>,
8183 {
8184 let mut states__ = None;
8185 while let Some(k) = map_.next_key()? {
8186 match k {
8187 GeneratedField::States => {
8188 if states__.is_some() {
8189 return Err(serde::de::Error::duplicate_field("states"));
8190 }
8191 states__ = Some(map_.next_value()?);
8192 }
8193 }
8194 }
8195 Ok(ListActorStatesResponse {
8196 states: states__.unwrap_or_default(),
8197 })
8198 }
8199 }
8200 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
8201 }
8202}
8203impl serde::Serialize for list_actor_states_response::ActorState {
8204 #[allow(deprecated)]
8205 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8206 where
8207 S: serde::Serializer,
8208 {
8209 use serde::ser::SerializeStruct;
8210 let mut len = 0;
8211 if self.actor_id != 0 {
8212 len += 1;
8213 }
8214 if self.fragment_id != 0 {
8215 len += 1;
8216 }
8217 if self.state != 0 {
8218 len += 1;
8219 }
8220 if self.worker_id != 0 {
8221 len += 1;
8222 }
8223 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
8224 if self.actor_id != 0 {
8225 struct_ser.serialize_field("actorId", &self.actor_id)?;
8226 }
8227 if self.fragment_id != 0 {
8228 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8229 }
8230 if self.state != 0 {
8231 let v = table_fragments::actor_status::ActorState::try_from(self.state)
8232 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
8233 struct_ser.serialize_field("state", &v)?;
8234 }
8235 if self.worker_id != 0 {
8236 struct_ser.serialize_field("workerId", &self.worker_id)?;
8237 }
8238 struct_ser.end()
8239 }
8240}
8241impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
8242 #[allow(deprecated)]
8243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8244 where
8245 D: serde::Deserializer<'de>,
8246 {
8247 const FIELDS: &[&str] = &[
8248 "actor_id",
8249 "actorId",
8250 "fragment_id",
8251 "fragmentId",
8252 "state",
8253 "worker_id",
8254 "workerId",
8255 ];
8256
8257 #[allow(clippy::enum_variant_names)]
8258 enum GeneratedField {
8259 ActorId,
8260 FragmentId,
8261 State,
8262 WorkerId,
8263 }
8264 impl<'de> serde::Deserialize<'de> for GeneratedField {
8265 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8266 where
8267 D: serde::Deserializer<'de>,
8268 {
8269 struct GeneratedVisitor;
8270
8271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8272 type Value = GeneratedField;
8273
8274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8275 write!(formatter, "expected one of: {:?}", &FIELDS)
8276 }
8277
8278 #[allow(unused_variables)]
8279 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8280 where
8281 E: serde::de::Error,
8282 {
8283 match value {
8284 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8285 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8286 "state" => Ok(GeneratedField::State),
8287 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
8288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8289 }
8290 }
8291 }
8292 deserializer.deserialize_identifier(GeneratedVisitor)
8293 }
8294 }
8295 struct GeneratedVisitor;
8296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8297 type Value = list_actor_states_response::ActorState;
8298
8299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8300 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
8301 }
8302
8303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
8304 where
8305 V: serde::de::MapAccess<'de>,
8306 {
8307 let mut actor_id__ = None;
8308 let mut fragment_id__ = None;
8309 let mut state__ = None;
8310 let mut worker_id__ = None;
8311 while let Some(k) = map_.next_key()? {
8312 match k {
8313 GeneratedField::ActorId => {
8314 if actor_id__.is_some() {
8315 return Err(serde::de::Error::duplicate_field("actorId"));
8316 }
8317 actor_id__ =
8318 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8319 ;
8320 }
8321 GeneratedField::FragmentId => {
8322 if fragment_id__.is_some() {
8323 return Err(serde::de::Error::duplicate_field("fragmentId"));
8324 }
8325 fragment_id__ =
8326 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8327 ;
8328 }
8329 GeneratedField::State => {
8330 if state__.is_some() {
8331 return Err(serde::de::Error::duplicate_field("state"));
8332 }
8333 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
8334 }
8335 GeneratedField::WorkerId => {
8336 if worker_id__.is_some() {
8337 return Err(serde::de::Error::duplicate_field("workerId"));
8338 }
8339 worker_id__ =
8340 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8341 ;
8342 }
8343 }
8344 }
8345 Ok(list_actor_states_response::ActorState {
8346 actor_id: actor_id__.unwrap_or_default(),
8347 fragment_id: fragment_id__.unwrap_or_default(),
8348 state: state__.unwrap_or_default(),
8349 worker_id: worker_id__.unwrap_or_default(),
8350 })
8351 }
8352 }
8353 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
8354 }
8355}
8356impl serde::Serialize for ListAllNodesRequest {
8357 #[allow(deprecated)]
8358 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8359 where
8360 S: serde::Serializer,
8361 {
8362 use serde::ser::SerializeStruct;
8363 let mut len = 0;
8364 if self.worker_type.is_some() {
8365 len += 1;
8366 }
8367 if self.include_starting_nodes {
8368 len += 1;
8369 }
8370 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
8371 if let Some(v) = self.worker_type.as_ref() {
8372 let v = super::common::WorkerType::try_from(*v)
8373 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
8374 struct_ser.serialize_field("workerType", &v)?;
8375 }
8376 if self.include_starting_nodes {
8377 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
8378 }
8379 struct_ser.end()
8380 }
8381}
8382impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
8383 #[allow(deprecated)]
8384 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8385 where
8386 D: serde::Deserializer<'de>,
8387 {
8388 const FIELDS: &[&str] = &[
8389 "worker_type",
8390 "workerType",
8391 "include_starting_nodes",
8392 "includeStartingNodes",
8393 ];
8394
8395 #[allow(clippy::enum_variant_names)]
8396 enum GeneratedField {
8397 WorkerType,
8398 IncludeStartingNodes,
8399 }
8400 impl<'de> serde::Deserialize<'de> for GeneratedField {
8401 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8402 where
8403 D: serde::Deserializer<'de>,
8404 {
8405 struct GeneratedVisitor;
8406
8407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8408 type Value = GeneratedField;
8409
8410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8411 write!(formatter, "expected one of: {:?}", &FIELDS)
8412 }
8413
8414 #[allow(unused_variables)]
8415 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8416 where
8417 E: serde::de::Error,
8418 {
8419 match value {
8420 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
8421 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
8422 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8423 }
8424 }
8425 }
8426 deserializer.deserialize_identifier(GeneratedVisitor)
8427 }
8428 }
8429 struct GeneratedVisitor;
8430 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8431 type Value = ListAllNodesRequest;
8432
8433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8434 formatter.write_str("struct meta.ListAllNodesRequest")
8435 }
8436
8437 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
8438 where
8439 V: serde::de::MapAccess<'de>,
8440 {
8441 let mut worker_type__ = None;
8442 let mut include_starting_nodes__ = None;
8443 while let Some(k) = map_.next_key()? {
8444 match k {
8445 GeneratedField::WorkerType => {
8446 if worker_type__.is_some() {
8447 return Err(serde::de::Error::duplicate_field("workerType"));
8448 }
8449 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
8450 }
8451 GeneratedField::IncludeStartingNodes => {
8452 if include_starting_nodes__.is_some() {
8453 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
8454 }
8455 include_starting_nodes__ = Some(map_.next_value()?);
8456 }
8457 }
8458 }
8459 Ok(ListAllNodesRequest {
8460 worker_type: worker_type__,
8461 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
8462 })
8463 }
8464 }
8465 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
8466 }
8467}
8468impl serde::Serialize for ListAllNodesResponse {
8469 #[allow(deprecated)]
8470 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8471 where
8472 S: serde::Serializer,
8473 {
8474 use serde::ser::SerializeStruct;
8475 let mut len = 0;
8476 if self.status.is_some() {
8477 len += 1;
8478 }
8479 if !self.nodes.is_empty() {
8480 len += 1;
8481 }
8482 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
8483 if let Some(v) = self.status.as_ref() {
8484 struct_ser.serialize_field("status", v)?;
8485 }
8486 if !self.nodes.is_empty() {
8487 struct_ser.serialize_field("nodes", &self.nodes)?;
8488 }
8489 struct_ser.end()
8490 }
8491}
8492impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
8493 #[allow(deprecated)]
8494 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8495 where
8496 D: serde::Deserializer<'de>,
8497 {
8498 const FIELDS: &[&str] = &[
8499 "status",
8500 "nodes",
8501 ];
8502
8503 #[allow(clippy::enum_variant_names)]
8504 enum GeneratedField {
8505 Status,
8506 Nodes,
8507 }
8508 impl<'de> serde::Deserialize<'de> for GeneratedField {
8509 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8510 where
8511 D: serde::Deserializer<'de>,
8512 {
8513 struct GeneratedVisitor;
8514
8515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8516 type Value = GeneratedField;
8517
8518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8519 write!(formatter, "expected one of: {:?}", &FIELDS)
8520 }
8521
8522 #[allow(unused_variables)]
8523 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8524 where
8525 E: serde::de::Error,
8526 {
8527 match value {
8528 "status" => Ok(GeneratedField::Status),
8529 "nodes" => Ok(GeneratedField::Nodes),
8530 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8531 }
8532 }
8533 }
8534 deserializer.deserialize_identifier(GeneratedVisitor)
8535 }
8536 }
8537 struct GeneratedVisitor;
8538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8539 type Value = ListAllNodesResponse;
8540
8541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8542 formatter.write_str("struct meta.ListAllNodesResponse")
8543 }
8544
8545 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
8546 where
8547 V: serde::de::MapAccess<'de>,
8548 {
8549 let mut status__ = None;
8550 let mut nodes__ = None;
8551 while let Some(k) = map_.next_key()? {
8552 match k {
8553 GeneratedField::Status => {
8554 if status__.is_some() {
8555 return Err(serde::de::Error::duplicate_field("status"));
8556 }
8557 status__ = map_.next_value()?;
8558 }
8559 GeneratedField::Nodes => {
8560 if nodes__.is_some() {
8561 return Err(serde::de::Error::duplicate_field("nodes"));
8562 }
8563 nodes__ = Some(map_.next_value()?);
8564 }
8565 }
8566 }
8567 Ok(ListAllNodesResponse {
8568 status: status__,
8569 nodes: nodes__.unwrap_or_default(),
8570 })
8571 }
8572 }
8573 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
8574 }
8575}
8576impl serde::Serialize for ListCreatingFragmentDistributionRequest {
8577 #[allow(deprecated)]
8578 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8579 where
8580 S: serde::Serializer,
8581 {
8582 use serde::ser::SerializeStruct;
8583 let len = 0;
8584 let struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
8585 struct_ser.end()
8586 }
8587}
8588impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
8589 #[allow(deprecated)]
8590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8591 where
8592 D: serde::Deserializer<'de>,
8593 {
8594 const FIELDS: &[&str] = &[
8595 ];
8596
8597 #[allow(clippy::enum_variant_names)]
8598 enum GeneratedField {
8599 }
8600 impl<'de> serde::Deserialize<'de> for GeneratedField {
8601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8602 where
8603 D: serde::Deserializer<'de>,
8604 {
8605 struct GeneratedVisitor;
8606
8607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8608 type Value = GeneratedField;
8609
8610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8611 write!(formatter, "expected one of: {:?}", &FIELDS)
8612 }
8613
8614 #[allow(unused_variables)]
8615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8616 where
8617 E: serde::de::Error,
8618 {
8619 Err(serde::de::Error::unknown_field(value, FIELDS))
8620 }
8621 }
8622 deserializer.deserialize_identifier(GeneratedVisitor)
8623 }
8624 }
8625 struct GeneratedVisitor;
8626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8627 type Value = ListCreatingFragmentDistributionRequest;
8628
8629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8630 formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
8631 }
8632
8633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
8634 where
8635 V: serde::de::MapAccess<'de>,
8636 {
8637 while map_.next_key::<GeneratedField>()?.is_some() {
8638 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8639 }
8640 Ok(ListCreatingFragmentDistributionRequest {
8641 })
8642 }
8643 }
8644 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
8645 }
8646}
8647impl serde::Serialize for ListCreatingFragmentDistributionResponse {
8648 #[allow(deprecated)]
8649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8650 where
8651 S: serde::Serializer,
8652 {
8653 use serde::ser::SerializeStruct;
8654 let mut len = 0;
8655 if !self.distributions.is_empty() {
8656 len += 1;
8657 }
8658 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
8659 if !self.distributions.is_empty() {
8660 struct_ser.serialize_field("distributions", &self.distributions)?;
8661 }
8662 struct_ser.end()
8663 }
8664}
8665impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
8666 #[allow(deprecated)]
8667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8668 where
8669 D: serde::Deserializer<'de>,
8670 {
8671 const FIELDS: &[&str] = &[
8672 "distributions",
8673 ];
8674
8675 #[allow(clippy::enum_variant_names)]
8676 enum GeneratedField {
8677 Distributions,
8678 }
8679 impl<'de> serde::Deserialize<'de> for GeneratedField {
8680 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8681 where
8682 D: serde::Deserializer<'de>,
8683 {
8684 struct GeneratedVisitor;
8685
8686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8687 type Value = GeneratedField;
8688
8689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8690 write!(formatter, "expected one of: {:?}", &FIELDS)
8691 }
8692
8693 #[allow(unused_variables)]
8694 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8695 where
8696 E: serde::de::Error,
8697 {
8698 match value {
8699 "distributions" => Ok(GeneratedField::Distributions),
8700 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8701 }
8702 }
8703 }
8704 deserializer.deserialize_identifier(GeneratedVisitor)
8705 }
8706 }
8707 struct GeneratedVisitor;
8708 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8709 type Value = ListCreatingFragmentDistributionResponse;
8710
8711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8712 formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
8713 }
8714
8715 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
8716 where
8717 V: serde::de::MapAccess<'de>,
8718 {
8719 let mut distributions__ = None;
8720 while let Some(k) = map_.next_key()? {
8721 match k {
8722 GeneratedField::Distributions => {
8723 if distributions__.is_some() {
8724 return Err(serde::de::Error::duplicate_field("distributions"));
8725 }
8726 distributions__ = Some(map_.next_value()?);
8727 }
8728 }
8729 }
8730 Ok(ListCreatingFragmentDistributionResponse {
8731 distributions: distributions__.unwrap_or_default(),
8732 })
8733 }
8734 }
8735 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
8736 }
8737}
8738impl serde::Serialize for ListEventLogRequest {
8739 #[allow(deprecated)]
8740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8741 where
8742 S: serde::Serializer,
8743 {
8744 use serde::ser::SerializeStruct;
8745 let len = 0;
8746 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
8747 struct_ser.end()
8748 }
8749}
8750impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
8751 #[allow(deprecated)]
8752 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8753 where
8754 D: serde::Deserializer<'de>,
8755 {
8756 const FIELDS: &[&str] = &[
8757 ];
8758
8759 #[allow(clippy::enum_variant_names)]
8760 enum GeneratedField {
8761 }
8762 impl<'de> serde::Deserialize<'de> for GeneratedField {
8763 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8764 where
8765 D: serde::Deserializer<'de>,
8766 {
8767 struct GeneratedVisitor;
8768
8769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8770 type Value = GeneratedField;
8771
8772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8773 write!(formatter, "expected one of: {:?}", &FIELDS)
8774 }
8775
8776 #[allow(unused_variables)]
8777 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8778 where
8779 E: serde::de::Error,
8780 {
8781 Err(serde::de::Error::unknown_field(value, FIELDS))
8782 }
8783 }
8784 deserializer.deserialize_identifier(GeneratedVisitor)
8785 }
8786 }
8787 struct GeneratedVisitor;
8788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8789 type Value = ListEventLogRequest;
8790
8791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8792 formatter.write_str("struct meta.ListEventLogRequest")
8793 }
8794
8795 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
8796 where
8797 V: serde::de::MapAccess<'de>,
8798 {
8799 while map_.next_key::<GeneratedField>()?.is_some() {
8800 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8801 }
8802 Ok(ListEventLogRequest {
8803 })
8804 }
8805 }
8806 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
8807 }
8808}
8809impl serde::Serialize for ListEventLogResponse {
8810 #[allow(deprecated)]
8811 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8812 where
8813 S: serde::Serializer,
8814 {
8815 use serde::ser::SerializeStruct;
8816 let mut len = 0;
8817 if !self.event_logs.is_empty() {
8818 len += 1;
8819 }
8820 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
8821 if !self.event_logs.is_empty() {
8822 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
8823 }
8824 struct_ser.end()
8825 }
8826}
8827impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
8828 #[allow(deprecated)]
8829 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8830 where
8831 D: serde::Deserializer<'de>,
8832 {
8833 const FIELDS: &[&str] = &[
8834 "event_logs",
8835 "eventLogs",
8836 ];
8837
8838 #[allow(clippy::enum_variant_names)]
8839 enum GeneratedField {
8840 EventLogs,
8841 }
8842 impl<'de> serde::Deserialize<'de> for GeneratedField {
8843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8844 where
8845 D: serde::Deserializer<'de>,
8846 {
8847 struct GeneratedVisitor;
8848
8849 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8850 type Value = GeneratedField;
8851
8852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8853 write!(formatter, "expected one of: {:?}", &FIELDS)
8854 }
8855
8856 #[allow(unused_variables)]
8857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8858 where
8859 E: serde::de::Error,
8860 {
8861 match value {
8862 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
8863 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8864 }
8865 }
8866 }
8867 deserializer.deserialize_identifier(GeneratedVisitor)
8868 }
8869 }
8870 struct GeneratedVisitor;
8871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8872 type Value = ListEventLogResponse;
8873
8874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8875 formatter.write_str("struct meta.ListEventLogResponse")
8876 }
8877
8878 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
8879 where
8880 V: serde::de::MapAccess<'de>,
8881 {
8882 let mut event_logs__ = None;
8883 while let Some(k) = map_.next_key()? {
8884 match k {
8885 GeneratedField::EventLogs => {
8886 if event_logs__.is_some() {
8887 return Err(serde::de::Error::duplicate_field("eventLogs"));
8888 }
8889 event_logs__ = Some(map_.next_value()?);
8890 }
8891 }
8892 }
8893 Ok(ListEventLogResponse {
8894 event_logs: event_logs__.unwrap_or_default(),
8895 })
8896 }
8897 }
8898 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
8899 }
8900}
8901impl serde::Serialize for ListFragmentDistributionRequest {
8902 #[allow(deprecated)]
8903 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8904 where
8905 S: serde::Serializer,
8906 {
8907 use serde::ser::SerializeStruct;
8908 let len = 0;
8909 let struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
8910 struct_ser.end()
8911 }
8912}
8913impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
8914 #[allow(deprecated)]
8915 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8916 where
8917 D: serde::Deserializer<'de>,
8918 {
8919 const FIELDS: &[&str] = &[
8920 ];
8921
8922 #[allow(clippy::enum_variant_names)]
8923 enum GeneratedField {
8924 }
8925 impl<'de> serde::Deserialize<'de> for GeneratedField {
8926 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8927 where
8928 D: serde::Deserializer<'de>,
8929 {
8930 struct GeneratedVisitor;
8931
8932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8933 type Value = GeneratedField;
8934
8935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8936 write!(formatter, "expected one of: {:?}", &FIELDS)
8937 }
8938
8939 #[allow(unused_variables)]
8940 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8941 where
8942 E: serde::de::Error,
8943 {
8944 Err(serde::de::Error::unknown_field(value, FIELDS))
8945 }
8946 }
8947 deserializer.deserialize_identifier(GeneratedVisitor)
8948 }
8949 }
8950 struct GeneratedVisitor;
8951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8952 type Value = ListFragmentDistributionRequest;
8953
8954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8955 formatter.write_str("struct meta.ListFragmentDistributionRequest")
8956 }
8957
8958 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
8959 where
8960 V: serde::de::MapAccess<'de>,
8961 {
8962 while map_.next_key::<GeneratedField>()?.is_some() {
8963 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8964 }
8965 Ok(ListFragmentDistributionRequest {
8966 })
8967 }
8968 }
8969 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
8970 }
8971}
8972impl serde::Serialize for ListFragmentDistributionResponse {
8973 #[allow(deprecated)]
8974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8975 where
8976 S: serde::Serializer,
8977 {
8978 use serde::ser::SerializeStruct;
8979 let mut len = 0;
8980 if !self.distributions.is_empty() {
8981 len += 1;
8982 }
8983 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
8984 if !self.distributions.is_empty() {
8985 struct_ser.serialize_field("distributions", &self.distributions)?;
8986 }
8987 struct_ser.end()
8988 }
8989}
8990impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
8991 #[allow(deprecated)]
8992 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8993 where
8994 D: serde::Deserializer<'de>,
8995 {
8996 const FIELDS: &[&str] = &[
8997 "distributions",
8998 ];
8999
9000 #[allow(clippy::enum_variant_names)]
9001 enum GeneratedField {
9002 Distributions,
9003 }
9004 impl<'de> serde::Deserialize<'de> for GeneratedField {
9005 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9006 where
9007 D: serde::Deserializer<'de>,
9008 {
9009 struct GeneratedVisitor;
9010
9011 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9012 type Value = GeneratedField;
9013
9014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9015 write!(formatter, "expected one of: {:?}", &FIELDS)
9016 }
9017
9018 #[allow(unused_variables)]
9019 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9020 where
9021 E: serde::de::Error,
9022 {
9023 match value {
9024 "distributions" => Ok(GeneratedField::Distributions),
9025 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9026 }
9027 }
9028 }
9029 deserializer.deserialize_identifier(GeneratedVisitor)
9030 }
9031 }
9032 struct GeneratedVisitor;
9033 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9034 type Value = ListFragmentDistributionResponse;
9035
9036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9037 formatter.write_str("struct meta.ListFragmentDistributionResponse")
9038 }
9039
9040 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
9041 where
9042 V: serde::de::MapAccess<'de>,
9043 {
9044 let mut distributions__ = None;
9045 while let Some(k) = map_.next_key()? {
9046 match k {
9047 GeneratedField::Distributions => {
9048 if distributions__.is_some() {
9049 return Err(serde::de::Error::duplicate_field("distributions"));
9050 }
9051 distributions__ = Some(map_.next_value()?);
9052 }
9053 }
9054 }
9055 Ok(ListFragmentDistributionResponse {
9056 distributions: distributions__.unwrap_or_default(),
9057 })
9058 }
9059 }
9060 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9061 }
9062}
9063impl serde::Serialize for ListIcebergTablesRequest {
9064 #[allow(deprecated)]
9065 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9066 where
9067 S: serde::Serializer,
9068 {
9069 use serde::ser::SerializeStruct;
9070 let len = 0;
9071 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
9072 struct_ser.end()
9073 }
9074}
9075impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
9076 #[allow(deprecated)]
9077 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9078 where
9079 D: serde::Deserializer<'de>,
9080 {
9081 const FIELDS: &[&str] = &[
9082 ];
9083
9084 #[allow(clippy::enum_variant_names)]
9085 enum GeneratedField {
9086 }
9087 impl<'de> serde::Deserialize<'de> for GeneratedField {
9088 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9089 where
9090 D: serde::Deserializer<'de>,
9091 {
9092 struct GeneratedVisitor;
9093
9094 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9095 type Value = GeneratedField;
9096
9097 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9098 write!(formatter, "expected one of: {:?}", &FIELDS)
9099 }
9100
9101 #[allow(unused_variables)]
9102 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9103 where
9104 E: serde::de::Error,
9105 {
9106 Err(serde::de::Error::unknown_field(value, FIELDS))
9107 }
9108 }
9109 deserializer.deserialize_identifier(GeneratedVisitor)
9110 }
9111 }
9112 struct GeneratedVisitor;
9113 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9114 type Value = ListIcebergTablesRequest;
9115
9116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9117 formatter.write_str("struct meta.ListIcebergTablesRequest")
9118 }
9119
9120 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
9121 where
9122 V: serde::de::MapAccess<'de>,
9123 {
9124 while map_.next_key::<GeneratedField>()?.is_some() {
9125 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9126 }
9127 Ok(ListIcebergTablesRequest {
9128 })
9129 }
9130 }
9131 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
9132 }
9133}
9134impl serde::Serialize for ListIcebergTablesResponse {
9135 #[allow(deprecated)]
9136 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9137 where
9138 S: serde::Serializer,
9139 {
9140 use serde::ser::SerializeStruct;
9141 let mut len = 0;
9142 if !self.iceberg_tables.is_empty() {
9143 len += 1;
9144 }
9145 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
9146 if !self.iceberg_tables.is_empty() {
9147 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
9148 }
9149 struct_ser.end()
9150 }
9151}
9152impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
9153 #[allow(deprecated)]
9154 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9155 where
9156 D: serde::Deserializer<'de>,
9157 {
9158 const FIELDS: &[&str] = &[
9159 "iceberg_tables",
9160 "icebergTables",
9161 ];
9162
9163 #[allow(clippy::enum_variant_names)]
9164 enum GeneratedField {
9165 IcebergTables,
9166 }
9167 impl<'de> serde::Deserialize<'de> for GeneratedField {
9168 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9169 where
9170 D: serde::Deserializer<'de>,
9171 {
9172 struct GeneratedVisitor;
9173
9174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9175 type Value = GeneratedField;
9176
9177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9178 write!(formatter, "expected one of: {:?}", &FIELDS)
9179 }
9180
9181 #[allow(unused_variables)]
9182 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9183 where
9184 E: serde::de::Error,
9185 {
9186 match value {
9187 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
9188 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9189 }
9190 }
9191 }
9192 deserializer.deserialize_identifier(GeneratedVisitor)
9193 }
9194 }
9195 struct GeneratedVisitor;
9196 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9197 type Value = ListIcebergTablesResponse;
9198
9199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9200 formatter.write_str("struct meta.ListIcebergTablesResponse")
9201 }
9202
9203 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
9204 where
9205 V: serde::de::MapAccess<'de>,
9206 {
9207 let mut iceberg_tables__ = None;
9208 while let Some(k) = map_.next_key()? {
9209 match k {
9210 GeneratedField::IcebergTables => {
9211 if iceberg_tables__.is_some() {
9212 return Err(serde::de::Error::duplicate_field("icebergTables"));
9213 }
9214 iceberg_tables__ = Some(map_.next_value()?);
9215 }
9216 }
9217 }
9218 Ok(ListIcebergTablesResponse {
9219 iceberg_tables: iceberg_tables__.unwrap_or_default(),
9220 })
9221 }
9222 }
9223 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
9224 }
9225}
9226impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
9227 #[allow(deprecated)]
9228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9229 where
9230 S: serde::Serializer,
9231 {
9232 use serde::ser::SerializeStruct;
9233 let mut len = 0;
9234 if !self.catalog_name.is_empty() {
9235 len += 1;
9236 }
9237 if !self.table_namespace.is_empty() {
9238 len += 1;
9239 }
9240 if !self.table_name.is_empty() {
9241 len += 1;
9242 }
9243 if self.metadata_location.is_some() {
9244 len += 1;
9245 }
9246 if self.previous_metadata_location.is_some() {
9247 len += 1;
9248 }
9249 if self.iceberg_type.is_some() {
9250 len += 1;
9251 }
9252 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
9253 if !self.catalog_name.is_empty() {
9254 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
9255 }
9256 if !self.table_namespace.is_empty() {
9257 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
9258 }
9259 if !self.table_name.is_empty() {
9260 struct_ser.serialize_field("tableName", &self.table_name)?;
9261 }
9262 if let Some(v) = self.metadata_location.as_ref() {
9263 struct_ser.serialize_field("metadataLocation", v)?;
9264 }
9265 if let Some(v) = self.previous_metadata_location.as_ref() {
9266 struct_ser.serialize_field("previousMetadataLocation", v)?;
9267 }
9268 if let Some(v) = self.iceberg_type.as_ref() {
9269 struct_ser.serialize_field("icebergType", v)?;
9270 }
9271 struct_ser.end()
9272 }
9273}
9274impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
9275 #[allow(deprecated)]
9276 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9277 where
9278 D: serde::Deserializer<'de>,
9279 {
9280 const FIELDS: &[&str] = &[
9281 "catalog_name",
9282 "catalogName",
9283 "table_namespace",
9284 "tableNamespace",
9285 "table_name",
9286 "tableName",
9287 "metadata_location",
9288 "metadataLocation",
9289 "previous_metadata_location",
9290 "previousMetadataLocation",
9291 "iceberg_type",
9292 "icebergType",
9293 ];
9294
9295 #[allow(clippy::enum_variant_names)]
9296 enum GeneratedField {
9297 CatalogName,
9298 TableNamespace,
9299 TableName,
9300 MetadataLocation,
9301 PreviousMetadataLocation,
9302 IcebergType,
9303 }
9304 impl<'de> serde::Deserialize<'de> for GeneratedField {
9305 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9306 where
9307 D: serde::Deserializer<'de>,
9308 {
9309 struct GeneratedVisitor;
9310
9311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9312 type Value = GeneratedField;
9313
9314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9315 write!(formatter, "expected one of: {:?}", &FIELDS)
9316 }
9317
9318 #[allow(unused_variables)]
9319 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9320 where
9321 E: serde::de::Error,
9322 {
9323 match value {
9324 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
9325 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
9326 "tableName" | "table_name" => Ok(GeneratedField::TableName),
9327 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
9328 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
9329 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
9330 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9331 }
9332 }
9333 }
9334 deserializer.deserialize_identifier(GeneratedVisitor)
9335 }
9336 }
9337 struct GeneratedVisitor;
9338 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9339 type Value = list_iceberg_tables_response::IcebergTable;
9340
9341 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9342 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
9343 }
9344
9345 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
9346 where
9347 V: serde::de::MapAccess<'de>,
9348 {
9349 let mut catalog_name__ = None;
9350 let mut table_namespace__ = None;
9351 let mut table_name__ = None;
9352 let mut metadata_location__ = None;
9353 let mut previous_metadata_location__ = None;
9354 let mut iceberg_type__ = None;
9355 while let Some(k) = map_.next_key()? {
9356 match k {
9357 GeneratedField::CatalogName => {
9358 if catalog_name__.is_some() {
9359 return Err(serde::de::Error::duplicate_field("catalogName"));
9360 }
9361 catalog_name__ = Some(map_.next_value()?);
9362 }
9363 GeneratedField::TableNamespace => {
9364 if table_namespace__.is_some() {
9365 return Err(serde::de::Error::duplicate_field("tableNamespace"));
9366 }
9367 table_namespace__ = Some(map_.next_value()?);
9368 }
9369 GeneratedField::TableName => {
9370 if table_name__.is_some() {
9371 return Err(serde::de::Error::duplicate_field("tableName"));
9372 }
9373 table_name__ = Some(map_.next_value()?);
9374 }
9375 GeneratedField::MetadataLocation => {
9376 if metadata_location__.is_some() {
9377 return Err(serde::de::Error::duplicate_field("metadataLocation"));
9378 }
9379 metadata_location__ = map_.next_value()?;
9380 }
9381 GeneratedField::PreviousMetadataLocation => {
9382 if previous_metadata_location__.is_some() {
9383 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
9384 }
9385 previous_metadata_location__ = map_.next_value()?;
9386 }
9387 GeneratedField::IcebergType => {
9388 if iceberg_type__.is_some() {
9389 return Err(serde::de::Error::duplicate_field("icebergType"));
9390 }
9391 iceberg_type__ = map_.next_value()?;
9392 }
9393 }
9394 }
9395 Ok(list_iceberg_tables_response::IcebergTable {
9396 catalog_name: catalog_name__.unwrap_or_default(),
9397 table_namespace: table_namespace__.unwrap_or_default(),
9398 table_name: table_name__.unwrap_or_default(),
9399 metadata_location: metadata_location__,
9400 previous_metadata_location: previous_metadata_location__,
9401 iceberg_type: iceberg_type__,
9402 })
9403 }
9404 }
9405 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
9406 }
9407}
9408impl serde::Serialize for ListObjectDependenciesRequest {
9409 #[allow(deprecated)]
9410 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9411 where
9412 S: serde::Serializer,
9413 {
9414 use serde::ser::SerializeStruct;
9415 let len = 0;
9416 let struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesRequest", len)?;
9417 struct_ser.end()
9418 }
9419}
9420impl<'de> serde::Deserialize<'de> for ListObjectDependenciesRequest {
9421 #[allow(deprecated)]
9422 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9423 where
9424 D: serde::Deserializer<'de>,
9425 {
9426 const FIELDS: &[&str] = &[
9427 ];
9428
9429 #[allow(clippy::enum_variant_names)]
9430 enum GeneratedField {
9431 }
9432 impl<'de> serde::Deserialize<'de> for GeneratedField {
9433 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9434 where
9435 D: serde::Deserializer<'de>,
9436 {
9437 struct GeneratedVisitor;
9438
9439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9440 type Value = GeneratedField;
9441
9442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9443 write!(formatter, "expected one of: {:?}", &FIELDS)
9444 }
9445
9446 #[allow(unused_variables)]
9447 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9448 where
9449 E: serde::de::Error,
9450 {
9451 Err(serde::de::Error::unknown_field(value, FIELDS))
9452 }
9453 }
9454 deserializer.deserialize_identifier(GeneratedVisitor)
9455 }
9456 }
9457 struct GeneratedVisitor;
9458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9459 type Value = ListObjectDependenciesRequest;
9460
9461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9462 formatter.write_str("struct meta.ListObjectDependenciesRequest")
9463 }
9464
9465 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesRequest, V::Error>
9466 where
9467 V: serde::de::MapAccess<'de>,
9468 {
9469 while map_.next_key::<GeneratedField>()?.is_some() {
9470 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9471 }
9472 Ok(ListObjectDependenciesRequest {
9473 })
9474 }
9475 }
9476 deserializer.deserialize_struct("meta.ListObjectDependenciesRequest", FIELDS, GeneratedVisitor)
9477 }
9478}
9479impl serde::Serialize for ListObjectDependenciesResponse {
9480 #[allow(deprecated)]
9481 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9482 where
9483 S: serde::Serializer,
9484 {
9485 use serde::ser::SerializeStruct;
9486 let mut len = 0;
9487 if !self.dependencies.is_empty() {
9488 len += 1;
9489 }
9490 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse", len)?;
9491 if !self.dependencies.is_empty() {
9492 struct_ser.serialize_field("dependencies", &self.dependencies)?;
9493 }
9494 struct_ser.end()
9495 }
9496}
9497impl<'de> serde::Deserialize<'de> for ListObjectDependenciesResponse {
9498 #[allow(deprecated)]
9499 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9500 where
9501 D: serde::Deserializer<'de>,
9502 {
9503 const FIELDS: &[&str] = &[
9504 "dependencies",
9505 ];
9506
9507 #[allow(clippy::enum_variant_names)]
9508 enum GeneratedField {
9509 Dependencies,
9510 }
9511 impl<'de> serde::Deserialize<'de> for GeneratedField {
9512 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9513 where
9514 D: serde::Deserializer<'de>,
9515 {
9516 struct GeneratedVisitor;
9517
9518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9519 type Value = GeneratedField;
9520
9521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9522 write!(formatter, "expected one of: {:?}", &FIELDS)
9523 }
9524
9525 #[allow(unused_variables)]
9526 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9527 where
9528 E: serde::de::Error,
9529 {
9530 match value {
9531 "dependencies" => Ok(GeneratedField::Dependencies),
9532 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9533 }
9534 }
9535 }
9536 deserializer.deserialize_identifier(GeneratedVisitor)
9537 }
9538 }
9539 struct GeneratedVisitor;
9540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9541 type Value = ListObjectDependenciesResponse;
9542
9543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9544 formatter.write_str("struct meta.ListObjectDependenciesResponse")
9545 }
9546
9547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesResponse, V::Error>
9548 where
9549 V: serde::de::MapAccess<'de>,
9550 {
9551 let mut dependencies__ = None;
9552 while let Some(k) = map_.next_key()? {
9553 match k {
9554 GeneratedField::Dependencies => {
9555 if dependencies__.is_some() {
9556 return Err(serde::de::Error::duplicate_field("dependencies"));
9557 }
9558 dependencies__ = Some(map_.next_value()?);
9559 }
9560 }
9561 }
9562 Ok(ListObjectDependenciesResponse {
9563 dependencies: dependencies__.unwrap_or_default(),
9564 })
9565 }
9566 }
9567 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse", FIELDS, GeneratedVisitor)
9568 }
9569}
9570impl serde::Serialize for list_object_dependencies_response::ObjectDependencies {
9571 #[allow(deprecated)]
9572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9573 where
9574 S: serde::Serializer,
9575 {
9576 use serde::ser::SerializeStruct;
9577 let mut len = 0;
9578 if self.object_id != 0 {
9579 len += 1;
9580 }
9581 if self.referenced_object_id != 0 {
9582 len += 1;
9583 }
9584 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", len)?;
9585 if self.object_id != 0 {
9586 struct_ser.serialize_field("objectId", &self.object_id)?;
9587 }
9588 if self.referenced_object_id != 0 {
9589 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
9590 }
9591 struct_ser.end()
9592 }
9593}
9594impl<'de> serde::Deserialize<'de> for list_object_dependencies_response::ObjectDependencies {
9595 #[allow(deprecated)]
9596 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9597 where
9598 D: serde::Deserializer<'de>,
9599 {
9600 const FIELDS: &[&str] = &[
9601 "object_id",
9602 "objectId",
9603 "referenced_object_id",
9604 "referencedObjectId",
9605 ];
9606
9607 #[allow(clippy::enum_variant_names)]
9608 enum GeneratedField {
9609 ObjectId,
9610 ReferencedObjectId,
9611 }
9612 impl<'de> serde::Deserialize<'de> for GeneratedField {
9613 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9614 where
9615 D: serde::Deserializer<'de>,
9616 {
9617 struct GeneratedVisitor;
9618
9619 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9620 type Value = GeneratedField;
9621
9622 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9623 write!(formatter, "expected one of: {:?}", &FIELDS)
9624 }
9625
9626 #[allow(unused_variables)]
9627 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9628 where
9629 E: serde::de::Error,
9630 {
9631 match value {
9632 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
9633 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
9634 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9635 }
9636 }
9637 }
9638 deserializer.deserialize_identifier(GeneratedVisitor)
9639 }
9640 }
9641 struct GeneratedVisitor;
9642 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9643 type Value = list_object_dependencies_response::ObjectDependencies;
9644
9645 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9646 formatter.write_str("struct meta.ListObjectDependenciesResponse.ObjectDependencies")
9647 }
9648
9649 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_object_dependencies_response::ObjectDependencies, V::Error>
9650 where
9651 V: serde::de::MapAccess<'de>,
9652 {
9653 let mut object_id__ = None;
9654 let mut referenced_object_id__ = None;
9655 while let Some(k) = map_.next_key()? {
9656 match k {
9657 GeneratedField::ObjectId => {
9658 if object_id__.is_some() {
9659 return Err(serde::de::Error::duplicate_field("objectId"));
9660 }
9661 object_id__ =
9662 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9663 ;
9664 }
9665 GeneratedField::ReferencedObjectId => {
9666 if referenced_object_id__.is_some() {
9667 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
9668 }
9669 referenced_object_id__ =
9670 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9671 ;
9672 }
9673 }
9674 }
9675 Ok(list_object_dependencies_response::ObjectDependencies {
9676 object_id: object_id__.unwrap_or_default(),
9677 referenced_object_id: referenced_object_id__.unwrap_or_default(),
9678 })
9679 }
9680 }
9681 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", FIELDS, GeneratedVisitor)
9682 }
9683}
9684impl serde::Serialize for ListRateLimitsRequest {
9685 #[allow(deprecated)]
9686 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9687 where
9688 S: serde::Serializer,
9689 {
9690 use serde::ser::SerializeStruct;
9691 let len = 0;
9692 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
9693 struct_ser.end()
9694 }
9695}
9696impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
9697 #[allow(deprecated)]
9698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9699 where
9700 D: serde::Deserializer<'de>,
9701 {
9702 const FIELDS: &[&str] = &[
9703 ];
9704
9705 #[allow(clippy::enum_variant_names)]
9706 enum GeneratedField {
9707 }
9708 impl<'de> serde::Deserialize<'de> for GeneratedField {
9709 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9710 where
9711 D: serde::Deserializer<'de>,
9712 {
9713 struct GeneratedVisitor;
9714
9715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9716 type Value = GeneratedField;
9717
9718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9719 write!(formatter, "expected one of: {:?}", &FIELDS)
9720 }
9721
9722 #[allow(unused_variables)]
9723 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9724 where
9725 E: serde::de::Error,
9726 {
9727 Err(serde::de::Error::unknown_field(value, FIELDS))
9728 }
9729 }
9730 deserializer.deserialize_identifier(GeneratedVisitor)
9731 }
9732 }
9733 struct GeneratedVisitor;
9734 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9735 type Value = ListRateLimitsRequest;
9736
9737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9738 formatter.write_str("struct meta.ListRateLimitsRequest")
9739 }
9740
9741 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
9742 where
9743 V: serde::de::MapAccess<'de>,
9744 {
9745 while map_.next_key::<GeneratedField>()?.is_some() {
9746 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9747 }
9748 Ok(ListRateLimitsRequest {
9749 })
9750 }
9751 }
9752 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
9753 }
9754}
9755impl serde::Serialize for ListRateLimitsResponse {
9756 #[allow(deprecated)]
9757 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9758 where
9759 S: serde::Serializer,
9760 {
9761 use serde::ser::SerializeStruct;
9762 let mut len = 0;
9763 if !self.rate_limits.is_empty() {
9764 len += 1;
9765 }
9766 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
9767 if !self.rate_limits.is_empty() {
9768 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
9769 }
9770 struct_ser.end()
9771 }
9772}
9773impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
9774 #[allow(deprecated)]
9775 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9776 where
9777 D: serde::Deserializer<'de>,
9778 {
9779 const FIELDS: &[&str] = &[
9780 "rate_limits",
9781 "rateLimits",
9782 ];
9783
9784 #[allow(clippy::enum_variant_names)]
9785 enum GeneratedField {
9786 RateLimits,
9787 }
9788 impl<'de> serde::Deserialize<'de> for GeneratedField {
9789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9790 where
9791 D: serde::Deserializer<'de>,
9792 {
9793 struct GeneratedVisitor;
9794
9795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9796 type Value = GeneratedField;
9797
9798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9799 write!(formatter, "expected one of: {:?}", &FIELDS)
9800 }
9801
9802 #[allow(unused_variables)]
9803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9804 where
9805 E: serde::de::Error,
9806 {
9807 match value {
9808 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
9809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9810 }
9811 }
9812 }
9813 deserializer.deserialize_identifier(GeneratedVisitor)
9814 }
9815 }
9816 struct GeneratedVisitor;
9817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9818 type Value = ListRateLimitsResponse;
9819
9820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9821 formatter.write_str("struct meta.ListRateLimitsResponse")
9822 }
9823
9824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
9825 where
9826 V: serde::de::MapAccess<'de>,
9827 {
9828 let mut rate_limits__ = None;
9829 while let Some(k) = map_.next_key()? {
9830 match k {
9831 GeneratedField::RateLimits => {
9832 if rate_limits__.is_some() {
9833 return Err(serde::de::Error::duplicate_field("rateLimits"));
9834 }
9835 rate_limits__ = Some(map_.next_value()?);
9836 }
9837 }
9838 }
9839 Ok(ListRateLimitsResponse {
9840 rate_limits: rate_limits__.unwrap_or_default(),
9841 })
9842 }
9843 }
9844 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
9845 }
9846}
9847impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
9848 #[allow(deprecated)]
9849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9850 where
9851 S: serde::Serializer,
9852 {
9853 use serde::ser::SerializeStruct;
9854 let mut len = 0;
9855 if self.fragment_id != 0 {
9856 len += 1;
9857 }
9858 if self.job_id != 0 {
9859 len += 1;
9860 }
9861 if self.fragment_type_mask != 0 {
9862 len += 1;
9863 }
9864 if self.rate_limit != 0 {
9865 len += 1;
9866 }
9867 if !self.node_name.is_empty() {
9868 len += 1;
9869 }
9870 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
9871 if self.fragment_id != 0 {
9872 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9873 }
9874 if self.job_id != 0 {
9875 struct_ser.serialize_field("jobId", &self.job_id)?;
9876 }
9877 if self.fragment_type_mask != 0 {
9878 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
9879 }
9880 if self.rate_limit != 0 {
9881 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
9882 }
9883 if !self.node_name.is_empty() {
9884 struct_ser.serialize_field("nodeName", &self.node_name)?;
9885 }
9886 struct_ser.end()
9887 }
9888}
9889impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
9890 #[allow(deprecated)]
9891 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9892 where
9893 D: serde::Deserializer<'de>,
9894 {
9895 const FIELDS: &[&str] = &[
9896 "fragment_id",
9897 "fragmentId",
9898 "job_id",
9899 "jobId",
9900 "fragment_type_mask",
9901 "fragmentTypeMask",
9902 "rate_limit",
9903 "rateLimit",
9904 "node_name",
9905 "nodeName",
9906 ];
9907
9908 #[allow(clippy::enum_variant_names)]
9909 enum GeneratedField {
9910 FragmentId,
9911 JobId,
9912 FragmentTypeMask,
9913 RateLimit,
9914 NodeName,
9915 }
9916 impl<'de> serde::Deserialize<'de> for GeneratedField {
9917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9918 where
9919 D: serde::Deserializer<'de>,
9920 {
9921 struct GeneratedVisitor;
9922
9923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9924 type Value = GeneratedField;
9925
9926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9927 write!(formatter, "expected one of: {:?}", &FIELDS)
9928 }
9929
9930 #[allow(unused_variables)]
9931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9932 where
9933 E: serde::de::Error,
9934 {
9935 match value {
9936 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9937 "jobId" | "job_id" => Ok(GeneratedField::JobId),
9938 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
9939 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9940 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
9941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9942 }
9943 }
9944 }
9945 deserializer.deserialize_identifier(GeneratedVisitor)
9946 }
9947 }
9948 struct GeneratedVisitor;
9949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9950 type Value = list_rate_limits_response::RateLimitInfo;
9951
9952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9953 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
9954 }
9955
9956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
9957 where
9958 V: serde::de::MapAccess<'de>,
9959 {
9960 let mut fragment_id__ = None;
9961 let mut job_id__ = None;
9962 let mut fragment_type_mask__ = None;
9963 let mut rate_limit__ = None;
9964 let mut node_name__ = None;
9965 while let Some(k) = map_.next_key()? {
9966 match k {
9967 GeneratedField::FragmentId => {
9968 if fragment_id__.is_some() {
9969 return Err(serde::de::Error::duplicate_field("fragmentId"));
9970 }
9971 fragment_id__ =
9972 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9973 ;
9974 }
9975 GeneratedField::JobId => {
9976 if job_id__.is_some() {
9977 return Err(serde::de::Error::duplicate_field("jobId"));
9978 }
9979 job_id__ =
9980 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9981 ;
9982 }
9983 GeneratedField::FragmentTypeMask => {
9984 if fragment_type_mask__.is_some() {
9985 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
9986 }
9987 fragment_type_mask__ =
9988 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9989 ;
9990 }
9991 GeneratedField::RateLimit => {
9992 if rate_limit__.is_some() {
9993 return Err(serde::de::Error::duplicate_field("rateLimit"));
9994 }
9995 rate_limit__ =
9996 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9997 ;
9998 }
9999 GeneratedField::NodeName => {
10000 if node_name__.is_some() {
10001 return Err(serde::de::Error::duplicate_field("nodeName"));
10002 }
10003 node_name__ = Some(map_.next_value()?);
10004 }
10005 }
10006 }
10007 Ok(list_rate_limits_response::RateLimitInfo {
10008 fragment_id: fragment_id__.unwrap_or_default(),
10009 job_id: job_id__.unwrap_or_default(),
10010 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10011 rate_limit: rate_limit__.unwrap_or_default(),
10012 node_name: node_name__.unwrap_or_default(),
10013 })
10014 }
10015 }
10016 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
10017 }
10018}
10019impl serde::Serialize for ListStreamingJobStatesRequest {
10020 #[allow(deprecated)]
10021 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10022 where
10023 S: serde::Serializer,
10024 {
10025 use serde::ser::SerializeStruct;
10026 let len = 0;
10027 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
10028 struct_ser.end()
10029 }
10030}
10031impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
10032 #[allow(deprecated)]
10033 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10034 where
10035 D: serde::Deserializer<'de>,
10036 {
10037 const FIELDS: &[&str] = &[
10038 ];
10039
10040 #[allow(clippy::enum_variant_names)]
10041 enum GeneratedField {
10042 }
10043 impl<'de> serde::Deserialize<'de> for GeneratedField {
10044 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10045 where
10046 D: serde::Deserializer<'de>,
10047 {
10048 struct GeneratedVisitor;
10049
10050 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10051 type Value = GeneratedField;
10052
10053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10054 write!(formatter, "expected one of: {:?}", &FIELDS)
10055 }
10056
10057 #[allow(unused_variables)]
10058 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10059 where
10060 E: serde::de::Error,
10061 {
10062 Err(serde::de::Error::unknown_field(value, FIELDS))
10063 }
10064 }
10065 deserializer.deserialize_identifier(GeneratedVisitor)
10066 }
10067 }
10068 struct GeneratedVisitor;
10069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10070 type Value = ListStreamingJobStatesRequest;
10071
10072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10073 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
10074 }
10075
10076 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
10077 where
10078 V: serde::de::MapAccess<'de>,
10079 {
10080 while map_.next_key::<GeneratedField>()?.is_some() {
10081 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10082 }
10083 Ok(ListStreamingJobStatesRequest {
10084 })
10085 }
10086 }
10087 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
10088 }
10089}
10090impl serde::Serialize for ListStreamingJobStatesResponse {
10091 #[allow(deprecated)]
10092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10093 where
10094 S: serde::Serializer,
10095 {
10096 use serde::ser::SerializeStruct;
10097 let mut len = 0;
10098 if !self.states.is_empty() {
10099 len += 1;
10100 }
10101 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
10102 if !self.states.is_empty() {
10103 struct_ser.serialize_field("states", &self.states)?;
10104 }
10105 struct_ser.end()
10106 }
10107}
10108impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
10109 #[allow(deprecated)]
10110 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10111 where
10112 D: serde::Deserializer<'de>,
10113 {
10114 const FIELDS: &[&str] = &[
10115 "states",
10116 ];
10117
10118 #[allow(clippy::enum_variant_names)]
10119 enum GeneratedField {
10120 States,
10121 }
10122 impl<'de> serde::Deserialize<'de> for GeneratedField {
10123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10124 where
10125 D: serde::Deserializer<'de>,
10126 {
10127 struct GeneratedVisitor;
10128
10129 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10130 type Value = GeneratedField;
10131
10132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10133 write!(formatter, "expected one of: {:?}", &FIELDS)
10134 }
10135
10136 #[allow(unused_variables)]
10137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10138 where
10139 E: serde::de::Error,
10140 {
10141 match value {
10142 "states" => Ok(GeneratedField::States),
10143 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10144 }
10145 }
10146 }
10147 deserializer.deserialize_identifier(GeneratedVisitor)
10148 }
10149 }
10150 struct GeneratedVisitor;
10151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10152 type Value = ListStreamingJobStatesResponse;
10153
10154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10155 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
10156 }
10157
10158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
10159 where
10160 V: serde::de::MapAccess<'de>,
10161 {
10162 let mut states__ = None;
10163 while let Some(k) = map_.next_key()? {
10164 match k {
10165 GeneratedField::States => {
10166 if states__.is_some() {
10167 return Err(serde::de::Error::duplicate_field("states"));
10168 }
10169 states__ = Some(map_.next_value()?);
10170 }
10171 }
10172 }
10173 Ok(ListStreamingJobStatesResponse {
10174 states: states__.unwrap_or_default(),
10175 })
10176 }
10177 }
10178 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
10179 }
10180}
10181impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
10182 #[allow(deprecated)]
10183 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10184 where
10185 S: serde::Serializer,
10186 {
10187 use serde::ser::SerializeStruct;
10188 let mut len = 0;
10189 if self.table_id != 0 {
10190 len += 1;
10191 }
10192 if self.state != 0 {
10193 len += 1;
10194 }
10195 if self.parallelism.is_some() {
10196 len += 1;
10197 }
10198 if self.max_parallelism != 0 {
10199 len += 1;
10200 }
10201 if !self.name.is_empty() {
10202 len += 1;
10203 }
10204 if !self.resource_group.is_empty() {
10205 len += 1;
10206 }
10207 if self.database_id != 0 {
10208 len += 1;
10209 }
10210 if self.schema_id != 0 {
10211 len += 1;
10212 }
10213 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
10214 if self.table_id != 0 {
10215 struct_ser.serialize_field("tableId", &self.table_id)?;
10216 }
10217 if self.state != 0 {
10218 let v = table_fragments::State::try_from(self.state)
10219 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
10220 struct_ser.serialize_field("state", &v)?;
10221 }
10222 if let Some(v) = self.parallelism.as_ref() {
10223 struct_ser.serialize_field("parallelism", v)?;
10224 }
10225 if self.max_parallelism != 0 {
10226 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10227 }
10228 if !self.name.is_empty() {
10229 struct_ser.serialize_field("name", &self.name)?;
10230 }
10231 if !self.resource_group.is_empty() {
10232 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
10233 }
10234 if self.database_id != 0 {
10235 struct_ser.serialize_field("databaseId", &self.database_id)?;
10236 }
10237 if self.schema_id != 0 {
10238 struct_ser.serialize_field("schemaId", &self.schema_id)?;
10239 }
10240 struct_ser.end()
10241 }
10242}
10243impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
10244 #[allow(deprecated)]
10245 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10246 where
10247 D: serde::Deserializer<'de>,
10248 {
10249 const FIELDS: &[&str] = &[
10250 "table_id",
10251 "tableId",
10252 "state",
10253 "parallelism",
10254 "max_parallelism",
10255 "maxParallelism",
10256 "name",
10257 "resource_group",
10258 "resourceGroup",
10259 "database_id",
10260 "databaseId",
10261 "schema_id",
10262 "schemaId",
10263 ];
10264
10265 #[allow(clippy::enum_variant_names)]
10266 enum GeneratedField {
10267 TableId,
10268 State,
10269 Parallelism,
10270 MaxParallelism,
10271 Name,
10272 ResourceGroup,
10273 DatabaseId,
10274 SchemaId,
10275 }
10276 impl<'de> serde::Deserialize<'de> for GeneratedField {
10277 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10278 where
10279 D: serde::Deserializer<'de>,
10280 {
10281 struct GeneratedVisitor;
10282
10283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10284 type Value = GeneratedField;
10285
10286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10287 write!(formatter, "expected one of: {:?}", &FIELDS)
10288 }
10289
10290 #[allow(unused_variables)]
10291 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10292 where
10293 E: serde::de::Error,
10294 {
10295 match value {
10296 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10297 "state" => Ok(GeneratedField::State),
10298 "parallelism" => Ok(GeneratedField::Parallelism),
10299 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10300 "name" => Ok(GeneratedField::Name),
10301 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
10302 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
10303 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
10304 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10305 }
10306 }
10307 }
10308 deserializer.deserialize_identifier(GeneratedVisitor)
10309 }
10310 }
10311 struct GeneratedVisitor;
10312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10313 type Value = list_streaming_job_states_response::StreamingJobState;
10314
10315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10316 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
10317 }
10318
10319 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
10320 where
10321 V: serde::de::MapAccess<'de>,
10322 {
10323 let mut table_id__ = None;
10324 let mut state__ = None;
10325 let mut parallelism__ = None;
10326 let mut max_parallelism__ = None;
10327 let mut name__ = None;
10328 let mut resource_group__ = None;
10329 let mut database_id__ = None;
10330 let mut schema_id__ = None;
10331 while let Some(k) = map_.next_key()? {
10332 match k {
10333 GeneratedField::TableId => {
10334 if table_id__.is_some() {
10335 return Err(serde::de::Error::duplicate_field("tableId"));
10336 }
10337 table_id__ =
10338 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10339 ;
10340 }
10341 GeneratedField::State => {
10342 if state__.is_some() {
10343 return Err(serde::de::Error::duplicate_field("state"));
10344 }
10345 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
10346 }
10347 GeneratedField::Parallelism => {
10348 if parallelism__.is_some() {
10349 return Err(serde::de::Error::duplicate_field("parallelism"));
10350 }
10351 parallelism__ = map_.next_value()?;
10352 }
10353 GeneratedField::MaxParallelism => {
10354 if max_parallelism__.is_some() {
10355 return Err(serde::de::Error::duplicate_field("maxParallelism"));
10356 }
10357 max_parallelism__ =
10358 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10359 ;
10360 }
10361 GeneratedField::Name => {
10362 if name__.is_some() {
10363 return Err(serde::de::Error::duplicate_field("name"));
10364 }
10365 name__ = Some(map_.next_value()?);
10366 }
10367 GeneratedField::ResourceGroup => {
10368 if resource_group__.is_some() {
10369 return Err(serde::de::Error::duplicate_field("resourceGroup"));
10370 }
10371 resource_group__ = Some(map_.next_value()?);
10372 }
10373 GeneratedField::DatabaseId => {
10374 if database_id__.is_some() {
10375 return Err(serde::de::Error::duplicate_field("databaseId"));
10376 }
10377 database_id__ =
10378 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10379 ;
10380 }
10381 GeneratedField::SchemaId => {
10382 if schema_id__.is_some() {
10383 return Err(serde::de::Error::duplicate_field("schemaId"));
10384 }
10385 schema_id__ =
10386 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10387 ;
10388 }
10389 }
10390 }
10391 Ok(list_streaming_job_states_response::StreamingJobState {
10392 table_id: table_id__.unwrap_or_default(),
10393 state: state__.unwrap_or_default(),
10394 parallelism: parallelism__,
10395 max_parallelism: max_parallelism__.unwrap_or_default(),
10396 name: name__.unwrap_or_default(),
10397 resource_group: resource_group__.unwrap_or_default(),
10398 database_id: database_id__.unwrap_or_default(),
10399 schema_id: schema_id__.unwrap_or_default(),
10400 })
10401 }
10402 }
10403 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
10404 }
10405}
10406impl serde::Serialize for ListTableFragmentsRequest {
10407 #[allow(deprecated)]
10408 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10409 where
10410 S: serde::Serializer,
10411 {
10412 use serde::ser::SerializeStruct;
10413 let mut len = 0;
10414 if !self.table_ids.is_empty() {
10415 len += 1;
10416 }
10417 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
10418 if !self.table_ids.is_empty() {
10419 struct_ser.serialize_field("tableIds", &self.table_ids)?;
10420 }
10421 struct_ser.end()
10422 }
10423}
10424impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
10425 #[allow(deprecated)]
10426 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10427 where
10428 D: serde::Deserializer<'de>,
10429 {
10430 const FIELDS: &[&str] = &[
10431 "table_ids",
10432 "tableIds",
10433 ];
10434
10435 #[allow(clippy::enum_variant_names)]
10436 enum GeneratedField {
10437 TableIds,
10438 }
10439 impl<'de> serde::Deserialize<'de> for GeneratedField {
10440 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10441 where
10442 D: serde::Deserializer<'de>,
10443 {
10444 struct GeneratedVisitor;
10445
10446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10447 type Value = GeneratedField;
10448
10449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10450 write!(formatter, "expected one of: {:?}", &FIELDS)
10451 }
10452
10453 #[allow(unused_variables)]
10454 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10455 where
10456 E: serde::de::Error,
10457 {
10458 match value {
10459 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10460 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10461 }
10462 }
10463 }
10464 deserializer.deserialize_identifier(GeneratedVisitor)
10465 }
10466 }
10467 struct GeneratedVisitor;
10468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10469 type Value = ListTableFragmentsRequest;
10470
10471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10472 formatter.write_str("struct meta.ListTableFragmentsRequest")
10473 }
10474
10475 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
10476 where
10477 V: serde::de::MapAccess<'de>,
10478 {
10479 let mut table_ids__ = None;
10480 while let Some(k) = map_.next_key()? {
10481 match k {
10482 GeneratedField::TableIds => {
10483 if table_ids__.is_some() {
10484 return Err(serde::de::Error::duplicate_field("tableIds"));
10485 }
10486 table_ids__ =
10487 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10488 .into_iter().map(|x| x.0).collect())
10489 ;
10490 }
10491 }
10492 }
10493 Ok(ListTableFragmentsRequest {
10494 table_ids: table_ids__.unwrap_or_default(),
10495 })
10496 }
10497 }
10498 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
10499 }
10500}
10501impl serde::Serialize for ListTableFragmentsResponse {
10502 #[allow(deprecated)]
10503 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10504 where
10505 S: serde::Serializer,
10506 {
10507 use serde::ser::SerializeStruct;
10508 let mut len = 0;
10509 if !self.table_fragments.is_empty() {
10510 len += 1;
10511 }
10512 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
10513 if !self.table_fragments.is_empty() {
10514 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
10515 }
10516 struct_ser.end()
10517 }
10518}
10519impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
10520 #[allow(deprecated)]
10521 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10522 where
10523 D: serde::Deserializer<'de>,
10524 {
10525 const FIELDS: &[&str] = &[
10526 "table_fragments",
10527 "tableFragments",
10528 ];
10529
10530 #[allow(clippy::enum_variant_names)]
10531 enum GeneratedField {
10532 TableFragments,
10533 }
10534 impl<'de> serde::Deserialize<'de> for GeneratedField {
10535 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10536 where
10537 D: serde::Deserializer<'de>,
10538 {
10539 struct GeneratedVisitor;
10540
10541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10542 type Value = GeneratedField;
10543
10544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10545 write!(formatter, "expected one of: {:?}", &FIELDS)
10546 }
10547
10548 #[allow(unused_variables)]
10549 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10550 where
10551 E: serde::de::Error,
10552 {
10553 match value {
10554 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
10555 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10556 }
10557 }
10558 }
10559 deserializer.deserialize_identifier(GeneratedVisitor)
10560 }
10561 }
10562 struct GeneratedVisitor;
10563 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10564 type Value = ListTableFragmentsResponse;
10565
10566 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10567 formatter.write_str("struct meta.ListTableFragmentsResponse")
10568 }
10569
10570 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
10571 where
10572 V: serde::de::MapAccess<'de>,
10573 {
10574 let mut table_fragments__ = None;
10575 while let Some(k) = map_.next_key()? {
10576 match k {
10577 GeneratedField::TableFragments => {
10578 if table_fragments__.is_some() {
10579 return Err(serde::de::Error::duplicate_field("tableFragments"));
10580 }
10581 table_fragments__ = Some(
10582 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10583 .into_iter().map(|(k,v)| (k.0, v)).collect()
10584 );
10585 }
10586 }
10587 }
10588 Ok(ListTableFragmentsResponse {
10589 table_fragments: table_fragments__.unwrap_or_default(),
10590 })
10591 }
10592 }
10593 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
10594 }
10595}
10596impl serde::Serialize for list_table_fragments_response::ActorInfo {
10597 #[allow(deprecated)]
10598 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10599 where
10600 S: serde::Serializer,
10601 {
10602 use serde::ser::SerializeStruct;
10603 let mut len = 0;
10604 if self.id != 0 {
10605 len += 1;
10606 }
10607 if self.node.is_some() {
10608 len += 1;
10609 }
10610 if !self.dispatcher.is_empty() {
10611 len += 1;
10612 }
10613 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
10614 if self.id != 0 {
10615 struct_ser.serialize_field("id", &self.id)?;
10616 }
10617 if let Some(v) = self.node.as_ref() {
10618 struct_ser.serialize_field("node", v)?;
10619 }
10620 if !self.dispatcher.is_empty() {
10621 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10622 }
10623 struct_ser.end()
10624 }
10625}
10626impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
10627 #[allow(deprecated)]
10628 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10629 where
10630 D: serde::Deserializer<'de>,
10631 {
10632 const FIELDS: &[&str] = &[
10633 "id",
10634 "node",
10635 "dispatcher",
10636 ];
10637
10638 #[allow(clippy::enum_variant_names)]
10639 enum GeneratedField {
10640 Id,
10641 Node,
10642 Dispatcher,
10643 }
10644 impl<'de> serde::Deserialize<'de> for GeneratedField {
10645 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10646 where
10647 D: serde::Deserializer<'de>,
10648 {
10649 struct GeneratedVisitor;
10650
10651 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10652 type Value = GeneratedField;
10653
10654 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10655 write!(formatter, "expected one of: {:?}", &FIELDS)
10656 }
10657
10658 #[allow(unused_variables)]
10659 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10660 where
10661 E: serde::de::Error,
10662 {
10663 match value {
10664 "id" => Ok(GeneratedField::Id),
10665 "node" => Ok(GeneratedField::Node),
10666 "dispatcher" => Ok(GeneratedField::Dispatcher),
10667 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10668 }
10669 }
10670 }
10671 deserializer.deserialize_identifier(GeneratedVisitor)
10672 }
10673 }
10674 struct GeneratedVisitor;
10675 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10676 type Value = list_table_fragments_response::ActorInfo;
10677
10678 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10679 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
10680 }
10681
10682 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
10683 where
10684 V: serde::de::MapAccess<'de>,
10685 {
10686 let mut id__ = None;
10687 let mut node__ = None;
10688 let mut dispatcher__ = None;
10689 while let Some(k) = map_.next_key()? {
10690 match k {
10691 GeneratedField::Id => {
10692 if id__.is_some() {
10693 return Err(serde::de::Error::duplicate_field("id"));
10694 }
10695 id__ =
10696 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10697 ;
10698 }
10699 GeneratedField::Node => {
10700 if node__.is_some() {
10701 return Err(serde::de::Error::duplicate_field("node"));
10702 }
10703 node__ = map_.next_value()?;
10704 }
10705 GeneratedField::Dispatcher => {
10706 if dispatcher__.is_some() {
10707 return Err(serde::de::Error::duplicate_field("dispatcher"));
10708 }
10709 dispatcher__ = Some(map_.next_value()?);
10710 }
10711 }
10712 }
10713 Ok(list_table_fragments_response::ActorInfo {
10714 id: id__.unwrap_or_default(),
10715 node: node__,
10716 dispatcher: dispatcher__.unwrap_or_default(),
10717 })
10718 }
10719 }
10720 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
10721 }
10722}
10723impl serde::Serialize for list_table_fragments_response::FragmentInfo {
10724 #[allow(deprecated)]
10725 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10726 where
10727 S: serde::Serializer,
10728 {
10729 use serde::ser::SerializeStruct;
10730 let mut len = 0;
10731 if self.id != 0 {
10732 len += 1;
10733 }
10734 if !self.actors.is_empty() {
10735 len += 1;
10736 }
10737 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
10738 if self.id != 0 {
10739 struct_ser.serialize_field("id", &self.id)?;
10740 }
10741 if !self.actors.is_empty() {
10742 struct_ser.serialize_field("actors", &self.actors)?;
10743 }
10744 struct_ser.end()
10745 }
10746}
10747impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
10748 #[allow(deprecated)]
10749 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10750 where
10751 D: serde::Deserializer<'de>,
10752 {
10753 const FIELDS: &[&str] = &[
10754 "id",
10755 "actors",
10756 ];
10757
10758 #[allow(clippy::enum_variant_names)]
10759 enum GeneratedField {
10760 Id,
10761 Actors,
10762 }
10763 impl<'de> serde::Deserialize<'de> for GeneratedField {
10764 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10765 where
10766 D: serde::Deserializer<'de>,
10767 {
10768 struct GeneratedVisitor;
10769
10770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10771 type Value = GeneratedField;
10772
10773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10774 write!(formatter, "expected one of: {:?}", &FIELDS)
10775 }
10776
10777 #[allow(unused_variables)]
10778 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10779 where
10780 E: serde::de::Error,
10781 {
10782 match value {
10783 "id" => Ok(GeneratedField::Id),
10784 "actors" => Ok(GeneratedField::Actors),
10785 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10786 }
10787 }
10788 }
10789 deserializer.deserialize_identifier(GeneratedVisitor)
10790 }
10791 }
10792 struct GeneratedVisitor;
10793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10794 type Value = list_table_fragments_response::FragmentInfo;
10795
10796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10797 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
10798 }
10799
10800 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
10801 where
10802 V: serde::de::MapAccess<'de>,
10803 {
10804 let mut id__ = None;
10805 let mut actors__ = None;
10806 while let Some(k) = map_.next_key()? {
10807 match k {
10808 GeneratedField::Id => {
10809 if id__.is_some() {
10810 return Err(serde::de::Error::duplicate_field("id"));
10811 }
10812 id__ =
10813 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10814 ;
10815 }
10816 GeneratedField::Actors => {
10817 if actors__.is_some() {
10818 return Err(serde::de::Error::duplicate_field("actors"));
10819 }
10820 actors__ = Some(map_.next_value()?);
10821 }
10822 }
10823 }
10824 Ok(list_table_fragments_response::FragmentInfo {
10825 id: id__.unwrap_or_default(),
10826 actors: actors__.unwrap_or_default(),
10827 })
10828 }
10829 }
10830 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
10831 }
10832}
10833impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
10834 #[allow(deprecated)]
10835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10836 where
10837 S: serde::Serializer,
10838 {
10839 use serde::ser::SerializeStruct;
10840 let mut len = 0;
10841 if !self.fragments.is_empty() {
10842 len += 1;
10843 }
10844 if self.ctx.is_some() {
10845 len += 1;
10846 }
10847 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
10848 if !self.fragments.is_empty() {
10849 struct_ser.serialize_field("fragments", &self.fragments)?;
10850 }
10851 if let Some(v) = self.ctx.as_ref() {
10852 struct_ser.serialize_field("ctx", v)?;
10853 }
10854 struct_ser.end()
10855 }
10856}
10857impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
10858 #[allow(deprecated)]
10859 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10860 where
10861 D: serde::Deserializer<'de>,
10862 {
10863 const FIELDS: &[&str] = &[
10864 "fragments",
10865 "ctx",
10866 ];
10867
10868 #[allow(clippy::enum_variant_names)]
10869 enum GeneratedField {
10870 Fragments,
10871 Ctx,
10872 }
10873 impl<'de> serde::Deserialize<'de> for GeneratedField {
10874 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10875 where
10876 D: serde::Deserializer<'de>,
10877 {
10878 struct GeneratedVisitor;
10879
10880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10881 type Value = GeneratedField;
10882
10883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10884 write!(formatter, "expected one of: {:?}", &FIELDS)
10885 }
10886
10887 #[allow(unused_variables)]
10888 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10889 where
10890 E: serde::de::Error,
10891 {
10892 match value {
10893 "fragments" => Ok(GeneratedField::Fragments),
10894 "ctx" => Ok(GeneratedField::Ctx),
10895 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10896 }
10897 }
10898 }
10899 deserializer.deserialize_identifier(GeneratedVisitor)
10900 }
10901 }
10902 struct GeneratedVisitor;
10903 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10904 type Value = list_table_fragments_response::TableFragmentInfo;
10905
10906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10907 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
10908 }
10909
10910 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
10911 where
10912 V: serde::de::MapAccess<'de>,
10913 {
10914 let mut fragments__ = None;
10915 let mut ctx__ = None;
10916 while let Some(k) = map_.next_key()? {
10917 match k {
10918 GeneratedField::Fragments => {
10919 if fragments__.is_some() {
10920 return Err(serde::de::Error::duplicate_field("fragments"));
10921 }
10922 fragments__ = Some(map_.next_value()?);
10923 }
10924 GeneratedField::Ctx => {
10925 if ctx__.is_some() {
10926 return Err(serde::de::Error::duplicate_field("ctx"));
10927 }
10928 ctx__ = map_.next_value()?;
10929 }
10930 }
10931 }
10932 Ok(list_table_fragments_response::TableFragmentInfo {
10933 fragments: fragments__.unwrap_or_default(),
10934 ctx: ctx__,
10935 })
10936 }
10937 }
10938 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
10939 }
10940}
10941impl serde::Serialize for MembersRequest {
10942 #[allow(deprecated)]
10943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10944 where
10945 S: serde::Serializer,
10946 {
10947 use serde::ser::SerializeStruct;
10948 let len = 0;
10949 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
10950 struct_ser.end()
10951 }
10952}
10953impl<'de> serde::Deserialize<'de> for MembersRequest {
10954 #[allow(deprecated)]
10955 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10956 where
10957 D: serde::Deserializer<'de>,
10958 {
10959 const FIELDS: &[&str] = &[
10960 ];
10961
10962 #[allow(clippy::enum_variant_names)]
10963 enum GeneratedField {
10964 }
10965 impl<'de> serde::Deserialize<'de> for GeneratedField {
10966 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10967 where
10968 D: serde::Deserializer<'de>,
10969 {
10970 struct GeneratedVisitor;
10971
10972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10973 type Value = GeneratedField;
10974
10975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10976 write!(formatter, "expected one of: {:?}", &FIELDS)
10977 }
10978
10979 #[allow(unused_variables)]
10980 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10981 where
10982 E: serde::de::Error,
10983 {
10984 Err(serde::de::Error::unknown_field(value, FIELDS))
10985 }
10986 }
10987 deserializer.deserialize_identifier(GeneratedVisitor)
10988 }
10989 }
10990 struct GeneratedVisitor;
10991 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10992 type Value = MembersRequest;
10993
10994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10995 formatter.write_str("struct meta.MembersRequest")
10996 }
10997
10998 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
10999 where
11000 V: serde::de::MapAccess<'de>,
11001 {
11002 while map_.next_key::<GeneratedField>()?.is_some() {
11003 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11004 }
11005 Ok(MembersRequest {
11006 })
11007 }
11008 }
11009 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
11010 }
11011}
11012impl serde::Serialize for MembersResponse {
11013 #[allow(deprecated)]
11014 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11015 where
11016 S: serde::Serializer,
11017 {
11018 use serde::ser::SerializeStruct;
11019 let mut len = 0;
11020 if !self.members.is_empty() {
11021 len += 1;
11022 }
11023 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
11024 if !self.members.is_empty() {
11025 struct_ser.serialize_field("members", &self.members)?;
11026 }
11027 struct_ser.end()
11028 }
11029}
11030impl<'de> serde::Deserialize<'de> for MembersResponse {
11031 #[allow(deprecated)]
11032 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11033 where
11034 D: serde::Deserializer<'de>,
11035 {
11036 const FIELDS: &[&str] = &[
11037 "members",
11038 ];
11039
11040 #[allow(clippy::enum_variant_names)]
11041 enum GeneratedField {
11042 Members,
11043 }
11044 impl<'de> serde::Deserialize<'de> for GeneratedField {
11045 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11046 where
11047 D: serde::Deserializer<'de>,
11048 {
11049 struct GeneratedVisitor;
11050
11051 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11052 type Value = GeneratedField;
11053
11054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11055 write!(formatter, "expected one of: {:?}", &FIELDS)
11056 }
11057
11058 #[allow(unused_variables)]
11059 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11060 where
11061 E: serde::de::Error,
11062 {
11063 match value {
11064 "members" => Ok(GeneratedField::Members),
11065 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11066 }
11067 }
11068 }
11069 deserializer.deserialize_identifier(GeneratedVisitor)
11070 }
11071 }
11072 struct GeneratedVisitor;
11073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11074 type Value = MembersResponse;
11075
11076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11077 formatter.write_str("struct meta.MembersResponse")
11078 }
11079
11080 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
11081 where
11082 V: serde::de::MapAccess<'de>,
11083 {
11084 let mut members__ = None;
11085 while let Some(k) = map_.next_key()? {
11086 match k {
11087 GeneratedField::Members => {
11088 if members__.is_some() {
11089 return Err(serde::de::Error::duplicate_field("members"));
11090 }
11091 members__ = Some(map_.next_value()?);
11092 }
11093 }
11094 }
11095 Ok(MembersResponse {
11096 members: members__.unwrap_or_default(),
11097 })
11098 }
11099 }
11100 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
11101 }
11102}
11103impl serde::Serialize for MetaMember {
11104 #[allow(deprecated)]
11105 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11106 where
11107 S: serde::Serializer,
11108 {
11109 use serde::ser::SerializeStruct;
11110 let mut len = 0;
11111 if self.address.is_some() {
11112 len += 1;
11113 }
11114 if self.is_leader {
11115 len += 1;
11116 }
11117 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
11118 if let Some(v) = self.address.as_ref() {
11119 struct_ser.serialize_field("address", v)?;
11120 }
11121 if self.is_leader {
11122 struct_ser.serialize_field("isLeader", &self.is_leader)?;
11123 }
11124 struct_ser.end()
11125 }
11126}
11127impl<'de> serde::Deserialize<'de> for MetaMember {
11128 #[allow(deprecated)]
11129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11130 where
11131 D: serde::Deserializer<'de>,
11132 {
11133 const FIELDS: &[&str] = &[
11134 "address",
11135 "is_leader",
11136 "isLeader",
11137 ];
11138
11139 #[allow(clippy::enum_variant_names)]
11140 enum GeneratedField {
11141 Address,
11142 IsLeader,
11143 }
11144 impl<'de> serde::Deserialize<'de> for GeneratedField {
11145 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11146 where
11147 D: serde::Deserializer<'de>,
11148 {
11149 struct GeneratedVisitor;
11150
11151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11152 type Value = GeneratedField;
11153
11154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11155 write!(formatter, "expected one of: {:?}", &FIELDS)
11156 }
11157
11158 #[allow(unused_variables)]
11159 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11160 where
11161 E: serde::de::Error,
11162 {
11163 match value {
11164 "address" => Ok(GeneratedField::Address),
11165 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
11166 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11167 }
11168 }
11169 }
11170 deserializer.deserialize_identifier(GeneratedVisitor)
11171 }
11172 }
11173 struct GeneratedVisitor;
11174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11175 type Value = MetaMember;
11176
11177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11178 formatter.write_str("struct meta.MetaMember")
11179 }
11180
11181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
11182 where
11183 V: serde::de::MapAccess<'de>,
11184 {
11185 let mut address__ = None;
11186 let mut is_leader__ = None;
11187 while let Some(k) = map_.next_key()? {
11188 match k {
11189 GeneratedField::Address => {
11190 if address__.is_some() {
11191 return Err(serde::de::Error::duplicate_field("address"));
11192 }
11193 address__ = map_.next_value()?;
11194 }
11195 GeneratedField::IsLeader => {
11196 if is_leader__.is_some() {
11197 return Err(serde::de::Error::duplicate_field("isLeader"));
11198 }
11199 is_leader__ = Some(map_.next_value()?);
11200 }
11201 }
11202 }
11203 Ok(MetaMember {
11204 address: address__,
11205 is_leader: is_leader__.unwrap_or_default(),
11206 })
11207 }
11208 }
11209 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
11210 }
11211}
11212impl serde::Serialize for MetaSnapshot {
11213 #[allow(deprecated)]
11214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11215 where
11216 S: serde::Serializer,
11217 {
11218 use serde::ser::SerializeStruct;
11219 let mut len = 0;
11220 if !self.databases.is_empty() {
11221 len += 1;
11222 }
11223 if !self.schemas.is_empty() {
11224 len += 1;
11225 }
11226 if !self.sources.is_empty() {
11227 len += 1;
11228 }
11229 if !self.sinks.is_empty() {
11230 len += 1;
11231 }
11232 if !self.tables.is_empty() {
11233 len += 1;
11234 }
11235 if !self.indexes.is_empty() {
11236 len += 1;
11237 }
11238 if !self.views.is_empty() {
11239 len += 1;
11240 }
11241 if !self.functions.is_empty() {
11242 len += 1;
11243 }
11244 if !self.connections.is_empty() {
11245 len += 1;
11246 }
11247 if !self.subscriptions.is_empty() {
11248 len += 1;
11249 }
11250 if !self.users.is_empty() {
11251 len += 1;
11252 }
11253 if self.session_params.is_some() {
11254 len += 1;
11255 }
11256 if !self.secrets.is_empty() {
11257 len += 1;
11258 }
11259 if self.compute_node_total_cpu_count != 0 {
11260 len += 1;
11261 }
11262 if !self.nodes.is_empty() {
11263 len += 1;
11264 }
11265 if self.hummock_version.is_some() {
11266 len += 1;
11267 }
11268 if self.meta_backup_manifest_id.is_some() {
11269 len += 1;
11270 }
11271 if self.hummock_write_limits.is_some() {
11272 len += 1;
11273 }
11274 if !self.streaming_worker_slot_mappings.is_empty() {
11275 len += 1;
11276 }
11277 if !self.serving_worker_slot_mappings.is_empty() {
11278 len += 1;
11279 }
11280 if self.version.is_some() {
11281 len += 1;
11282 }
11283 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
11284 if !self.databases.is_empty() {
11285 struct_ser.serialize_field("databases", &self.databases)?;
11286 }
11287 if !self.schemas.is_empty() {
11288 struct_ser.serialize_field("schemas", &self.schemas)?;
11289 }
11290 if !self.sources.is_empty() {
11291 struct_ser.serialize_field("sources", &self.sources)?;
11292 }
11293 if !self.sinks.is_empty() {
11294 struct_ser.serialize_field("sinks", &self.sinks)?;
11295 }
11296 if !self.tables.is_empty() {
11297 struct_ser.serialize_field("tables", &self.tables)?;
11298 }
11299 if !self.indexes.is_empty() {
11300 struct_ser.serialize_field("indexes", &self.indexes)?;
11301 }
11302 if !self.views.is_empty() {
11303 struct_ser.serialize_field("views", &self.views)?;
11304 }
11305 if !self.functions.is_empty() {
11306 struct_ser.serialize_field("functions", &self.functions)?;
11307 }
11308 if !self.connections.is_empty() {
11309 struct_ser.serialize_field("connections", &self.connections)?;
11310 }
11311 if !self.subscriptions.is_empty() {
11312 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
11313 }
11314 if !self.users.is_empty() {
11315 struct_ser.serialize_field("users", &self.users)?;
11316 }
11317 if let Some(v) = self.session_params.as_ref() {
11318 struct_ser.serialize_field("sessionParams", v)?;
11319 }
11320 if !self.secrets.is_empty() {
11321 struct_ser.serialize_field("secrets", &self.secrets)?;
11322 }
11323 if self.compute_node_total_cpu_count != 0 {
11324 #[allow(clippy::needless_borrow)]
11325 #[allow(clippy::needless_borrows_for_generic_args)]
11326 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&self.compute_node_total_cpu_count).as_str())?;
11327 }
11328 if !self.nodes.is_empty() {
11329 struct_ser.serialize_field("nodes", &self.nodes)?;
11330 }
11331 if let Some(v) = self.hummock_version.as_ref() {
11332 struct_ser.serialize_field("hummockVersion", v)?;
11333 }
11334 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
11335 struct_ser.serialize_field("metaBackupManifestId", v)?;
11336 }
11337 if let Some(v) = self.hummock_write_limits.as_ref() {
11338 struct_ser.serialize_field("hummockWriteLimits", v)?;
11339 }
11340 if !self.streaming_worker_slot_mappings.is_empty() {
11341 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
11342 }
11343 if !self.serving_worker_slot_mappings.is_empty() {
11344 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
11345 }
11346 if let Some(v) = self.version.as_ref() {
11347 struct_ser.serialize_field("version", v)?;
11348 }
11349 struct_ser.end()
11350 }
11351}
11352impl<'de> serde::Deserialize<'de> for MetaSnapshot {
11353 #[allow(deprecated)]
11354 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11355 where
11356 D: serde::Deserializer<'de>,
11357 {
11358 const FIELDS: &[&str] = &[
11359 "databases",
11360 "schemas",
11361 "sources",
11362 "sinks",
11363 "tables",
11364 "indexes",
11365 "views",
11366 "functions",
11367 "connections",
11368 "subscriptions",
11369 "users",
11370 "session_params",
11371 "sessionParams",
11372 "secrets",
11373 "compute_node_total_cpu_count",
11374 "computeNodeTotalCpuCount",
11375 "nodes",
11376 "hummock_version",
11377 "hummockVersion",
11378 "meta_backup_manifest_id",
11379 "metaBackupManifestId",
11380 "hummock_write_limits",
11381 "hummockWriteLimits",
11382 "streaming_worker_slot_mappings",
11383 "streamingWorkerSlotMappings",
11384 "serving_worker_slot_mappings",
11385 "servingWorkerSlotMappings",
11386 "version",
11387 ];
11388
11389 #[allow(clippy::enum_variant_names)]
11390 enum GeneratedField {
11391 Databases,
11392 Schemas,
11393 Sources,
11394 Sinks,
11395 Tables,
11396 Indexes,
11397 Views,
11398 Functions,
11399 Connections,
11400 Subscriptions,
11401 Users,
11402 SessionParams,
11403 Secrets,
11404 ComputeNodeTotalCpuCount,
11405 Nodes,
11406 HummockVersion,
11407 MetaBackupManifestId,
11408 HummockWriteLimits,
11409 StreamingWorkerSlotMappings,
11410 ServingWorkerSlotMappings,
11411 Version,
11412 }
11413 impl<'de> serde::Deserialize<'de> for GeneratedField {
11414 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11415 where
11416 D: serde::Deserializer<'de>,
11417 {
11418 struct GeneratedVisitor;
11419
11420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11421 type Value = GeneratedField;
11422
11423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11424 write!(formatter, "expected one of: {:?}", &FIELDS)
11425 }
11426
11427 #[allow(unused_variables)]
11428 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11429 where
11430 E: serde::de::Error,
11431 {
11432 match value {
11433 "databases" => Ok(GeneratedField::Databases),
11434 "schemas" => Ok(GeneratedField::Schemas),
11435 "sources" => Ok(GeneratedField::Sources),
11436 "sinks" => Ok(GeneratedField::Sinks),
11437 "tables" => Ok(GeneratedField::Tables),
11438 "indexes" => Ok(GeneratedField::Indexes),
11439 "views" => Ok(GeneratedField::Views),
11440 "functions" => Ok(GeneratedField::Functions),
11441 "connections" => Ok(GeneratedField::Connections),
11442 "subscriptions" => Ok(GeneratedField::Subscriptions),
11443 "users" => Ok(GeneratedField::Users),
11444 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
11445 "secrets" => Ok(GeneratedField::Secrets),
11446 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
11447 "nodes" => Ok(GeneratedField::Nodes),
11448 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
11449 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
11450 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
11451 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
11452 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
11453 "version" => Ok(GeneratedField::Version),
11454 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11455 }
11456 }
11457 }
11458 deserializer.deserialize_identifier(GeneratedVisitor)
11459 }
11460 }
11461 struct GeneratedVisitor;
11462 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11463 type Value = MetaSnapshot;
11464
11465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11466 formatter.write_str("struct meta.MetaSnapshot")
11467 }
11468
11469 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
11470 where
11471 V: serde::de::MapAccess<'de>,
11472 {
11473 let mut databases__ = None;
11474 let mut schemas__ = None;
11475 let mut sources__ = None;
11476 let mut sinks__ = None;
11477 let mut tables__ = None;
11478 let mut indexes__ = None;
11479 let mut views__ = None;
11480 let mut functions__ = None;
11481 let mut connections__ = None;
11482 let mut subscriptions__ = None;
11483 let mut users__ = None;
11484 let mut session_params__ = None;
11485 let mut secrets__ = None;
11486 let mut compute_node_total_cpu_count__ = None;
11487 let mut nodes__ = None;
11488 let mut hummock_version__ = None;
11489 let mut meta_backup_manifest_id__ = None;
11490 let mut hummock_write_limits__ = None;
11491 let mut streaming_worker_slot_mappings__ = None;
11492 let mut serving_worker_slot_mappings__ = None;
11493 let mut version__ = None;
11494 while let Some(k) = map_.next_key()? {
11495 match k {
11496 GeneratedField::Databases => {
11497 if databases__.is_some() {
11498 return Err(serde::de::Error::duplicate_field("databases"));
11499 }
11500 databases__ = Some(map_.next_value()?);
11501 }
11502 GeneratedField::Schemas => {
11503 if schemas__.is_some() {
11504 return Err(serde::de::Error::duplicate_field("schemas"));
11505 }
11506 schemas__ = Some(map_.next_value()?);
11507 }
11508 GeneratedField::Sources => {
11509 if sources__.is_some() {
11510 return Err(serde::de::Error::duplicate_field("sources"));
11511 }
11512 sources__ = Some(map_.next_value()?);
11513 }
11514 GeneratedField::Sinks => {
11515 if sinks__.is_some() {
11516 return Err(serde::de::Error::duplicate_field("sinks"));
11517 }
11518 sinks__ = Some(map_.next_value()?);
11519 }
11520 GeneratedField::Tables => {
11521 if tables__.is_some() {
11522 return Err(serde::de::Error::duplicate_field("tables"));
11523 }
11524 tables__ = Some(map_.next_value()?);
11525 }
11526 GeneratedField::Indexes => {
11527 if indexes__.is_some() {
11528 return Err(serde::de::Error::duplicate_field("indexes"));
11529 }
11530 indexes__ = Some(map_.next_value()?);
11531 }
11532 GeneratedField::Views => {
11533 if views__.is_some() {
11534 return Err(serde::de::Error::duplicate_field("views"));
11535 }
11536 views__ = Some(map_.next_value()?);
11537 }
11538 GeneratedField::Functions => {
11539 if functions__.is_some() {
11540 return Err(serde::de::Error::duplicate_field("functions"));
11541 }
11542 functions__ = Some(map_.next_value()?);
11543 }
11544 GeneratedField::Connections => {
11545 if connections__.is_some() {
11546 return Err(serde::de::Error::duplicate_field("connections"));
11547 }
11548 connections__ = Some(map_.next_value()?);
11549 }
11550 GeneratedField::Subscriptions => {
11551 if subscriptions__.is_some() {
11552 return Err(serde::de::Error::duplicate_field("subscriptions"));
11553 }
11554 subscriptions__ = Some(map_.next_value()?);
11555 }
11556 GeneratedField::Users => {
11557 if users__.is_some() {
11558 return Err(serde::de::Error::duplicate_field("users"));
11559 }
11560 users__ = Some(map_.next_value()?);
11561 }
11562 GeneratedField::SessionParams => {
11563 if session_params__.is_some() {
11564 return Err(serde::de::Error::duplicate_field("sessionParams"));
11565 }
11566 session_params__ = map_.next_value()?;
11567 }
11568 GeneratedField::Secrets => {
11569 if secrets__.is_some() {
11570 return Err(serde::de::Error::duplicate_field("secrets"));
11571 }
11572 secrets__ = Some(map_.next_value()?);
11573 }
11574 GeneratedField::ComputeNodeTotalCpuCount => {
11575 if compute_node_total_cpu_count__.is_some() {
11576 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
11577 }
11578 compute_node_total_cpu_count__ =
11579 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11580 ;
11581 }
11582 GeneratedField::Nodes => {
11583 if nodes__.is_some() {
11584 return Err(serde::de::Error::duplicate_field("nodes"));
11585 }
11586 nodes__ = Some(map_.next_value()?);
11587 }
11588 GeneratedField::HummockVersion => {
11589 if hummock_version__.is_some() {
11590 return Err(serde::de::Error::duplicate_field("hummockVersion"));
11591 }
11592 hummock_version__ = map_.next_value()?;
11593 }
11594 GeneratedField::MetaBackupManifestId => {
11595 if meta_backup_manifest_id__.is_some() {
11596 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
11597 }
11598 meta_backup_manifest_id__ = map_.next_value()?;
11599 }
11600 GeneratedField::HummockWriteLimits => {
11601 if hummock_write_limits__.is_some() {
11602 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
11603 }
11604 hummock_write_limits__ = map_.next_value()?;
11605 }
11606 GeneratedField::StreamingWorkerSlotMappings => {
11607 if streaming_worker_slot_mappings__.is_some() {
11608 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
11609 }
11610 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
11611 }
11612 GeneratedField::ServingWorkerSlotMappings => {
11613 if serving_worker_slot_mappings__.is_some() {
11614 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
11615 }
11616 serving_worker_slot_mappings__ = Some(map_.next_value()?);
11617 }
11618 GeneratedField::Version => {
11619 if version__.is_some() {
11620 return Err(serde::de::Error::duplicate_field("version"));
11621 }
11622 version__ = map_.next_value()?;
11623 }
11624 }
11625 }
11626 Ok(MetaSnapshot {
11627 databases: databases__.unwrap_or_default(),
11628 schemas: schemas__.unwrap_or_default(),
11629 sources: sources__.unwrap_or_default(),
11630 sinks: sinks__.unwrap_or_default(),
11631 tables: tables__.unwrap_or_default(),
11632 indexes: indexes__.unwrap_or_default(),
11633 views: views__.unwrap_or_default(),
11634 functions: functions__.unwrap_or_default(),
11635 connections: connections__.unwrap_or_default(),
11636 subscriptions: subscriptions__.unwrap_or_default(),
11637 users: users__.unwrap_or_default(),
11638 session_params: session_params__,
11639 secrets: secrets__.unwrap_or_default(),
11640 compute_node_total_cpu_count: compute_node_total_cpu_count__.unwrap_or_default(),
11641 nodes: nodes__.unwrap_or_default(),
11642 hummock_version: hummock_version__,
11643 meta_backup_manifest_id: meta_backup_manifest_id__,
11644 hummock_write_limits: hummock_write_limits__,
11645 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
11646 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
11647 version: version__,
11648 })
11649 }
11650 }
11651 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
11652 }
11653}
11654impl serde::Serialize for meta_snapshot::SnapshotVersion {
11655 #[allow(deprecated)]
11656 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11657 where
11658 S: serde::Serializer,
11659 {
11660 use serde::ser::SerializeStruct;
11661 let mut len = 0;
11662 if self.catalog_version != 0 {
11663 len += 1;
11664 }
11665 if self.worker_node_version != 0 {
11666 len += 1;
11667 }
11668 if self.streaming_worker_slot_mapping_version != 0 {
11669 len += 1;
11670 }
11671 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
11672 if self.catalog_version != 0 {
11673 #[allow(clippy::needless_borrow)]
11674 #[allow(clippy::needless_borrows_for_generic_args)]
11675 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
11676 }
11677 if self.worker_node_version != 0 {
11678 #[allow(clippy::needless_borrow)]
11679 #[allow(clippy::needless_borrows_for_generic_args)]
11680 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
11681 }
11682 if self.streaming_worker_slot_mapping_version != 0 {
11683 #[allow(clippy::needless_borrow)]
11684 #[allow(clippy::needless_borrows_for_generic_args)]
11685 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
11686 }
11687 struct_ser.end()
11688 }
11689}
11690impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
11691 #[allow(deprecated)]
11692 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11693 where
11694 D: serde::Deserializer<'de>,
11695 {
11696 const FIELDS: &[&str] = &[
11697 "catalog_version",
11698 "catalogVersion",
11699 "worker_node_version",
11700 "workerNodeVersion",
11701 "streaming_worker_slot_mapping_version",
11702 "streamingWorkerSlotMappingVersion",
11703 ];
11704
11705 #[allow(clippy::enum_variant_names)]
11706 enum GeneratedField {
11707 CatalogVersion,
11708 WorkerNodeVersion,
11709 StreamingWorkerSlotMappingVersion,
11710 }
11711 impl<'de> serde::Deserialize<'de> for GeneratedField {
11712 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11713 where
11714 D: serde::Deserializer<'de>,
11715 {
11716 struct GeneratedVisitor;
11717
11718 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11719 type Value = GeneratedField;
11720
11721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11722 write!(formatter, "expected one of: {:?}", &FIELDS)
11723 }
11724
11725 #[allow(unused_variables)]
11726 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11727 where
11728 E: serde::de::Error,
11729 {
11730 match value {
11731 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
11732 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
11733 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
11734 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11735 }
11736 }
11737 }
11738 deserializer.deserialize_identifier(GeneratedVisitor)
11739 }
11740 }
11741 struct GeneratedVisitor;
11742 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11743 type Value = meta_snapshot::SnapshotVersion;
11744
11745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11746 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
11747 }
11748
11749 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
11750 where
11751 V: serde::de::MapAccess<'de>,
11752 {
11753 let mut catalog_version__ = None;
11754 let mut worker_node_version__ = None;
11755 let mut streaming_worker_slot_mapping_version__ = None;
11756 while let Some(k) = map_.next_key()? {
11757 match k {
11758 GeneratedField::CatalogVersion => {
11759 if catalog_version__.is_some() {
11760 return Err(serde::de::Error::duplicate_field("catalogVersion"));
11761 }
11762 catalog_version__ =
11763 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11764 ;
11765 }
11766 GeneratedField::WorkerNodeVersion => {
11767 if worker_node_version__.is_some() {
11768 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
11769 }
11770 worker_node_version__ =
11771 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11772 ;
11773 }
11774 GeneratedField::StreamingWorkerSlotMappingVersion => {
11775 if streaming_worker_slot_mapping_version__.is_some() {
11776 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
11777 }
11778 streaming_worker_slot_mapping_version__ =
11779 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11780 ;
11781 }
11782 }
11783 }
11784 Ok(meta_snapshot::SnapshotVersion {
11785 catalog_version: catalog_version__.unwrap_or_default(),
11786 worker_node_version: worker_node_version__.unwrap_or_default(),
11787 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
11788 })
11789 }
11790 }
11791 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
11792 }
11793}
11794impl serde::Serialize for MigrationPlan {
11795 #[allow(deprecated)]
11796 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11797 where
11798 S: serde::Serializer,
11799 {
11800 use serde::ser::SerializeStruct;
11801 let mut len = 0;
11802 if !self.worker_slot_migration_plan.is_empty() {
11803 len += 1;
11804 }
11805 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
11806 if !self.worker_slot_migration_plan.is_empty() {
11807 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
11808 .map(|(k, v)| (k, v.to_string())).collect();
11809 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
11810 }
11811 struct_ser.end()
11812 }
11813}
11814impl<'de> serde::Deserialize<'de> for MigrationPlan {
11815 #[allow(deprecated)]
11816 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11817 where
11818 D: serde::Deserializer<'de>,
11819 {
11820 const FIELDS: &[&str] = &[
11821 "worker_slot_migration_plan",
11822 "workerSlotMigrationPlan",
11823 ];
11824
11825 #[allow(clippy::enum_variant_names)]
11826 enum GeneratedField {
11827 WorkerSlotMigrationPlan,
11828 }
11829 impl<'de> serde::Deserialize<'de> for GeneratedField {
11830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11831 where
11832 D: serde::Deserializer<'de>,
11833 {
11834 struct GeneratedVisitor;
11835
11836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11837 type Value = GeneratedField;
11838
11839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11840 write!(formatter, "expected one of: {:?}", &FIELDS)
11841 }
11842
11843 #[allow(unused_variables)]
11844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11845 where
11846 E: serde::de::Error,
11847 {
11848 match value {
11849 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
11850 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11851 }
11852 }
11853 }
11854 deserializer.deserialize_identifier(GeneratedVisitor)
11855 }
11856 }
11857 struct GeneratedVisitor;
11858 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11859 type Value = MigrationPlan;
11860
11861 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11862 formatter.write_str("struct meta.MigrationPlan")
11863 }
11864
11865 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
11866 where
11867 V: serde::de::MapAccess<'de>,
11868 {
11869 let mut worker_slot_migration_plan__ = None;
11870 while let Some(k) = map_.next_key()? {
11871 match k {
11872 GeneratedField::WorkerSlotMigrationPlan => {
11873 if worker_slot_migration_plan__.is_some() {
11874 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
11875 }
11876 worker_slot_migration_plan__ = Some(
11877 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
11878 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
11879 );
11880 }
11881 }
11882 }
11883 Ok(MigrationPlan {
11884 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
11885 })
11886 }
11887 }
11888 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
11889 }
11890}
11891impl serde::Serialize for Object {
11892 #[allow(deprecated)]
11893 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11894 where
11895 S: serde::Serializer,
11896 {
11897 use serde::ser::SerializeStruct;
11898 let mut len = 0;
11899 if self.object_info.is_some() {
11900 len += 1;
11901 }
11902 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
11903 if let Some(v) = self.object_info.as_ref() {
11904 match v {
11905 object::ObjectInfo::Database(v) => {
11906 struct_ser.serialize_field("database", v)?;
11907 }
11908 object::ObjectInfo::Schema(v) => {
11909 struct_ser.serialize_field("schema", v)?;
11910 }
11911 object::ObjectInfo::Table(v) => {
11912 struct_ser.serialize_field("table", v)?;
11913 }
11914 object::ObjectInfo::Index(v) => {
11915 struct_ser.serialize_field("index", v)?;
11916 }
11917 object::ObjectInfo::Source(v) => {
11918 struct_ser.serialize_field("source", v)?;
11919 }
11920 object::ObjectInfo::Sink(v) => {
11921 struct_ser.serialize_field("sink", v)?;
11922 }
11923 object::ObjectInfo::View(v) => {
11924 struct_ser.serialize_field("view", v)?;
11925 }
11926 object::ObjectInfo::Function(v) => {
11927 struct_ser.serialize_field("function", v)?;
11928 }
11929 object::ObjectInfo::Connection(v) => {
11930 struct_ser.serialize_field("connection", v)?;
11931 }
11932 object::ObjectInfo::Subscription(v) => {
11933 struct_ser.serialize_field("subscription", v)?;
11934 }
11935 object::ObjectInfo::Secret(v) => {
11936 struct_ser.serialize_field("secret", v)?;
11937 }
11938 }
11939 }
11940 struct_ser.end()
11941 }
11942}
11943impl<'de> serde::Deserialize<'de> for Object {
11944 #[allow(deprecated)]
11945 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11946 where
11947 D: serde::Deserializer<'de>,
11948 {
11949 const FIELDS: &[&str] = &[
11950 "database",
11951 "schema",
11952 "table",
11953 "index",
11954 "source",
11955 "sink",
11956 "view",
11957 "function",
11958 "connection",
11959 "subscription",
11960 "secret",
11961 ];
11962
11963 #[allow(clippy::enum_variant_names)]
11964 enum GeneratedField {
11965 Database,
11966 Schema,
11967 Table,
11968 Index,
11969 Source,
11970 Sink,
11971 View,
11972 Function,
11973 Connection,
11974 Subscription,
11975 Secret,
11976 }
11977 impl<'de> serde::Deserialize<'de> for GeneratedField {
11978 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11979 where
11980 D: serde::Deserializer<'de>,
11981 {
11982 struct GeneratedVisitor;
11983
11984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11985 type Value = GeneratedField;
11986
11987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11988 write!(formatter, "expected one of: {:?}", &FIELDS)
11989 }
11990
11991 #[allow(unused_variables)]
11992 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11993 where
11994 E: serde::de::Error,
11995 {
11996 match value {
11997 "database" => Ok(GeneratedField::Database),
11998 "schema" => Ok(GeneratedField::Schema),
11999 "table" => Ok(GeneratedField::Table),
12000 "index" => Ok(GeneratedField::Index),
12001 "source" => Ok(GeneratedField::Source),
12002 "sink" => Ok(GeneratedField::Sink),
12003 "view" => Ok(GeneratedField::View),
12004 "function" => Ok(GeneratedField::Function),
12005 "connection" => Ok(GeneratedField::Connection),
12006 "subscription" => Ok(GeneratedField::Subscription),
12007 "secret" => Ok(GeneratedField::Secret),
12008 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12009 }
12010 }
12011 }
12012 deserializer.deserialize_identifier(GeneratedVisitor)
12013 }
12014 }
12015 struct GeneratedVisitor;
12016 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12017 type Value = Object;
12018
12019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12020 formatter.write_str("struct meta.Object")
12021 }
12022
12023 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
12024 where
12025 V: serde::de::MapAccess<'de>,
12026 {
12027 let mut object_info__ = None;
12028 while let Some(k) = map_.next_key()? {
12029 match k {
12030 GeneratedField::Database => {
12031 if object_info__.is_some() {
12032 return Err(serde::de::Error::duplicate_field("database"));
12033 }
12034 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
12035;
12036 }
12037 GeneratedField::Schema => {
12038 if object_info__.is_some() {
12039 return Err(serde::de::Error::duplicate_field("schema"));
12040 }
12041 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
12042;
12043 }
12044 GeneratedField::Table => {
12045 if object_info__.is_some() {
12046 return Err(serde::de::Error::duplicate_field("table"));
12047 }
12048 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
12049;
12050 }
12051 GeneratedField::Index => {
12052 if object_info__.is_some() {
12053 return Err(serde::de::Error::duplicate_field("index"));
12054 }
12055 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
12056;
12057 }
12058 GeneratedField::Source => {
12059 if object_info__.is_some() {
12060 return Err(serde::de::Error::duplicate_field("source"));
12061 }
12062 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
12063;
12064 }
12065 GeneratedField::Sink => {
12066 if object_info__.is_some() {
12067 return Err(serde::de::Error::duplicate_field("sink"));
12068 }
12069 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
12070;
12071 }
12072 GeneratedField::View => {
12073 if object_info__.is_some() {
12074 return Err(serde::de::Error::duplicate_field("view"));
12075 }
12076 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
12077;
12078 }
12079 GeneratedField::Function => {
12080 if object_info__.is_some() {
12081 return Err(serde::de::Error::duplicate_field("function"));
12082 }
12083 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
12084;
12085 }
12086 GeneratedField::Connection => {
12087 if object_info__.is_some() {
12088 return Err(serde::de::Error::duplicate_field("connection"));
12089 }
12090 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
12091;
12092 }
12093 GeneratedField::Subscription => {
12094 if object_info__.is_some() {
12095 return Err(serde::de::Error::duplicate_field("subscription"));
12096 }
12097 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
12098;
12099 }
12100 GeneratedField::Secret => {
12101 if object_info__.is_some() {
12102 return Err(serde::de::Error::duplicate_field("secret"));
12103 }
12104 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
12105;
12106 }
12107 }
12108 }
12109 Ok(Object {
12110 object_info: object_info__,
12111 })
12112 }
12113 }
12114 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
12115 }
12116}
12117impl serde::Serialize for ObjectGroup {
12118 #[allow(deprecated)]
12119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12120 where
12121 S: serde::Serializer,
12122 {
12123 use serde::ser::SerializeStruct;
12124 let mut len = 0;
12125 if !self.objects.is_empty() {
12126 len += 1;
12127 }
12128 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
12129 if !self.objects.is_empty() {
12130 struct_ser.serialize_field("objects", &self.objects)?;
12131 }
12132 struct_ser.end()
12133 }
12134}
12135impl<'de> serde::Deserialize<'de> for ObjectGroup {
12136 #[allow(deprecated)]
12137 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12138 where
12139 D: serde::Deserializer<'de>,
12140 {
12141 const FIELDS: &[&str] = &[
12142 "objects",
12143 ];
12144
12145 #[allow(clippy::enum_variant_names)]
12146 enum GeneratedField {
12147 Objects,
12148 }
12149 impl<'de> serde::Deserialize<'de> for GeneratedField {
12150 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12151 where
12152 D: serde::Deserializer<'de>,
12153 {
12154 struct GeneratedVisitor;
12155
12156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12157 type Value = GeneratedField;
12158
12159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12160 write!(formatter, "expected one of: {:?}", &FIELDS)
12161 }
12162
12163 #[allow(unused_variables)]
12164 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12165 where
12166 E: serde::de::Error,
12167 {
12168 match value {
12169 "objects" => Ok(GeneratedField::Objects),
12170 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12171 }
12172 }
12173 }
12174 deserializer.deserialize_identifier(GeneratedVisitor)
12175 }
12176 }
12177 struct GeneratedVisitor;
12178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12179 type Value = ObjectGroup;
12180
12181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12182 formatter.write_str("struct meta.ObjectGroup")
12183 }
12184
12185 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
12186 where
12187 V: serde::de::MapAccess<'de>,
12188 {
12189 let mut objects__ = None;
12190 while let Some(k) = map_.next_key()? {
12191 match k {
12192 GeneratedField::Objects => {
12193 if objects__.is_some() {
12194 return Err(serde::de::Error::duplicate_field("objects"));
12195 }
12196 objects__ = Some(map_.next_value()?);
12197 }
12198 }
12199 }
12200 Ok(ObjectGroup {
12201 objects: objects__.unwrap_or_default(),
12202 })
12203 }
12204 }
12205 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
12206 }
12207}
12208impl serde::Serialize for PauseRequest {
12209 #[allow(deprecated)]
12210 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12211 where
12212 S: serde::Serializer,
12213 {
12214 use serde::ser::SerializeStruct;
12215 let len = 0;
12216 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
12217 struct_ser.end()
12218 }
12219}
12220impl<'de> serde::Deserialize<'de> for PauseRequest {
12221 #[allow(deprecated)]
12222 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12223 where
12224 D: serde::Deserializer<'de>,
12225 {
12226 const FIELDS: &[&str] = &[
12227 ];
12228
12229 #[allow(clippy::enum_variant_names)]
12230 enum GeneratedField {
12231 }
12232 impl<'de> serde::Deserialize<'de> for GeneratedField {
12233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12234 where
12235 D: serde::Deserializer<'de>,
12236 {
12237 struct GeneratedVisitor;
12238
12239 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12240 type Value = GeneratedField;
12241
12242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12243 write!(formatter, "expected one of: {:?}", &FIELDS)
12244 }
12245
12246 #[allow(unused_variables)]
12247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12248 where
12249 E: serde::de::Error,
12250 {
12251 Err(serde::de::Error::unknown_field(value, FIELDS))
12252 }
12253 }
12254 deserializer.deserialize_identifier(GeneratedVisitor)
12255 }
12256 }
12257 struct GeneratedVisitor;
12258 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12259 type Value = PauseRequest;
12260
12261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12262 formatter.write_str("struct meta.PauseRequest")
12263 }
12264
12265 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
12266 where
12267 V: serde::de::MapAccess<'de>,
12268 {
12269 while map_.next_key::<GeneratedField>()?.is_some() {
12270 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12271 }
12272 Ok(PauseRequest {
12273 })
12274 }
12275 }
12276 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
12277 }
12278}
12279impl serde::Serialize for PauseResponse {
12280 #[allow(deprecated)]
12281 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12282 where
12283 S: serde::Serializer,
12284 {
12285 use serde::ser::SerializeStruct;
12286 let len = 0;
12287 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
12288 struct_ser.end()
12289 }
12290}
12291impl<'de> serde::Deserialize<'de> for PauseResponse {
12292 #[allow(deprecated)]
12293 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12294 where
12295 D: serde::Deserializer<'de>,
12296 {
12297 const FIELDS: &[&str] = &[
12298 ];
12299
12300 #[allow(clippy::enum_variant_names)]
12301 enum GeneratedField {
12302 }
12303 impl<'de> serde::Deserialize<'de> for GeneratedField {
12304 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12305 where
12306 D: serde::Deserializer<'de>,
12307 {
12308 struct GeneratedVisitor;
12309
12310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12311 type Value = GeneratedField;
12312
12313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12314 write!(formatter, "expected one of: {:?}", &FIELDS)
12315 }
12316
12317 #[allow(unused_variables)]
12318 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12319 where
12320 E: serde::de::Error,
12321 {
12322 Err(serde::de::Error::unknown_field(value, FIELDS))
12323 }
12324 }
12325 deserializer.deserialize_identifier(GeneratedVisitor)
12326 }
12327 }
12328 struct GeneratedVisitor;
12329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12330 type Value = PauseResponse;
12331
12332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12333 formatter.write_str("struct meta.PauseResponse")
12334 }
12335
12336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
12337 where
12338 V: serde::de::MapAccess<'de>,
12339 {
12340 while map_.next_key::<GeneratedField>()?.is_some() {
12341 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12342 }
12343 Ok(PauseResponse {
12344 })
12345 }
12346 }
12347 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
12348 }
12349}
12350impl serde::Serialize for RecoverRequest {
12351 #[allow(deprecated)]
12352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12353 where
12354 S: serde::Serializer,
12355 {
12356 use serde::ser::SerializeStruct;
12357 let len = 0;
12358 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
12359 struct_ser.end()
12360 }
12361}
12362impl<'de> serde::Deserialize<'de> for RecoverRequest {
12363 #[allow(deprecated)]
12364 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12365 where
12366 D: serde::Deserializer<'de>,
12367 {
12368 const FIELDS: &[&str] = &[
12369 ];
12370
12371 #[allow(clippy::enum_variant_names)]
12372 enum GeneratedField {
12373 }
12374 impl<'de> serde::Deserialize<'de> for GeneratedField {
12375 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12376 where
12377 D: serde::Deserializer<'de>,
12378 {
12379 struct GeneratedVisitor;
12380
12381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12382 type Value = GeneratedField;
12383
12384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12385 write!(formatter, "expected one of: {:?}", &FIELDS)
12386 }
12387
12388 #[allow(unused_variables)]
12389 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12390 where
12391 E: serde::de::Error,
12392 {
12393 Err(serde::de::Error::unknown_field(value, FIELDS))
12394 }
12395 }
12396 deserializer.deserialize_identifier(GeneratedVisitor)
12397 }
12398 }
12399 struct GeneratedVisitor;
12400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12401 type Value = RecoverRequest;
12402
12403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12404 formatter.write_str("struct meta.RecoverRequest")
12405 }
12406
12407 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
12408 where
12409 V: serde::de::MapAccess<'de>,
12410 {
12411 while map_.next_key::<GeneratedField>()?.is_some() {
12412 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12413 }
12414 Ok(RecoverRequest {
12415 })
12416 }
12417 }
12418 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
12419 }
12420}
12421impl serde::Serialize for RecoverResponse {
12422 #[allow(deprecated)]
12423 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12424 where
12425 S: serde::Serializer,
12426 {
12427 use serde::ser::SerializeStruct;
12428 let len = 0;
12429 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
12430 struct_ser.end()
12431 }
12432}
12433impl<'de> serde::Deserialize<'de> for RecoverResponse {
12434 #[allow(deprecated)]
12435 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12436 where
12437 D: serde::Deserializer<'de>,
12438 {
12439 const FIELDS: &[&str] = &[
12440 ];
12441
12442 #[allow(clippy::enum_variant_names)]
12443 enum GeneratedField {
12444 }
12445 impl<'de> serde::Deserialize<'de> for GeneratedField {
12446 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12447 where
12448 D: serde::Deserializer<'de>,
12449 {
12450 struct GeneratedVisitor;
12451
12452 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12453 type Value = GeneratedField;
12454
12455 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12456 write!(formatter, "expected one of: {:?}", &FIELDS)
12457 }
12458
12459 #[allow(unused_variables)]
12460 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12461 where
12462 E: serde::de::Error,
12463 {
12464 Err(serde::de::Error::unknown_field(value, FIELDS))
12465 }
12466 }
12467 deserializer.deserialize_identifier(GeneratedVisitor)
12468 }
12469 }
12470 struct GeneratedVisitor;
12471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12472 type Value = RecoverResponse;
12473
12474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12475 formatter.write_str("struct meta.RecoverResponse")
12476 }
12477
12478 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
12479 where
12480 V: serde::de::MapAccess<'de>,
12481 {
12482 while map_.next_key::<GeneratedField>()?.is_some() {
12483 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12484 }
12485 Ok(RecoverResponse {
12486 })
12487 }
12488 }
12489 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
12490 }
12491}
12492impl serde::Serialize for Recovery {
12493 #[allow(deprecated)]
12494 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12495 where
12496 S: serde::Serializer,
12497 {
12498 use serde::ser::SerializeStruct;
12499 let len = 0;
12500 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
12501 struct_ser.end()
12502 }
12503}
12504impl<'de> serde::Deserialize<'de> for Recovery {
12505 #[allow(deprecated)]
12506 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12507 where
12508 D: serde::Deserializer<'de>,
12509 {
12510 const FIELDS: &[&str] = &[
12511 ];
12512
12513 #[allow(clippy::enum_variant_names)]
12514 enum GeneratedField {
12515 }
12516 impl<'de> serde::Deserialize<'de> for GeneratedField {
12517 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12518 where
12519 D: serde::Deserializer<'de>,
12520 {
12521 struct GeneratedVisitor;
12522
12523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12524 type Value = GeneratedField;
12525
12526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12527 write!(formatter, "expected one of: {:?}", &FIELDS)
12528 }
12529
12530 #[allow(unused_variables)]
12531 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12532 where
12533 E: serde::de::Error,
12534 {
12535 Err(serde::de::Error::unknown_field(value, FIELDS))
12536 }
12537 }
12538 deserializer.deserialize_identifier(GeneratedVisitor)
12539 }
12540 }
12541 struct GeneratedVisitor;
12542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12543 type Value = Recovery;
12544
12545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12546 formatter.write_str("struct meta.Recovery")
12547 }
12548
12549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
12550 where
12551 V: serde::de::MapAccess<'de>,
12552 {
12553 while map_.next_key::<GeneratedField>()?.is_some() {
12554 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12555 }
12556 Ok(Recovery {
12557 })
12558 }
12559 }
12560 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
12561 }
12562}
12563impl serde::Serialize for RecoveryStatus {
12564 #[allow(deprecated)]
12565 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12566 where
12567 S: serde::Serializer,
12568 {
12569 let variant = match self {
12570 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
12571 Self::StatusStarting => "STATUS_STARTING",
12572 Self::StatusRecovering => "STATUS_RECOVERING",
12573 Self::StatusRunning => "STATUS_RUNNING",
12574 };
12575 serializer.serialize_str(variant)
12576 }
12577}
12578impl<'de> serde::Deserialize<'de> for RecoveryStatus {
12579 #[allow(deprecated)]
12580 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12581 where
12582 D: serde::Deserializer<'de>,
12583 {
12584 const FIELDS: &[&str] = &[
12585 "STATUS_UNSPECIFIED",
12586 "STATUS_STARTING",
12587 "STATUS_RECOVERING",
12588 "STATUS_RUNNING",
12589 ];
12590
12591 struct GeneratedVisitor;
12592
12593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12594 type Value = RecoveryStatus;
12595
12596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12597 write!(formatter, "expected one of: {:?}", &FIELDS)
12598 }
12599
12600 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12601 where
12602 E: serde::de::Error,
12603 {
12604 i32::try_from(v)
12605 .ok()
12606 .and_then(|x| x.try_into().ok())
12607 .ok_or_else(|| {
12608 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12609 })
12610 }
12611
12612 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12613 where
12614 E: serde::de::Error,
12615 {
12616 i32::try_from(v)
12617 .ok()
12618 .and_then(|x| x.try_into().ok())
12619 .ok_or_else(|| {
12620 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12621 })
12622 }
12623
12624 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12625 where
12626 E: serde::de::Error,
12627 {
12628 match value {
12629 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
12630 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
12631 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
12632 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
12633 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12634 }
12635 }
12636 }
12637 deserializer.deserialize_any(GeneratedVisitor)
12638 }
12639}
12640impl serde::Serialize for RelationIdInfos {
12641 #[allow(deprecated)]
12642 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12643 where
12644 S: serde::Serializer,
12645 {
12646 use serde::ser::SerializeStruct;
12647 let mut len = 0;
12648 if !self.map.is_empty() {
12649 len += 1;
12650 }
12651 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
12652 if !self.map.is_empty() {
12653 struct_ser.serialize_field("map", &self.map)?;
12654 }
12655 struct_ser.end()
12656 }
12657}
12658impl<'de> serde::Deserialize<'de> for RelationIdInfos {
12659 #[allow(deprecated)]
12660 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12661 where
12662 D: serde::Deserializer<'de>,
12663 {
12664 const FIELDS: &[&str] = &[
12665 "map",
12666 ];
12667
12668 #[allow(clippy::enum_variant_names)]
12669 enum GeneratedField {
12670 Map,
12671 }
12672 impl<'de> serde::Deserialize<'de> for GeneratedField {
12673 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12674 where
12675 D: serde::Deserializer<'de>,
12676 {
12677 struct GeneratedVisitor;
12678
12679 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12680 type Value = GeneratedField;
12681
12682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12683 write!(formatter, "expected one of: {:?}", &FIELDS)
12684 }
12685
12686 #[allow(unused_variables)]
12687 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12688 where
12689 E: serde::de::Error,
12690 {
12691 match value {
12692 "map" => Ok(GeneratedField::Map),
12693 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12694 }
12695 }
12696 }
12697 deserializer.deserialize_identifier(GeneratedVisitor)
12698 }
12699 }
12700 struct GeneratedVisitor;
12701 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12702 type Value = RelationIdInfos;
12703
12704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12705 formatter.write_str("struct meta.RelationIdInfos")
12706 }
12707
12708 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
12709 where
12710 V: serde::de::MapAccess<'de>,
12711 {
12712 let mut map__ = None;
12713 while let Some(k) = map_.next_key()? {
12714 match k {
12715 GeneratedField::Map => {
12716 if map__.is_some() {
12717 return Err(serde::de::Error::duplicate_field("map"));
12718 }
12719 map__ = Some(
12720 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12721 .into_iter().map(|(k,v)| (k.0, v)).collect()
12722 );
12723 }
12724 }
12725 }
12726 Ok(RelationIdInfos {
12727 map: map__.unwrap_or_default(),
12728 })
12729 }
12730 }
12731 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
12732 }
12733}
12734impl serde::Serialize for RescheduleRequest {
12735 #[allow(deprecated)]
12736 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12737 where
12738 S: serde::Serializer,
12739 {
12740 use serde::ser::SerializeStruct;
12741 let mut len = 0;
12742 if self.revision != 0 {
12743 len += 1;
12744 }
12745 if self.resolve_no_shuffle_upstream {
12746 len += 1;
12747 }
12748 if !self.worker_reschedules.is_empty() {
12749 len += 1;
12750 }
12751 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
12752 if self.revision != 0 {
12753 #[allow(clippy::needless_borrow)]
12754 #[allow(clippy::needless_borrows_for_generic_args)]
12755 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
12756 }
12757 if self.resolve_no_shuffle_upstream {
12758 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
12759 }
12760 if !self.worker_reschedules.is_empty() {
12761 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
12762 }
12763 struct_ser.end()
12764 }
12765}
12766impl<'de> serde::Deserialize<'de> for RescheduleRequest {
12767 #[allow(deprecated)]
12768 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12769 where
12770 D: serde::Deserializer<'de>,
12771 {
12772 const FIELDS: &[&str] = &[
12773 "revision",
12774 "resolve_no_shuffle_upstream",
12775 "resolveNoShuffleUpstream",
12776 "worker_reschedules",
12777 "workerReschedules",
12778 ];
12779
12780 #[allow(clippy::enum_variant_names)]
12781 enum GeneratedField {
12782 Revision,
12783 ResolveNoShuffleUpstream,
12784 WorkerReschedules,
12785 }
12786 impl<'de> serde::Deserialize<'de> for GeneratedField {
12787 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12788 where
12789 D: serde::Deserializer<'de>,
12790 {
12791 struct GeneratedVisitor;
12792
12793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12794 type Value = GeneratedField;
12795
12796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12797 write!(formatter, "expected one of: {:?}", &FIELDS)
12798 }
12799
12800 #[allow(unused_variables)]
12801 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12802 where
12803 E: serde::de::Error,
12804 {
12805 match value {
12806 "revision" => Ok(GeneratedField::Revision),
12807 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
12808 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
12809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12810 }
12811 }
12812 }
12813 deserializer.deserialize_identifier(GeneratedVisitor)
12814 }
12815 }
12816 struct GeneratedVisitor;
12817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12818 type Value = RescheduleRequest;
12819
12820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12821 formatter.write_str("struct meta.RescheduleRequest")
12822 }
12823
12824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
12825 where
12826 V: serde::de::MapAccess<'de>,
12827 {
12828 let mut revision__ = None;
12829 let mut resolve_no_shuffle_upstream__ = None;
12830 let mut worker_reschedules__ = None;
12831 while let Some(k) = map_.next_key()? {
12832 match k {
12833 GeneratedField::Revision => {
12834 if revision__.is_some() {
12835 return Err(serde::de::Error::duplicate_field("revision"));
12836 }
12837 revision__ =
12838 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12839 ;
12840 }
12841 GeneratedField::ResolveNoShuffleUpstream => {
12842 if resolve_no_shuffle_upstream__.is_some() {
12843 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
12844 }
12845 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
12846 }
12847 GeneratedField::WorkerReschedules => {
12848 if worker_reschedules__.is_some() {
12849 return Err(serde::de::Error::duplicate_field("workerReschedules"));
12850 }
12851 worker_reschedules__ = Some(
12852 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12853 .into_iter().map(|(k,v)| (k.0, v)).collect()
12854 );
12855 }
12856 }
12857 }
12858 Ok(RescheduleRequest {
12859 revision: revision__.unwrap_or_default(),
12860 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
12861 worker_reschedules: worker_reschedules__.unwrap_or_default(),
12862 })
12863 }
12864 }
12865 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
12866 }
12867}
12868impl serde::Serialize for RescheduleResponse {
12869 #[allow(deprecated)]
12870 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12871 where
12872 S: serde::Serializer,
12873 {
12874 use serde::ser::SerializeStruct;
12875 let mut len = 0;
12876 if self.success {
12877 len += 1;
12878 }
12879 if self.revision != 0 {
12880 len += 1;
12881 }
12882 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
12883 if self.success {
12884 struct_ser.serialize_field("success", &self.success)?;
12885 }
12886 if self.revision != 0 {
12887 #[allow(clippy::needless_borrow)]
12888 #[allow(clippy::needless_borrows_for_generic_args)]
12889 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
12890 }
12891 struct_ser.end()
12892 }
12893}
12894impl<'de> serde::Deserialize<'de> for RescheduleResponse {
12895 #[allow(deprecated)]
12896 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12897 where
12898 D: serde::Deserializer<'de>,
12899 {
12900 const FIELDS: &[&str] = &[
12901 "success",
12902 "revision",
12903 ];
12904
12905 #[allow(clippy::enum_variant_names)]
12906 enum GeneratedField {
12907 Success,
12908 Revision,
12909 }
12910 impl<'de> serde::Deserialize<'de> for GeneratedField {
12911 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12912 where
12913 D: serde::Deserializer<'de>,
12914 {
12915 struct GeneratedVisitor;
12916
12917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12918 type Value = GeneratedField;
12919
12920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12921 write!(formatter, "expected one of: {:?}", &FIELDS)
12922 }
12923
12924 #[allow(unused_variables)]
12925 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12926 where
12927 E: serde::de::Error,
12928 {
12929 match value {
12930 "success" => Ok(GeneratedField::Success),
12931 "revision" => Ok(GeneratedField::Revision),
12932 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12933 }
12934 }
12935 }
12936 deserializer.deserialize_identifier(GeneratedVisitor)
12937 }
12938 }
12939 struct GeneratedVisitor;
12940 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12941 type Value = RescheduleResponse;
12942
12943 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12944 formatter.write_str("struct meta.RescheduleResponse")
12945 }
12946
12947 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
12948 where
12949 V: serde::de::MapAccess<'de>,
12950 {
12951 let mut success__ = None;
12952 let mut revision__ = None;
12953 while let Some(k) = map_.next_key()? {
12954 match k {
12955 GeneratedField::Success => {
12956 if success__.is_some() {
12957 return Err(serde::de::Error::duplicate_field("success"));
12958 }
12959 success__ = Some(map_.next_value()?);
12960 }
12961 GeneratedField::Revision => {
12962 if revision__.is_some() {
12963 return Err(serde::de::Error::duplicate_field("revision"));
12964 }
12965 revision__ =
12966 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12967 ;
12968 }
12969 }
12970 }
12971 Ok(RescheduleResponse {
12972 success: success__.unwrap_or_default(),
12973 revision: revision__.unwrap_or_default(),
12974 })
12975 }
12976 }
12977 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
12978 }
12979}
12980impl serde::Serialize for ResumeRequest {
12981 #[allow(deprecated)]
12982 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12983 where
12984 S: serde::Serializer,
12985 {
12986 use serde::ser::SerializeStruct;
12987 let len = 0;
12988 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
12989 struct_ser.end()
12990 }
12991}
12992impl<'de> serde::Deserialize<'de> for ResumeRequest {
12993 #[allow(deprecated)]
12994 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12995 where
12996 D: serde::Deserializer<'de>,
12997 {
12998 const FIELDS: &[&str] = &[
12999 ];
13000
13001 #[allow(clippy::enum_variant_names)]
13002 enum GeneratedField {
13003 }
13004 impl<'de> serde::Deserialize<'de> for GeneratedField {
13005 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13006 where
13007 D: serde::Deserializer<'de>,
13008 {
13009 struct GeneratedVisitor;
13010
13011 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13012 type Value = GeneratedField;
13013
13014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13015 write!(formatter, "expected one of: {:?}", &FIELDS)
13016 }
13017
13018 #[allow(unused_variables)]
13019 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13020 where
13021 E: serde::de::Error,
13022 {
13023 Err(serde::de::Error::unknown_field(value, FIELDS))
13024 }
13025 }
13026 deserializer.deserialize_identifier(GeneratedVisitor)
13027 }
13028 }
13029 struct GeneratedVisitor;
13030 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13031 type Value = ResumeRequest;
13032
13033 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13034 formatter.write_str("struct meta.ResumeRequest")
13035 }
13036
13037 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
13038 where
13039 V: serde::de::MapAccess<'de>,
13040 {
13041 while map_.next_key::<GeneratedField>()?.is_some() {
13042 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13043 }
13044 Ok(ResumeRequest {
13045 })
13046 }
13047 }
13048 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
13049 }
13050}
13051impl serde::Serialize for ResumeResponse {
13052 #[allow(deprecated)]
13053 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13054 where
13055 S: serde::Serializer,
13056 {
13057 use serde::ser::SerializeStruct;
13058 let len = 0;
13059 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
13060 struct_ser.end()
13061 }
13062}
13063impl<'de> serde::Deserialize<'de> for ResumeResponse {
13064 #[allow(deprecated)]
13065 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13066 where
13067 D: serde::Deserializer<'de>,
13068 {
13069 const FIELDS: &[&str] = &[
13070 ];
13071
13072 #[allow(clippy::enum_variant_names)]
13073 enum GeneratedField {
13074 }
13075 impl<'de> serde::Deserialize<'de> for GeneratedField {
13076 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13077 where
13078 D: serde::Deserializer<'de>,
13079 {
13080 struct GeneratedVisitor;
13081
13082 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13083 type Value = GeneratedField;
13084
13085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13086 write!(formatter, "expected one of: {:?}", &FIELDS)
13087 }
13088
13089 #[allow(unused_variables)]
13090 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13091 where
13092 E: serde::de::Error,
13093 {
13094 Err(serde::de::Error::unknown_field(value, FIELDS))
13095 }
13096 }
13097 deserializer.deserialize_identifier(GeneratedVisitor)
13098 }
13099 }
13100 struct GeneratedVisitor;
13101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13102 type Value = ResumeResponse;
13103
13104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13105 formatter.write_str("struct meta.ResumeResponse")
13106 }
13107
13108 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
13109 where
13110 V: serde::de::MapAccess<'de>,
13111 {
13112 while map_.next_key::<GeneratedField>()?.is_some() {
13113 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13114 }
13115 Ok(ResumeResponse {
13116 })
13117 }
13118 }
13119 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
13120 }
13121}
13122impl serde::Serialize for SetSessionParamRequest {
13123 #[allow(deprecated)]
13124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13125 where
13126 S: serde::Serializer,
13127 {
13128 use serde::ser::SerializeStruct;
13129 let mut len = 0;
13130 if !self.param.is_empty() {
13131 len += 1;
13132 }
13133 if self.value.is_some() {
13134 len += 1;
13135 }
13136 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
13137 if !self.param.is_empty() {
13138 struct_ser.serialize_field("param", &self.param)?;
13139 }
13140 if let Some(v) = self.value.as_ref() {
13141 struct_ser.serialize_field("value", v)?;
13142 }
13143 struct_ser.end()
13144 }
13145}
13146impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
13147 #[allow(deprecated)]
13148 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13149 where
13150 D: serde::Deserializer<'de>,
13151 {
13152 const FIELDS: &[&str] = &[
13153 "param",
13154 "value",
13155 ];
13156
13157 #[allow(clippy::enum_variant_names)]
13158 enum GeneratedField {
13159 Param,
13160 Value,
13161 }
13162 impl<'de> serde::Deserialize<'de> for GeneratedField {
13163 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13164 where
13165 D: serde::Deserializer<'de>,
13166 {
13167 struct GeneratedVisitor;
13168
13169 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13170 type Value = GeneratedField;
13171
13172 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13173 write!(formatter, "expected one of: {:?}", &FIELDS)
13174 }
13175
13176 #[allow(unused_variables)]
13177 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13178 where
13179 E: serde::de::Error,
13180 {
13181 match value {
13182 "param" => Ok(GeneratedField::Param),
13183 "value" => Ok(GeneratedField::Value),
13184 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13185 }
13186 }
13187 }
13188 deserializer.deserialize_identifier(GeneratedVisitor)
13189 }
13190 }
13191 struct GeneratedVisitor;
13192 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13193 type Value = SetSessionParamRequest;
13194
13195 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13196 formatter.write_str("struct meta.SetSessionParamRequest")
13197 }
13198
13199 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
13200 where
13201 V: serde::de::MapAccess<'de>,
13202 {
13203 let mut param__ = None;
13204 let mut value__ = None;
13205 while let Some(k) = map_.next_key()? {
13206 match k {
13207 GeneratedField::Param => {
13208 if param__.is_some() {
13209 return Err(serde::de::Error::duplicate_field("param"));
13210 }
13211 param__ = Some(map_.next_value()?);
13212 }
13213 GeneratedField::Value => {
13214 if value__.is_some() {
13215 return Err(serde::de::Error::duplicate_field("value"));
13216 }
13217 value__ = map_.next_value()?;
13218 }
13219 }
13220 }
13221 Ok(SetSessionParamRequest {
13222 param: param__.unwrap_or_default(),
13223 value: value__,
13224 })
13225 }
13226 }
13227 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
13228 }
13229}
13230impl serde::Serialize for SetSessionParamResponse {
13231 #[allow(deprecated)]
13232 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13233 where
13234 S: serde::Serializer,
13235 {
13236 use serde::ser::SerializeStruct;
13237 let mut len = 0;
13238 if !self.param.is_empty() {
13239 len += 1;
13240 }
13241 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
13242 if !self.param.is_empty() {
13243 struct_ser.serialize_field("param", &self.param)?;
13244 }
13245 struct_ser.end()
13246 }
13247}
13248impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
13249 #[allow(deprecated)]
13250 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13251 where
13252 D: serde::Deserializer<'de>,
13253 {
13254 const FIELDS: &[&str] = &[
13255 "param",
13256 ];
13257
13258 #[allow(clippy::enum_variant_names)]
13259 enum GeneratedField {
13260 Param,
13261 }
13262 impl<'de> serde::Deserialize<'de> for GeneratedField {
13263 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13264 where
13265 D: serde::Deserializer<'de>,
13266 {
13267 struct GeneratedVisitor;
13268
13269 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13270 type Value = GeneratedField;
13271
13272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13273 write!(formatter, "expected one of: {:?}", &FIELDS)
13274 }
13275
13276 #[allow(unused_variables)]
13277 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13278 where
13279 E: serde::de::Error,
13280 {
13281 match value {
13282 "param" => Ok(GeneratedField::Param),
13283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13284 }
13285 }
13286 }
13287 deserializer.deserialize_identifier(GeneratedVisitor)
13288 }
13289 }
13290 struct GeneratedVisitor;
13291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13292 type Value = SetSessionParamResponse;
13293
13294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13295 formatter.write_str("struct meta.SetSessionParamResponse")
13296 }
13297
13298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
13299 where
13300 V: serde::de::MapAccess<'de>,
13301 {
13302 let mut param__ = None;
13303 while let Some(k) = map_.next_key()? {
13304 match k {
13305 GeneratedField::Param => {
13306 if param__.is_some() {
13307 return Err(serde::de::Error::duplicate_field("param"));
13308 }
13309 param__ = Some(map_.next_value()?);
13310 }
13311 }
13312 }
13313 Ok(SetSessionParamResponse {
13314 param: param__.unwrap_or_default(),
13315 })
13316 }
13317 }
13318 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
13319 }
13320}
13321impl serde::Serialize for SetSyncLogStoreAlignedRequest {
13322 #[allow(deprecated)]
13323 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13324 where
13325 S: serde::Serializer,
13326 {
13327 use serde::ser::SerializeStruct;
13328 let mut len = 0;
13329 if self.job_id != 0 {
13330 len += 1;
13331 }
13332 if self.aligned {
13333 len += 1;
13334 }
13335 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
13336 if self.job_id != 0 {
13337 struct_ser.serialize_field("jobId", &self.job_id)?;
13338 }
13339 if self.aligned {
13340 struct_ser.serialize_field("aligned", &self.aligned)?;
13341 }
13342 struct_ser.end()
13343 }
13344}
13345impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
13346 #[allow(deprecated)]
13347 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13348 where
13349 D: serde::Deserializer<'de>,
13350 {
13351 const FIELDS: &[&str] = &[
13352 "job_id",
13353 "jobId",
13354 "aligned",
13355 ];
13356
13357 #[allow(clippy::enum_variant_names)]
13358 enum GeneratedField {
13359 JobId,
13360 Aligned,
13361 }
13362 impl<'de> serde::Deserialize<'de> for GeneratedField {
13363 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13364 where
13365 D: serde::Deserializer<'de>,
13366 {
13367 struct GeneratedVisitor;
13368
13369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13370 type Value = GeneratedField;
13371
13372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13373 write!(formatter, "expected one of: {:?}", &FIELDS)
13374 }
13375
13376 #[allow(unused_variables)]
13377 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13378 where
13379 E: serde::de::Error,
13380 {
13381 match value {
13382 "jobId" | "job_id" => Ok(GeneratedField::JobId),
13383 "aligned" => Ok(GeneratedField::Aligned),
13384 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13385 }
13386 }
13387 }
13388 deserializer.deserialize_identifier(GeneratedVisitor)
13389 }
13390 }
13391 struct GeneratedVisitor;
13392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13393 type Value = SetSyncLogStoreAlignedRequest;
13394
13395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13396 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
13397 }
13398
13399 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
13400 where
13401 V: serde::de::MapAccess<'de>,
13402 {
13403 let mut job_id__ = None;
13404 let mut aligned__ = None;
13405 while let Some(k) = map_.next_key()? {
13406 match k {
13407 GeneratedField::JobId => {
13408 if job_id__.is_some() {
13409 return Err(serde::de::Error::duplicate_field("jobId"));
13410 }
13411 job_id__ =
13412 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13413 ;
13414 }
13415 GeneratedField::Aligned => {
13416 if aligned__.is_some() {
13417 return Err(serde::de::Error::duplicate_field("aligned"));
13418 }
13419 aligned__ = Some(map_.next_value()?);
13420 }
13421 }
13422 }
13423 Ok(SetSyncLogStoreAlignedRequest {
13424 job_id: job_id__.unwrap_or_default(),
13425 aligned: aligned__.unwrap_or_default(),
13426 })
13427 }
13428 }
13429 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
13430 }
13431}
13432impl serde::Serialize for SetSyncLogStoreAlignedResponse {
13433 #[allow(deprecated)]
13434 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13435 where
13436 S: serde::Serializer,
13437 {
13438 use serde::ser::SerializeStruct;
13439 let len = 0;
13440 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
13441 struct_ser.end()
13442 }
13443}
13444impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
13445 #[allow(deprecated)]
13446 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13447 where
13448 D: serde::Deserializer<'de>,
13449 {
13450 const FIELDS: &[&str] = &[
13451 ];
13452
13453 #[allow(clippy::enum_variant_names)]
13454 enum GeneratedField {
13455 }
13456 impl<'de> serde::Deserialize<'de> for GeneratedField {
13457 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13458 where
13459 D: serde::Deserializer<'de>,
13460 {
13461 struct GeneratedVisitor;
13462
13463 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13464 type Value = GeneratedField;
13465
13466 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13467 write!(formatter, "expected one of: {:?}", &FIELDS)
13468 }
13469
13470 #[allow(unused_variables)]
13471 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13472 where
13473 E: serde::de::Error,
13474 {
13475 Err(serde::de::Error::unknown_field(value, FIELDS))
13476 }
13477 }
13478 deserializer.deserialize_identifier(GeneratedVisitor)
13479 }
13480 }
13481 struct GeneratedVisitor;
13482 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13483 type Value = SetSyncLogStoreAlignedResponse;
13484
13485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13486 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
13487 }
13488
13489 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
13490 where
13491 V: serde::de::MapAccess<'de>,
13492 {
13493 while map_.next_key::<GeneratedField>()?.is_some() {
13494 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13495 }
13496 Ok(SetSyncLogStoreAlignedResponse {
13497 })
13498 }
13499 }
13500 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
13501 }
13502}
13503impl serde::Serialize for SetSystemParamRequest {
13504 #[allow(deprecated)]
13505 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13506 where
13507 S: serde::Serializer,
13508 {
13509 use serde::ser::SerializeStruct;
13510 let mut len = 0;
13511 if !self.param.is_empty() {
13512 len += 1;
13513 }
13514 if self.value.is_some() {
13515 len += 1;
13516 }
13517 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
13518 if !self.param.is_empty() {
13519 struct_ser.serialize_field("param", &self.param)?;
13520 }
13521 if let Some(v) = self.value.as_ref() {
13522 struct_ser.serialize_field("value", v)?;
13523 }
13524 struct_ser.end()
13525 }
13526}
13527impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
13528 #[allow(deprecated)]
13529 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13530 where
13531 D: serde::Deserializer<'de>,
13532 {
13533 const FIELDS: &[&str] = &[
13534 "param",
13535 "value",
13536 ];
13537
13538 #[allow(clippy::enum_variant_names)]
13539 enum GeneratedField {
13540 Param,
13541 Value,
13542 }
13543 impl<'de> serde::Deserialize<'de> for GeneratedField {
13544 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13545 where
13546 D: serde::Deserializer<'de>,
13547 {
13548 struct GeneratedVisitor;
13549
13550 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13551 type Value = GeneratedField;
13552
13553 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13554 write!(formatter, "expected one of: {:?}", &FIELDS)
13555 }
13556
13557 #[allow(unused_variables)]
13558 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13559 where
13560 E: serde::de::Error,
13561 {
13562 match value {
13563 "param" => Ok(GeneratedField::Param),
13564 "value" => Ok(GeneratedField::Value),
13565 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13566 }
13567 }
13568 }
13569 deserializer.deserialize_identifier(GeneratedVisitor)
13570 }
13571 }
13572 struct GeneratedVisitor;
13573 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13574 type Value = SetSystemParamRequest;
13575
13576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13577 formatter.write_str("struct meta.SetSystemParamRequest")
13578 }
13579
13580 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
13581 where
13582 V: serde::de::MapAccess<'de>,
13583 {
13584 let mut param__ = None;
13585 let mut value__ = None;
13586 while let Some(k) = map_.next_key()? {
13587 match k {
13588 GeneratedField::Param => {
13589 if param__.is_some() {
13590 return Err(serde::de::Error::duplicate_field("param"));
13591 }
13592 param__ = Some(map_.next_value()?);
13593 }
13594 GeneratedField::Value => {
13595 if value__.is_some() {
13596 return Err(serde::de::Error::duplicate_field("value"));
13597 }
13598 value__ = map_.next_value()?;
13599 }
13600 }
13601 }
13602 Ok(SetSystemParamRequest {
13603 param: param__.unwrap_or_default(),
13604 value: value__,
13605 })
13606 }
13607 }
13608 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
13609 }
13610}
13611impl serde::Serialize for SetSystemParamResponse {
13612 #[allow(deprecated)]
13613 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13614 where
13615 S: serde::Serializer,
13616 {
13617 use serde::ser::SerializeStruct;
13618 let mut len = 0;
13619 if self.params.is_some() {
13620 len += 1;
13621 }
13622 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
13623 if let Some(v) = self.params.as_ref() {
13624 struct_ser.serialize_field("params", v)?;
13625 }
13626 struct_ser.end()
13627 }
13628}
13629impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
13630 #[allow(deprecated)]
13631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13632 where
13633 D: serde::Deserializer<'de>,
13634 {
13635 const FIELDS: &[&str] = &[
13636 "params",
13637 ];
13638
13639 #[allow(clippy::enum_variant_names)]
13640 enum GeneratedField {
13641 Params,
13642 }
13643 impl<'de> serde::Deserialize<'de> for GeneratedField {
13644 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13645 where
13646 D: serde::Deserializer<'de>,
13647 {
13648 struct GeneratedVisitor;
13649
13650 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13651 type Value = GeneratedField;
13652
13653 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13654 write!(formatter, "expected one of: {:?}", &FIELDS)
13655 }
13656
13657 #[allow(unused_variables)]
13658 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13659 where
13660 E: serde::de::Error,
13661 {
13662 match value {
13663 "params" => Ok(GeneratedField::Params),
13664 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13665 }
13666 }
13667 }
13668 deserializer.deserialize_identifier(GeneratedVisitor)
13669 }
13670 }
13671 struct GeneratedVisitor;
13672 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13673 type Value = SetSystemParamResponse;
13674
13675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13676 formatter.write_str("struct meta.SetSystemParamResponse")
13677 }
13678
13679 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
13680 where
13681 V: serde::de::MapAccess<'de>,
13682 {
13683 let mut params__ = None;
13684 while let Some(k) = map_.next_key()? {
13685 match k {
13686 GeneratedField::Params => {
13687 if params__.is_some() {
13688 return Err(serde::de::Error::duplicate_field("params"));
13689 }
13690 params__ = map_.next_value()?;
13691 }
13692 }
13693 }
13694 Ok(SetSystemParamResponse {
13695 params: params__,
13696 })
13697 }
13698 }
13699 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
13700 }
13701}
13702impl serde::Serialize for SubscribeRequest {
13703 #[allow(deprecated)]
13704 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13705 where
13706 S: serde::Serializer,
13707 {
13708 use serde::ser::SerializeStruct;
13709 let mut len = 0;
13710 if self.subscribe_type != 0 {
13711 len += 1;
13712 }
13713 if self.host.is_some() {
13714 len += 1;
13715 }
13716 if self.worker_id != 0 {
13717 len += 1;
13718 }
13719 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
13720 if self.subscribe_type != 0 {
13721 let v = SubscribeType::try_from(self.subscribe_type)
13722 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
13723 struct_ser.serialize_field("subscribeType", &v)?;
13724 }
13725 if let Some(v) = self.host.as_ref() {
13726 struct_ser.serialize_field("host", v)?;
13727 }
13728 if self.worker_id != 0 {
13729 struct_ser.serialize_field("workerId", &self.worker_id)?;
13730 }
13731 struct_ser.end()
13732 }
13733}
13734impl<'de> serde::Deserialize<'de> for SubscribeRequest {
13735 #[allow(deprecated)]
13736 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13737 where
13738 D: serde::Deserializer<'de>,
13739 {
13740 const FIELDS: &[&str] = &[
13741 "subscribe_type",
13742 "subscribeType",
13743 "host",
13744 "worker_id",
13745 "workerId",
13746 ];
13747
13748 #[allow(clippy::enum_variant_names)]
13749 enum GeneratedField {
13750 SubscribeType,
13751 Host,
13752 WorkerId,
13753 }
13754 impl<'de> serde::Deserialize<'de> for GeneratedField {
13755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13756 where
13757 D: serde::Deserializer<'de>,
13758 {
13759 struct GeneratedVisitor;
13760
13761 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13762 type Value = GeneratedField;
13763
13764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13765 write!(formatter, "expected one of: {:?}", &FIELDS)
13766 }
13767
13768 #[allow(unused_variables)]
13769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13770 where
13771 E: serde::de::Error,
13772 {
13773 match value {
13774 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
13775 "host" => Ok(GeneratedField::Host),
13776 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
13777 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13778 }
13779 }
13780 }
13781 deserializer.deserialize_identifier(GeneratedVisitor)
13782 }
13783 }
13784 struct GeneratedVisitor;
13785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13786 type Value = SubscribeRequest;
13787
13788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13789 formatter.write_str("struct meta.SubscribeRequest")
13790 }
13791
13792 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
13793 where
13794 V: serde::de::MapAccess<'de>,
13795 {
13796 let mut subscribe_type__ = None;
13797 let mut host__ = None;
13798 let mut worker_id__ = None;
13799 while let Some(k) = map_.next_key()? {
13800 match k {
13801 GeneratedField::SubscribeType => {
13802 if subscribe_type__.is_some() {
13803 return Err(serde::de::Error::duplicate_field("subscribeType"));
13804 }
13805 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
13806 }
13807 GeneratedField::Host => {
13808 if host__.is_some() {
13809 return Err(serde::de::Error::duplicate_field("host"));
13810 }
13811 host__ = map_.next_value()?;
13812 }
13813 GeneratedField::WorkerId => {
13814 if worker_id__.is_some() {
13815 return Err(serde::de::Error::duplicate_field("workerId"));
13816 }
13817 worker_id__ =
13818 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13819 ;
13820 }
13821 }
13822 }
13823 Ok(SubscribeRequest {
13824 subscribe_type: subscribe_type__.unwrap_or_default(),
13825 host: host__,
13826 worker_id: worker_id__.unwrap_or_default(),
13827 })
13828 }
13829 }
13830 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
13831 }
13832}
13833impl serde::Serialize for SubscribeResponse {
13834 #[allow(deprecated)]
13835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13836 where
13837 S: serde::Serializer,
13838 {
13839 use serde::ser::SerializeStruct;
13840 let mut len = 0;
13841 if self.status.is_some() {
13842 len += 1;
13843 }
13844 if self.operation != 0 {
13845 len += 1;
13846 }
13847 if self.version != 0 {
13848 len += 1;
13849 }
13850 if self.info.is_some() {
13851 len += 1;
13852 }
13853 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
13854 if let Some(v) = self.status.as_ref() {
13855 struct_ser.serialize_field("status", v)?;
13856 }
13857 if self.operation != 0 {
13858 let v = subscribe_response::Operation::try_from(self.operation)
13859 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
13860 struct_ser.serialize_field("operation", &v)?;
13861 }
13862 if self.version != 0 {
13863 #[allow(clippy::needless_borrow)]
13864 #[allow(clippy::needless_borrows_for_generic_args)]
13865 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
13866 }
13867 if let Some(v) = self.info.as_ref() {
13868 match v {
13869 subscribe_response::Info::Database(v) => {
13870 struct_ser.serialize_field("database", v)?;
13871 }
13872 subscribe_response::Info::Schema(v) => {
13873 struct_ser.serialize_field("schema", v)?;
13874 }
13875 subscribe_response::Info::Function(v) => {
13876 struct_ser.serialize_field("function", v)?;
13877 }
13878 subscribe_response::Info::User(v) => {
13879 struct_ser.serialize_field("user", v)?;
13880 }
13881 subscribe_response::Info::SessionParam(v) => {
13882 struct_ser.serialize_field("sessionParam", v)?;
13883 }
13884 subscribe_response::Info::Node(v) => {
13885 struct_ser.serialize_field("node", v)?;
13886 }
13887 subscribe_response::Info::HummockVersionDeltas(v) => {
13888 struct_ser.serialize_field("hummockVersionDeltas", v)?;
13889 }
13890 subscribe_response::Info::Snapshot(v) => {
13891 struct_ser.serialize_field("snapshot", v)?;
13892 }
13893 subscribe_response::Info::MetaBackupManifestId(v) => {
13894 struct_ser.serialize_field("metaBackupManifestId", v)?;
13895 }
13896 subscribe_response::Info::SystemParams(v) => {
13897 struct_ser.serialize_field("systemParams", v)?;
13898 }
13899 subscribe_response::Info::HummockWriteLimits(v) => {
13900 struct_ser.serialize_field("hummockWriteLimits", v)?;
13901 }
13902 subscribe_response::Info::ObjectGroup(v) => {
13903 struct_ser.serialize_field("objectGroup", v)?;
13904 }
13905 subscribe_response::Info::Connection(v) => {
13906 struct_ser.serialize_field("connection", v)?;
13907 }
13908 subscribe_response::Info::HummockStats(v) => {
13909 struct_ser.serialize_field("hummockStats", v)?;
13910 }
13911 subscribe_response::Info::Recovery(v) => {
13912 struct_ser.serialize_field("recovery", v)?;
13913 }
13914 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
13915 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
13916 }
13917 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
13918 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
13919 }
13920 subscribe_response::Info::Secret(v) => {
13921 struct_ser.serialize_field("secret", v)?;
13922 }
13923 subscribe_response::Info::ComputeNodeTotalCpuCount(v) => {
13924 #[allow(clippy::needless_borrow)]
13925 #[allow(clippy::needless_borrows_for_generic_args)]
13926 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&v).as_str())?;
13927 }
13928 }
13929 }
13930 struct_ser.end()
13931 }
13932}
13933impl<'de> serde::Deserialize<'de> for SubscribeResponse {
13934 #[allow(deprecated)]
13935 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13936 where
13937 D: serde::Deserializer<'de>,
13938 {
13939 const FIELDS: &[&str] = &[
13940 "status",
13941 "operation",
13942 "version",
13943 "database",
13944 "schema",
13945 "function",
13946 "user",
13947 "session_param",
13948 "sessionParam",
13949 "node",
13950 "hummock_version_deltas",
13951 "hummockVersionDeltas",
13952 "snapshot",
13953 "meta_backup_manifest_id",
13954 "metaBackupManifestId",
13955 "system_params",
13956 "systemParams",
13957 "hummock_write_limits",
13958 "hummockWriteLimits",
13959 "object_group",
13960 "objectGroup",
13961 "connection",
13962 "hummock_stats",
13963 "hummockStats",
13964 "recovery",
13965 "streaming_worker_slot_mapping",
13966 "streamingWorkerSlotMapping",
13967 "serving_worker_slot_mappings",
13968 "servingWorkerSlotMappings",
13969 "secret",
13970 "compute_node_total_cpu_count",
13971 "computeNodeTotalCpuCount",
13972 ];
13973
13974 #[allow(clippy::enum_variant_names)]
13975 enum GeneratedField {
13976 Status,
13977 Operation,
13978 Version,
13979 Database,
13980 Schema,
13981 Function,
13982 User,
13983 SessionParam,
13984 Node,
13985 HummockVersionDeltas,
13986 Snapshot,
13987 MetaBackupManifestId,
13988 SystemParams,
13989 HummockWriteLimits,
13990 ObjectGroup,
13991 Connection,
13992 HummockStats,
13993 Recovery,
13994 StreamingWorkerSlotMapping,
13995 ServingWorkerSlotMappings,
13996 Secret,
13997 ComputeNodeTotalCpuCount,
13998 }
13999 impl<'de> serde::Deserialize<'de> for GeneratedField {
14000 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14001 where
14002 D: serde::Deserializer<'de>,
14003 {
14004 struct GeneratedVisitor;
14005
14006 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14007 type Value = GeneratedField;
14008
14009 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14010 write!(formatter, "expected one of: {:?}", &FIELDS)
14011 }
14012
14013 #[allow(unused_variables)]
14014 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14015 where
14016 E: serde::de::Error,
14017 {
14018 match value {
14019 "status" => Ok(GeneratedField::Status),
14020 "operation" => Ok(GeneratedField::Operation),
14021 "version" => Ok(GeneratedField::Version),
14022 "database" => Ok(GeneratedField::Database),
14023 "schema" => Ok(GeneratedField::Schema),
14024 "function" => Ok(GeneratedField::Function),
14025 "user" => Ok(GeneratedField::User),
14026 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
14027 "node" => Ok(GeneratedField::Node),
14028 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
14029 "snapshot" => Ok(GeneratedField::Snapshot),
14030 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
14031 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
14032 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
14033 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
14034 "connection" => Ok(GeneratedField::Connection),
14035 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
14036 "recovery" => Ok(GeneratedField::Recovery),
14037 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
14038 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
14039 "secret" => Ok(GeneratedField::Secret),
14040 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
14041 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14042 }
14043 }
14044 }
14045 deserializer.deserialize_identifier(GeneratedVisitor)
14046 }
14047 }
14048 struct GeneratedVisitor;
14049 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14050 type Value = SubscribeResponse;
14051
14052 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14053 formatter.write_str("struct meta.SubscribeResponse")
14054 }
14055
14056 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
14057 where
14058 V: serde::de::MapAccess<'de>,
14059 {
14060 let mut status__ = None;
14061 let mut operation__ = None;
14062 let mut version__ = None;
14063 let mut info__ = None;
14064 while let Some(k) = map_.next_key()? {
14065 match k {
14066 GeneratedField::Status => {
14067 if status__.is_some() {
14068 return Err(serde::de::Error::duplicate_field("status"));
14069 }
14070 status__ = map_.next_value()?;
14071 }
14072 GeneratedField::Operation => {
14073 if operation__.is_some() {
14074 return Err(serde::de::Error::duplicate_field("operation"));
14075 }
14076 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
14077 }
14078 GeneratedField::Version => {
14079 if version__.is_some() {
14080 return Err(serde::de::Error::duplicate_field("version"));
14081 }
14082 version__ =
14083 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14084 ;
14085 }
14086 GeneratedField::Database => {
14087 if info__.is_some() {
14088 return Err(serde::de::Error::duplicate_field("database"));
14089 }
14090 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
14091;
14092 }
14093 GeneratedField::Schema => {
14094 if info__.is_some() {
14095 return Err(serde::de::Error::duplicate_field("schema"));
14096 }
14097 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
14098;
14099 }
14100 GeneratedField::Function => {
14101 if info__.is_some() {
14102 return Err(serde::de::Error::duplicate_field("function"));
14103 }
14104 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
14105;
14106 }
14107 GeneratedField::User => {
14108 if info__.is_some() {
14109 return Err(serde::de::Error::duplicate_field("user"));
14110 }
14111 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
14112;
14113 }
14114 GeneratedField::SessionParam => {
14115 if info__.is_some() {
14116 return Err(serde::de::Error::duplicate_field("sessionParam"));
14117 }
14118 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
14119;
14120 }
14121 GeneratedField::Node => {
14122 if info__.is_some() {
14123 return Err(serde::de::Error::duplicate_field("node"));
14124 }
14125 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
14126;
14127 }
14128 GeneratedField::HummockVersionDeltas => {
14129 if info__.is_some() {
14130 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
14131 }
14132 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
14133;
14134 }
14135 GeneratedField::Snapshot => {
14136 if info__.is_some() {
14137 return Err(serde::de::Error::duplicate_field("snapshot"));
14138 }
14139 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
14140;
14141 }
14142 GeneratedField::MetaBackupManifestId => {
14143 if info__.is_some() {
14144 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14145 }
14146 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
14147;
14148 }
14149 GeneratedField::SystemParams => {
14150 if info__.is_some() {
14151 return Err(serde::de::Error::duplicate_field("systemParams"));
14152 }
14153 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
14154;
14155 }
14156 GeneratedField::HummockWriteLimits => {
14157 if info__.is_some() {
14158 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14159 }
14160 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
14161;
14162 }
14163 GeneratedField::ObjectGroup => {
14164 if info__.is_some() {
14165 return Err(serde::de::Error::duplicate_field("objectGroup"));
14166 }
14167 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
14168;
14169 }
14170 GeneratedField::Connection => {
14171 if info__.is_some() {
14172 return Err(serde::de::Error::duplicate_field("connection"));
14173 }
14174 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
14175;
14176 }
14177 GeneratedField::HummockStats => {
14178 if info__.is_some() {
14179 return Err(serde::de::Error::duplicate_field("hummockStats"));
14180 }
14181 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
14182;
14183 }
14184 GeneratedField::Recovery => {
14185 if info__.is_some() {
14186 return Err(serde::de::Error::duplicate_field("recovery"));
14187 }
14188 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
14189;
14190 }
14191 GeneratedField::StreamingWorkerSlotMapping => {
14192 if info__.is_some() {
14193 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
14194 }
14195 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
14196;
14197 }
14198 GeneratedField::ServingWorkerSlotMappings => {
14199 if info__.is_some() {
14200 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14201 }
14202 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
14203;
14204 }
14205 GeneratedField::Secret => {
14206 if info__.is_some() {
14207 return Err(serde::de::Error::duplicate_field("secret"));
14208 }
14209 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
14210;
14211 }
14212 GeneratedField::ComputeNodeTotalCpuCount => {
14213 if info__.is_some() {
14214 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
14215 }
14216 info__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| subscribe_response::Info::ComputeNodeTotalCpuCount(x.0));
14217 }
14218 }
14219 }
14220 Ok(SubscribeResponse {
14221 status: status__,
14222 operation: operation__.unwrap_or_default(),
14223 version: version__.unwrap_or_default(),
14224 info: info__,
14225 })
14226 }
14227 }
14228 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
14229 }
14230}
14231impl serde::Serialize for subscribe_response::Operation {
14232 #[allow(deprecated)]
14233 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14234 where
14235 S: serde::Serializer,
14236 {
14237 let variant = match self {
14238 Self::Unspecified => "UNSPECIFIED",
14239 Self::Add => "ADD",
14240 Self::Delete => "DELETE",
14241 Self::Update => "UPDATE",
14242 Self::Snapshot => "SNAPSHOT",
14243 };
14244 serializer.serialize_str(variant)
14245 }
14246}
14247impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
14248 #[allow(deprecated)]
14249 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14250 where
14251 D: serde::Deserializer<'de>,
14252 {
14253 const FIELDS: &[&str] = &[
14254 "UNSPECIFIED",
14255 "ADD",
14256 "DELETE",
14257 "UPDATE",
14258 "SNAPSHOT",
14259 ];
14260
14261 struct GeneratedVisitor;
14262
14263 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14264 type Value = subscribe_response::Operation;
14265
14266 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14267 write!(formatter, "expected one of: {:?}", &FIELDS)
14268 }
14269
14270 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14271 where
14272 E: serde::de::Error,
14273 {
14274 i32::try_from(v)
14275 .ok()
14276 .and_then(|x| x.try_into().ok())
14277 .ok_or_else(|| {
14278 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14279 })
14280 }
14281
14282 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14283 where
14284 E: serde::de::Error,
14285 {
14286 i32::try_from(v)
14287 .ok()
14288 .and_then(|x| x.try_into().ok())
14289 .ok_or_else(|| {
14290 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14291 })
14292 }
14293
14294 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14295 where
14296 E: serde::de::Error,
14297 {
14298 match value {
14299 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
14300 "ADD" => Ok(subscribe_response::Operation::Add),
14301 "DELETE" => Ok(subscribe_response::Operation::Delete),
14302 "UPDATE" => Ok(subscribe_response::Operation::Update),
14303 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
14304 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14305 }
14306 }
14307 }
14308 deserializer.deserialize_any(GeneratedVisitor)
14309 }
14310}
14311impl serde::Serialize for SubscribeType {
14312 #[allow(deprecated)]
14313 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14314 where
14315 S: serde::Serializer,
14316 {
14317 let variant = match self {
14318 Self::Unspecified => "UNSPECIFIED",
14319 Self::Frontend => "FRONTEND",
14320 Self::Hummock => "HUMMOCK",
14321 Self::Compactor => "COMPACTOR",
14322 Self::Compute => "COMPUTE",
14323 };
14324 serializer.serialize_str(variant)
14325 }
14326}
14327impl<'de> serde::Deserialize<'de> for SubscribeType {
14328 #[allow(deprecated)]
14329 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14330 where
14331 D: serde::Deserializer<'de>,
14332 {
14333 const FIELDS: &[&str] = &[
14334 "UNSPECIFIED",
14335 "FRONTEND",
14336 "HUMMOCK",
14337 "COMPACTOR",
14338 "COMPUTE",
14339 ];
14340
14341 struct GeneratedVisitor;
14342
14343 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14344 type Value = SubscribeType;
14345
14346 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14347 write!(formatter, "expected one of: {:?}", &FIELDS)
14348 }
14349
14350 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14351 where
14352 E: serde::de::Error,
14353 {
14354 i32::try_from(v)
14355 .ok()
14356 .and_then(|x| x.try_into().ok())
14357 .ok_or_else(|| {
14358 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14359 })
14360 }
14361
14362 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14363 where
14364 E: serde::de::Error,
14365 {
14366 i32::try_from(v)
14367 .ok()
14368 .and_then(|x| x.try_into().ok())
14369 .ok_or_else(|| {
14370 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14371 })
14372 }
14373
14374 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14375 where
14376 E: serde::de::Error,
14377 {
14378 match value {
14379 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
14380 "FRONTEND" => Ok(SubscribeType::Frontend),
14381 "HUMMOCK" => Ok(SubscribeType::Hummock),
14382 "COMPACTOR" => Ok(SubscribeType::Compactor),
14383 "COMPUTE" => Ok(SubscribeType::Compute),
14384 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14385 }
14386 }
14387 }
14388 deserializer.deserialize_any(GeneratedVisitor)
14389 }
14390}
14391impl serde::Serialize for SystemParams {
14392 #[allow(deprecated)]
14393 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14394 where
14395 S: serde::Serializer,
14396 {
14397 use serde::ser::SerializeStruct;
14398 let mut len = 0;
14399 if self.barrier_interval_ms.is_some() {
14400 len += 1;
14401 }
14402 if self.checkpoint_frequency.is_some() {
14403 len += 1;
14404 }
14405 if self.sstable_size_mb.is_some() {
14406 len += 1;
14407 }
14408 if self.block_size_kb.is_some() {
14409 len += 1;
14410 }
14411 if self.bloom_false_positive.is_some() {
14412 len += 1;
14413 }
14414 if self.state_store.is_some() {
14415 len += 1;
14416 }
14417 if self.data_directory.is_some() {
14418 len += 1;
14419 }
14420 if self.backup_storage_url.is_some() {
14421 len += 1;
14422 }
14423 if self.backup_storage_directory.is_some() {
14424 len += 1;
14425 }
14426 if self.telemetry_enabled.is_some() {
14427 len += 1;
14428 }
14429 if self.parallel_compact_size_mb.is_some() {
14430 len += 1;
14431 }
14432 if self.max_concurrent_creating_streaming_jobs.is_some() {
14433 len += 1;
14434 }
14435 if self.pause_on_next_bootstrap.is_some() {
14436 len += 1;
14437 }
14438 if self.wasm_storage_url.is_some() {
14439 len += 1;
14440 }
14441 if self.enable_tracing.is_some() {
14442 len += 1;
14443 }
14444 if self.use_new_object_prefix_strategy.is_some() {
14445 len += 1;
14446 }
14447 if self.license_key.is_some() {
14448 len += 1;
14449 }
14450 if self.time_travel_retention_ms.is_some() {
14451 len += 1;
14452 }
14453 if self.adaptive_parallelism_strategy.is_some() {
14454 len += 1;
14455 }
14456 if self.per_database_isolation.is_some() {
14457 len += 1;
14458 }
14459 if self.enforce_secret.is_some() {
14460 len += 1;
14461 }
14462 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
14463 if let Some(v) = self.barrier_interval_ms.as_ref() {
14464 struct_ser.serialize_field("barrierIntervalMs", v)?;
14465 }
14466 if let Some(v) = self.checkpoint_frequency.as_ref() {
14467 #[allow(clippy::needless_borrow)]
14468 #[allow(clippy::needless_borrows_for_generic_args)]
14469 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
14470 }
14471 if let Some(v) = self.sstable_size_mb.as_ref() {
14472 struct_ser.serialize_field("sstableSizeMb", v)?;
14473 }
14474 if let Some(v) = self.block_size_kb.as_ref() {
14475 struct_ser.serialize_field("blockSizeKb", v)?;
14476 }
14477 if let Some(v) = self.bloom_false_positive.as_ref() {
14478 struct_ser.serialize_field("bloomFalsePositive", v)?;
14479 }
14480 if let Some(v) = self.state_store.as_ref() {
14481 struct_ser.serialize_field("stateStore", v)?;
14482 }
14483 if let Some(v) = self.data_directory.as_ref() {
14484 struct_ser.serialize_field("dataDirectory", v)?;
14485 }
14486 if let Some(v) = self.backup_storage_url.as_ref() {
14487 struct_ser.serialize_field("backupStorageUrl", v)?;
14488 }
14489 if let Some(v) = self.backup_storage_directory.as_ref() {
14490 struct_ser.serialize_field("backupStorageDirectory", v)?;
14491 }
14492 if let Some(v) = self.telemetry_enabled.as_ref() {
14493 struct_ser.serialize_field("telemetryEnabled", v)?;
14494 }
14495 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
14496 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
14497 }
14498 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
14499 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
14500 }
14501 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
14502 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
14503 }
14504 if let Some(v) = self.wasm_storage_url.as_ref() {
14505 struct_ser.serialize_field("wasmStorageUrl", v)?;
14506 }
14507 if let Some(v) = self.enable_tracing.as_ref() {
14508 struct_ser.serialize_field("enableTracing", v)?;
14509 }
14510 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
14511 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
14512 }
14513 if let Some(v) = self.license_key.as_ref() {
14514 struct_ser.serialize_field("licenseKey", v)?;
14515 }
14516 if let Some(v) = self.time_travel_retention_ms.as_ref() {
14517 #[allow(clippy::needless_borrow)]
14518 #[allow(clippy::needless_borrows_for_generic_args)]
14519 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
14520 }
14521 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
14522 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
14523 }
14524 if let Some(v) = self.per_database_isolation.as_ref() {
14525 struct_ser.serialize_field("perDatabaseIsolation", v)?;
14526 }
14527 if let Some(v) = self.enforce_secret.as_ref() {
14528 struct_ser.serialize_field("enforceSecret", v)?;
14529 }
14530 struct_ser.end()
14531 }
14532}
14533impl<'de> serde::Deserialize<'de> for SystemParams {
14534 #[allow(deprecated)]
14535 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14536 where
14537 D: serde::Deserializer<'de>,
14538 {
14539 const FIELDS: &[&str] = &[
14540 "barrier_interval_ms",
14541 "barrierIntervalMs",
14542 "checkpoint_frequency",
14543 "checkpointFrequency",
14544 "sstable_size_mb",
14545 "sstableSizeMb",
14546 "block_size_kb",
14547 "blockSizeKb",
14548 "bloom_false_positive",
14549 "bloomFalsePositive",
14550 "state_store",
14551 "stateStore",
14552 "data_directory",
14553 "dataDirectory",
14554 "backup_storage_url",
14555 "backupStorageUrl",
14556 "backup_storage_directory",
14557 "backupStorageDirectory",
14558 "telemetry_enabled",
14559 "telemetryEnabled",
14560 "parallel_compact_size_mb",
14561 "parallelCompactSizeMb",
14562 "max_concurrent_creating_streaming_jobs",
14563 "maxConcurrentCreatingStreamingJobs",
14564 "pause_on_next_bootstrap",
14565 "pauseOnNextBootstrap",
14566 "wasm_storage_url",
14567 "wasmStorageUrl",
14568 "enable_tracing",
14569 "enableTracing",
14570 "use_new_object_prefix_strategy",
14571 "useNewObjectPrefixStrategy",
14572 "license_key",
14573 "licenseKey",
14574 "time_travel_retention_ms",
14575 "timeTravelRetentionMs",
14576 "adaptive_parallelism_strategy",
14577 "adaptiveParallelismStrategy",
14578 "per_database_isolation",
14579 "perDatabaseIsolation",
14580 "enforce_secret",
14581 "enforceSecret",
14582 ];
14583
14584 #[allow(clippy::enum_variant_names)]
14585 enum GeneratedField {
14586 BarrierIntervalMs,
14587 CheckpointFrequency,
14588 SstableSizeMb,
14589 BlockSizeKb,
14590 BloomFalsePositive,
14591 StateStore,
14592 DataDirectory,
14593 BackupStorageUrl,
14594 BackupStorageDirectory,
14595 TelemetryEnabled,
14596 ParallelCompactSizeMb,
14597 MaxConcurrentCreatingStreamingJobs,
14598 PauseOnNextBootstrap,
14599 WasmStorageUrl,
14600 EnableTracing,
14601 UseNewObjectPrefixStrategy,
14602 LicenseKey,
14603 TimeTravelRetentionMs,
14604 AdaptiveParallelismStrategy,
14605 PerDatabaseIsolation,
14606 EnforceSecret,
14607 }
14608 impl<'de> serde::Deserialize<'de> for GeneratedField {
14609 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14610 where
14611 D: serde::Deserializer<'de>,
14612 {
14613 struct GeneratedVisitor;
14614
14615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14616 type Value = GeneratedField;
14617
14618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14619 write!(formatter, "expected one of: {:?}", &FIELDS)
14620 }
14621
14622 #[allow(unused_variables)]
14623 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14624 where
14625 E: serde::de::Error,
14626 {
14627 match value {
14628 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
14629 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
14630 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
14631 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
14632 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
14633 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
14634 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
14635 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
14636 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
14637 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
14638 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
14639 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
14640 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
14641 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
14642 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
14643 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
14644 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
14645 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
14646 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
14647 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
14648 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
14649 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14650 }
14651 }
14652 }
14653 deserializer.deserialize_identifier(GeneratedVisitor)
14654 }
14655 }
14656 struct GeneratedVisitor;
14657 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14658 type Value = SystemParams;
14659
14660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14661 formatter.write_str("struct meta.SystemParams")
14662 }
14663
14664 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
14665 where
14666 V: serde::de::MapAccess<'de>,
14667 {
14668 let mut barrier_interval_ms__ = None;
14669 let mut checkpoint_frequency__ = None;
14670 let mut sstable_size_mb__ = None;
14671 let mut block_size_kb__ = None;
14672 let mut bloom_false_positive__ = None;
14673 let mut state_store__ = None;
14674 let mut data_directory__ = None;
14675 let mut backup_storage_url__ = None;
14676 let mut backup_storage_directory__ = None;
14677 let mut telemetry_enabled__ = None;
14678 let mut parallel_compact_size_mb__ = None;
14679 let mut max_concurrent_creating_streaming_jobs__ = None;
14680 let mut pause_on_next_bootstrap__ = None;
14681 let mut wasm_storage_url__ = None;
14682 let mut enable_tracing__ = None;
14683 let mut use_new_object_prefix_strategy__ = None;
14684 let mut license_key__ = None;
14685 let mut time_travel_retention_ms__ = None;
14686 let mut adaptive_parallelism_strategy__ = None;
14687 let mut per_database_isolation__ = None;
14688 let mut enforce_secret__ = None;
14689 while let Some(k) = map_.next_key()? {
14690 match k {
14691 GeneratedField::BarrierIntervalMs => {
14692 if barrier_interval_ms__.is_some() {
14693 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
14694 }
14695 barrier_interval_ms__ =
14696 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14697 ;
14698 }
14699 GeneratedField::CheckpointFrequency => {
14700 if checkpoint_frequency__.is_some() {
14701 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
14702 }
14703 checkpoint_frequency__ =
14704 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14705 ;
14706 }
14707 GeneratedField::SstableSizeMb => {
14708 if sstable_size_mb__.is_some() {
14709 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
14710 }
14711 sstable_size_mb__ =
14712 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14713 ;
14714 }
14715 GeneratedField::BlockSizeKb => {
14716 if block_size_kb__.is_some() {
14717 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
14718 }
14719 block_size_kb__ =
14720 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14721 ;
14722 }
14723 GeneratedField::BloomFalsePositive => {
14724 if bloom_false_positive__.is_some() {
14725 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
14726 }
14727 bloom_false_positive__ =
14728 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14729 ;
14730 }
14731 GeneratedField::StateStore => {
14732 if state_store__.is_some() {
14733 return Err(serde::de::Error::duplicate_field("stateStore"));
14734 }
14735 state_store__ = map_.next_value()?;
14736 }
14737 GeneratedField::DataDirectory => {
14738 if data_directory__.is_some() {
14739 return Err(serde::de::Error::duplicate_field("dataDirectory"));
14740 }
14741 data_directory__ = map_.next_value()?;
14742 }
14743 GeneratedField::BackupStorageUrl => {
14744 if backup_storage_url__.is_some() {
14745 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
14746 }
14747 backup_storage_url__ = map_.next_value()?;
14748 }
14749 GeneratedField::BackupStorageDirectory => {
14750 if backup_storage_directory__.is_some() {
14751 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
14752 }
14753 backup_storage_directory__ = map_.next_value()?;
14754 }
14755 GeneratedField::TelemetryEnabled => {
14756 if telemetry_enabled__.is_some() {
14757 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
14758 }
14759 telemetry_enabled__ = map_.next_value()?;
14760 }
14761 GeneratedField::ParallelCompactSizeMb => {
14762 if parallel_compact_size_mb__.is_some() {
14763 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
14764 }
14765 parallel_compact_size_mb__ =
14766 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14767 ;
14768 }
14769 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
14770 if max_concurrent_creating_streaming_jobs__.is_some() {
14771 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
14772 }
14773 max_concurrent_creating_streaming_jobs__ =
14774 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14775 ;
14776 }
14777 GeneratedField::PauseOnNextBootstrap => {
14778 if pause_on_next_bootstrap__.is_some() {
14779 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
14780 }
14781 pause_on_next_bootstrap__ = map_.next_value()?;
14782 }
14783 GeneratedField::WasmStorageUrl => {
14784 if wasm_storage_url__.is_some() {
14785 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
14786 }
14787 wasm_storage_url__ = map_.next_value()?;
14788 }
14789 GeneratedField::EnableTracing => {
14790 if enable_tracing__.is_some() {
14791 return Err(serde::de::Error::duplicate_field("enableTracing"));
14792 }
14793 enable_tracing__ = map_.next_value()?;
14794 }
14795 GeneratedField::UseNewObjectPrefixStrategy => {
14796 if use_new_object_prefix_strategy__.is_some() {
14797 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
14798 }
14799 use_new_object_prefix_strategy__ = map_.next_value()?;
14800 }
14801 GeneratedField::LicenseKey => {
14802 if license_key__.is_some() {
14803 return Err(serde::de::Error::duplicate_field("licenseKey"));
14804 }
14805 license_key__ = map_.next_value()?;
14806 }
14807 GeneratedField::TimeTravelRetentionMs => {
14808 if time_travel_retention_ms__.is_some() {
14809 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
14810 }
14811 time_travel_retention_ms__ =
14812 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14813 ;
14814 }
14815 GeneratedField::AdaptiveParallelismStrategy => {
14816 if adaptive_parallelism_strategy__.is_some() {
14817 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
14818 }
14819 adaptive_parallelism_strategy__ = map_.next_value()?;
14820 }
14821 GeneratedField::PerDatabaseIsolation => {
14822 if per_database_isolation__.is_some() {
14823 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
14824 }
14825 per_database_isolation__ = map_.next_value()?;
14826 }
14827 GeneratedField::EnforceSecret => {
14828 if enforce_secret__.is_some() {
14829 return Err(serde::de::Error::duplicate_field("enforceSecret"));
14830 }
14831 enforce_secret__ = map_.next_value()?;
14832 }
14833 }
14834 }
14835 Ok(SystemParams {
14836 barrier_interval_ms: barrier_interval_ms__,
14837 checkpoint_frequency: checkpoint_frequency__,
14838 sstable_size_mb: sstable_size_mb__,
14839 block_size_kb: block_size_kb__,
14840 bloom_false_positive: bloom_false_positive__,
14841 state_store: state_store__,
14842 data_directory: data_directory__,
14843 backup_storage_url: backup_storage_url__,
14844 backup_storage_directory: backup_storage_directory__,
14845 telemetry_enabled: telemetry_enabled__,
14846 parallel_compact_size_mb: parallel_compact_size_mb__,
14847 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
14848 pause_on_next_bootstrap: pause_on_next_bootstrap__,
14849 wasm_storage_url: wasm_storage_url__,
14850 enable_tracing: enable_tracing__,
14851 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
14852 license_key: license_key__,
14853 time_travel_retention_ms: time_travel_retention_ms__,
14854 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
14855 per_database_isolation: per_database_isolation__,
14856 enforce_secret: enforce_secret__,
14857 })
14858 }
14859 }
14860 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
14861 }
14862}
14863impl serde::Serialize for TableFragments {
14864 #[allow(deprecated)]
14865 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14866 where
14867 S: serde::Serializer,
14868 {
14869 use serde::ser::SerializeStruct;
14870 let mut len = 0;
14871 if self.table_id != 0 {
14872 len += 1;
14873 }
14874 if self.state != 0 {
14875 len += 1;
14876 }
14877 if !self.fragments.is_empty() {
14878 len += 1;
14879 }
14880 if !self.actor_status.is_empty() {
14881 len += 1;
14882 }
14883 if !self.actor_splits.is_empty() {
14884 len += 1;
14885 }
14886 if self.ctx.is_some() {
14887 len += 1;
14888 }
14889 if self.parallelism.is_some() {
14890 len += 1;
14891 }
14892 if self.max_parallelism.is_some() {
14893 len += 1;
14894 }
14895 if !self.node_label.is_empty() {
14896 len += 1;
14897 }
14898 if self.backfill_done {
14899 len += 1;
14900 }
14901 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
14902 if self.table_id != 0 {
14903 struct_ser.serialize_field("tableId", &self.table_id)?;
14904 }
14905 if self.state != 0 {
14906 let v = table_fragments::State::try_from(self.state)
14907 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
14908 struct_ser.serialize_field("state", &v)?;
14909 }
14910 if !self.fragments.is_empty() {
14911 struct_ser.serialize_field("fragments", &self.fragments)?;
14912 }
14913 if !self.actor_status.is_empty() {
14914 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
14915 }
14916 if !self.actor_splits.is_empty() {
14917 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14918 }
14919 if let Some(v) = self.ctx.as_ref() {
14920 struct_ser.serialize_field("ctx", v)?;
14921 }
14922 if let Some(v) = self.parallelism.as_ref() {
14923 struct_ser.serialize_field("parallelism", v)?;
14924 }
14925 if let Some(v) = self.max_parallelism.as_ref() {
14926 struct_ser.serialize_field("maxParallelism", v)?;
14927 }
14928 if !self.node_label.is_empty() {
14929 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
14930 }
14931 if self.backfill_done {
14932 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
14933 }
14934 struct_ser.end()
14935 }
14936}
14937impl<'de> serde::Deserialize<'de> for TableFragments {
14938 #[allow(deprecated)]
14939 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14940 where
14941 D: serde::Deserializer<'de>,
14942 {
14943 const FIELDS: &[&str] = &[
14944 "table_id",
14945 "tableId",
14946 "state",
14947 "fragments",
14948 "actor_status",
14949 "actorStatus",
14950 "actor_splits",
14951 "actorSplits",
14952 "ctx",
14953 "parallelism",
14954 "max_parallelism",
14955 "maxParallelism",
14956 "node_label",
14957 "nodeLabel",
14958 "backfill_done",
14959 "backfillDone",
14960 ];
14961
14962 #[allow(clippy::enum_variant_names)]
14963 enum GeneratedField {
14964 TableId,
14965 State,
14966 Fragments,
14967 ActorStatus,
14968 ActorSplits,
14969 Ctx,
14970 Parallelism,
14971 MaxParallelism,
14972 NodeLabel,
14973 BackfillDone,
14974 }
14975 impl<'de> serde::Deserialize<'de> for GeneratedField {
14976 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14977 where
14978 D: serde::Deserializer<'de>,
14979 {
14980 struct GeneratedVisitor;
14981
14982 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14983 type Value = GeneratedField;
14984
14985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14986 write!(formatter, "expected one of: {:?}", &FIELDS)
14987 }
14988
14989 #[allow(unused_variables)]
14990 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14991 where
14992 E: serde::de::Error,
14993 {
14994 match value {
14995 "tableId" | "table_id" => Ok(GeneratedField::TableId),
14996 "state" => Ok(GeneratedField::State),
14997 "fragments" => Ok(GeneratedField::Fragments),
14998 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
14999 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
15000 "ctx" => Ok(GeneratedField::Ctx),
15001 "parallelism" => Ok(GeneratedField::Parallelism),
15002 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
15003 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
15004 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
15005 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15006 }
15007 }
15008 }
15009 deserializer.deserialize_identifier(GeneratedVisitor)
15010 }
15011 }
15012 struct GeneratedVisitor;
15013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15014 type Value = TableFragments;
15015
15016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15017 formatter.write_str("struct meta.TableFragments")
15018 }
15019
15020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
15021 where
15022 V: serde::de::MapAccess<'de>,
15023 {
15024 let mut table_id__ = None;
15025 let mut state__ = None;
15026 let mut fragments__ = None;
15027 let mut actor_status__ = None;
15028 let mut actor_splits__ = None;
15029 let mut ctx__ = None;
15030 let mut parallelism__ = None;
15031 let mut max_parallelism__ = None;
15032 let mut node_label__ = None;
15033 let mut backfill_done__ = None;
15034 while let Some(k) = map_.next_key()? {
15035 match k {
15036 GeneratedField::TableId => {
15037 if table_id__.is_some() {
15038 return Err(serde::de::Error::duplicate_field("tableId"));
15039 }
15040 table_id__ =
15041 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15042 ;
15043 }
15044 GeneratedField::State => {
15045 if state__.is_some() {
15046 return Err(serde::de::Error::duplicate_field("state"));
15047 }
15048 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
15049 }
15050 GeneratedField::Fragments => {
15051 if fragments__.is_some() {
15052 return Err(serde::de::Error::duplicate_field("fragments"));
15053 }
15054 fragments__ = Some(
15055 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15056 .into_iter().map(|(k,v)| (k.0, v)).collect()
15057 );
15058 }
15059 GeneratedField::ActorStatus => {
15060 if actor_status__.is_some() {
15061 return Err(serde::de::Error::duplicate_field("actorStatus"));
15062 }
15063 actor_status__ = Some(
15064 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15065 .into_iter().map(|(k,v)| (k.0, v)).collect()
15066 );
15067 }
15068 GeneratedField::ActorSplits => {
15069 if actor_splits__.is_some() {
15070 return Err(serde::de::Error::duplicate_field("actorSplits"));
15071 }
15072 actor_splits__ = Some(
15073 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15074 .into_iter().map(|(k,v)| (k.0, v)).collect()
15075 );
15076 }
15077 GeneratedField::Ctx => {
15078 if ctx__.is_some() {
15079 return Err(serde::de::Error::duplicate_field("ctx"));
15080 }
15081 ctx__ = map_.next_value()?;
15082 }
15083 GeneratedField::Parallelism => {
15084 if parallelism__.is_some() {
15085 return Err(serde::de::Error::duplicate_field("parallelism"));
15086 }
15087 parallelism__ = map_.next_value()?;
15088 }
15089 GeneratedField::MaxParallelism => {
15090 if max_parallelism__.is_some() {
15091 return Err(serde::de::Error::duplicate_field("maxParallelism"));
15092 }
15093 max_parallelism__ =
15094 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15095 ;
15096 }
15097 GeneratedField::NodeLabel => {
15098 if node_label__.is_some() {
15099 return Err(serde::de::Error::duplicate_field("nodeLabel"));
15100 }
15101 node_label__ = Some(map_.next_value()?);
15102 }
15103 GeneratedField::BackfillDone => {
15104 if backfill_done__.is_some() {
15105 return Err(serde::de::Error::duplicate_field("backfillDone"));
15106 }
15107 backfill_done__ = Some(map_.next_value()?);
15108 }
15109 }
15110 }
15111 Ok(TableFragments {
15112 table_id: table_id__.unwrap_or_default(),
15113 state: state__.unwrap_or_default(),
15114 fragments: fragments__.unwrap_or_default(),
15115 actor_status: actor_status__.unwrap_or_default(),
15116 actor_splits: actor_splits__.unwrap_or_default(),
15117 ctx: ctx__,
15118 parallelism: parallelism__,
15119 max_parallelism: max_parallelism__,
15120 node_label: node_label__.unwrap_or_default(),
15121 backfill_done: backfill_done__.unwrap_or_default(),
15122 })
15123 }
15124 }
15125 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
15126 }
15127}
15128impl serde::Serialize for table_fragments::ActorStatus {
15129 #[allow(deprecated)]
15130 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15131 where
15132 S: serde::Serializer,
15133 {
15134 use serde::ser::SerializeStruct;
15135 let mut len = 0;
15136 if self.location.is_some() {
15137 len += 1;
15138 }
15139 if self.state != 0 {
15140 len += 1;
15141 }
15142 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
15143 if let Some(v) = self.location.as_ref() {
15144 struct_ser.serialize_field("location", v)?;
15145 }
15146 if self.state != 0 {
15147 let v = table_fragments::actor_status::ActorState::try_from(self.state)
15148 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15149 struct_ser.serialize_field("state", &v)?;
15150 }
15151 struct_ser.end()
15152 }
15153}
15154impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
15155 #[allow(deprecated)]
15156 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15157 where
15158 D: serde::Deserializer<'de>,
15159 {
15160 const FIELDS: &[&str] = &[
15161 "location",
15162 "state",
15163 ];
15164
15165 #[allow(clippy::enum_variant_names)]
15166 enum GeneratedField {
15167 Location,
15168 State,
15169 }
15170 impl<'de> serde::Deserialize<'de> for GeneratedField {
15171 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15172 where
15173 D: serde::Deserializer<'de>,
15174 {
15175 struct GeneratedVisitor;
15176
15177 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15178 type Value = GeneratedField;
15179
15180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15181 write!(formatter, "expected one of: {:?}", &FIELDS)
15182 }
15183
15184 #[allow(unused_variables)]
15185 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15186 where
15187 E: serde::de::Error,
15188 {
15189 match value {
15190 "location" => Ok(GeneratedField::Location),
15191 "state" => Ok(GeneratedField::State),
15192 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15193 }
15194 }
15195 }
15196 deserializer.deserialize_identifier(GeneratedVisitor)
15197 }
15198 }
15199 struct GeneratedVisitor;
15200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15201 type Value = table_fragments::ActorStatus;
15202
15203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15204 formatter.write_str("struct meta.TableFragments.ActorStatus")
15205 }
15206
15207 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
15208 where
15209 V: serde::de::MapAccess<'de>,
15210 {
15211 let mut location__ = None;
15212 let mut state__ = None;
15213 while let Some(k) = map_.next_key()? {
15214 match k {
15215 GeneratedField::Location => {
15216 if location__.is_some() {
15217 return Err(serde::de::Error::duplicate_field("location"));
15218 }
15219 location__ = map_.next_value()?;
15220 }
15221 GeneratedField::State => {
15222 if state__.is_some() {
15223 return Err(serde::de::Error::duplicate_field("state"));
15224 }
15225 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
15226 }
15227 }
15228 }
15229 Ok(table_fragments::ActorStatus {
15230 location: location__,
15231 state: state__.unwrap_or_default(),
15232 })
15233 }
15234 }
15235 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
15236 }
15237}
15238impl serde::Serialize for table_fragments::actor_status::ActorState {
15239 #[allow(deprecated)]
15240 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15241 where
15242 S: serde::Serializer,
15243 {
15244 let variant = match self {
15245 Self::Unspecified => "UNSPECIFIED",
15246 Self::Inactive => "INACTIVE",
15247 Self::Running => "RUNNING",
15248 };
15249 serializer.serialize_str(variant)
15250 }
15251}
15252impl<'de> serde::Deserialize<'de> for table_fragments::actor_status::ActorState {
15253 #[allow(deprecated)]
15254 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15255 where
15256 D: serde::Deserializer<'de>,
15257 {
15258 const FIELDS: &[&str] = &[
15259 "UNSPECIFIED",
15260 "INACTIVE",
15261 "RUNNING",
15262 ];
15263
15264 struct GeneratedVisitor;
15265
15266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15267 type Value = table_fragments::actor_status::ActorState;
15268
15269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15270 write!(formatter, "expected one of: {:?}", &FIELDS)
15271 }
15272
15273 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15274 where
15275 E: serde::de::Error,
15276 {
15277 i32::try_from(v)
15278 .ok()
15279 .and_then(|x| x.try_into().ok())
15280 .ok_or_else(|| {
15281 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15282 })
15283 }
15284
15285 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15286 where
15287 E: serde::de::Error,
15288 {
15289 i32::try_from(v)
15290 .ok()
15291 .and_then(|x| x.try_into().ok())
15292 .ok_or_else(|| {
15293 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15294 })
15295 }
15296
15297 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15298 where
15299 E: serde::de::Error,
15300 {
15301 match value {
15302 "UNSPECIFIED" => Ok(table_fragments::actor_status::ActorState::Unspecified),
15303 "INACTIVE" => Ok(table_fragments::actor_status::ActorState::Inactive),
15304 "RUNNING" => Ok(table_fragments::actor_status::ActorState::Running),
15305 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15306 }
15307 }
15308 }
15309 deserializer.deserialize_any(GeneratedVisitor)
15310 }
15311}
15312impl serde::Serialize for table_fragments::Fragment {
15313 #[allow(deprecated)]
15314 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15315 where
15316 S: serde::Serializer,
15317 {
15318 use serde::ser::SerializeStruct;
15319 let mut len = 0;
15320 if self.fragment_id != 0 {
15321 len += 1;
15322 }
15323 if self.fragment_type_mask != 0 {
15324 len += 1;
15325 }
15326 if self.distribution_type != 0 {
15327 len += 1;
15328 }
15329 if !self.actors.is_empty() {
15330 len += 1;
15331 }
15332 if !self.state_table_ids.is_empty() {
15333 len += 1;
15334 }
15335 if !self.upstream_fragment_ids.is_empty() {
15336 len += 1;
15337 }
15338 if self.maybe_vnode_count.is_some() {
15339 len += 1;
15340 }
15341 if self.nodes.is_some() {
15342 len += 1;
15343 }
15344 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
15345 if self.fragment_id != 0 {
15346 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
15347 }
15348 if self.fragment_type_mask != 0 {
15349 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
15350 }
15351 if self.distribution_type != 0 {
15352 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
15353 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
15354 struct_ser.serialize_field("distributionType", &v)?;
15355 }
15356 if !self.actors.is_empty() {
15357 struct_ser.serialize_field("actors", &self.actors)?;
15358 }
15359 if !self.state_table_ids.is_empty() {
15360 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
15361 }
15362 if !self.upstream_fragment_ids.is_empty() {
15363 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
15364 }
15365 if let Some(v) = self.maybe_vnode_count.as_ref() {
15366 struct_ser.serialize_field("maybeVnodeCount", v)?;
15367 }
15368 if let Some(v) = self.nodes.as_ref() {
15369 struct_ser.serialize_field("nodes", v)?;
15370 }
15371 struct_ser.end()
15372 }
15373}
15374impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
15375 #[allow(deprecated)]
15376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15377 where
15378 D: serde::Deserializer<'de>,
15379 {
15380 const FIELDS: &[&str] = &[
15381 "fragment_id",
15382 "fragmentId",
15383 "fragment_type_mask",
15384 "fragmentTypeMask",
15385 "distribution_type",
15386 "distributionType",
15387 "actors",
15388 "state_table_ids",
15389 "stateTableIds",
15390 "upstream_fragment_ids",
15391 "upstreamFragmentIds",
15392 "maybe_vnode_count",
15393 "maybeVnodeCount",
15394 "nodes",
15395 ];
15396
15397 #[allow(clippy::enum_variant_names)]
15398 enum GeneratedField {
15399 FragmentId,
15400 FragmentTypeMask,
15401 DistributionType,
15402 Actors,
15403 StateTableIds,
15404 UpstreamFragmentIds,
15405 MaybeVnodeCount,
15406 Nodes,
15407 }
15408 impl<'de> serde::Deserialize<'de> for GeneratedField {
15409 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15410 where
15411 D: serde::Deserializer<'de>,
15412 {
15413 struct GeneratedVisitor;
15414
15415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15416 type Value = GeneratedField;
15417
15418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15419 write!(formatter, "expected one of: {:?}", &FIELDS)
15420 }
15421
15422 #[allow(unused_variables)]
15423 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15424 where
15425 E: serde::de::Error,
15426 {
15427 match value {
15428 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
15429 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
15430 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
15431 "actors" => Ok(GeneratedField::Actors),
15432 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
15433 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
15434 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
15435 "nodes" => Ok(GeneratedField::Nodes),
15436 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15437 }
15438 }
15439 }
15440 deserializer.deserialize_identifier(GeneratedVisitor)
15441 }
15442 }
15443 struct GeneratedVisitor;
15444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15445 type Value = table_fragments::Fragment;
15446
15447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15448 formatter.write_str("struct meta.TableFragments.Fragment")
15449 }
15450
15451 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
15452 where
15453 V: serde::de::MapAccess<'de>,
15454 {
15455 let mut fragment_id__ = None;
15456 let mut fragment_type_mask__ = None;
15457 let mut distribution_type__ = None;
15458 let mut actors__ = None;
15459 let mut state_table_ids__ = None;
15460 let mut upstream_fragment_ids__ = None;
15461 let mut maybe_vnode_count__ = None;
15462 let mut nodes__ = None;
15463 while let Some(k) = map_.next_key()? {
15464 match k {
15465 GeneratedField::FragmentId => {
15466 if fragment_id__.is_some() {
15467 return Err(serde::de::Error::duplicate_field("fragmentId"));
15468 }
15469 fragment_id__ =
15470 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15471 ;
15472 }
15473 GeneratedField::FragmentTypeMask => {
15474 if fragment_type_mask__.is_some() {
15475 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
15476 }
15477 fragment_type_mask__ =
15478 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15479 ;
15480 }
15481 GeneratedField::DistributionType => {
15482 if distribution_type__.is_some() {
15483 return Err(serde::de::Error::duplicate_field("distributionType"));
15484 }
15485 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
15486 }
15487 GeneratedField::Actors => {
15488 if actors__.is_some() {
15489 return Err(serde::de::Error::duplicate_field("actors"));
15490 }
15491 actors__ = Some(map_.next_value()?);
15492 }
15493 GeneratedField::StateTableIds => {
15494 if state_table_ids__.is_some() {
15495 return Err(serde::de::Error::duplicate_field("stateTableIds"));
15496 }
15497 state_table_ids__ =
15498 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15499 .into_iter().map(|x| x.0).collect())
15500 ;
15501 }
15502 GeneratedField::UpstreamFragmentIds => {
15503 if upstream_fragment_ids__.is_some() {
15504 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
15505 }
15506 upstream_fragment_ids__ =
15507 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15508 .into_iter().map(|x| x.0).collect())
15509 ;
15510 }
15511 GeneratedField::MaybeVnodeCount => {
15512 if maybe_vnode_count__.is_some() {
15513 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
15514 }
15515 maybe_vnode_count__ =
15516 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15517 ;
15518 }
15519 GeneratedField::Nodes => {
15520 if nodes__.is_some() {
15521 return Err(serde::de::Error::duplicate_field("nodes"));
15522 }
15523 nodes__ = map_.next_value()?;
15524 }
15525 }
15526 }
15527 Ok(table_fragments::Fragment {
15528 fragment_id: fragment_id__.unwrap_or_default(),
15529 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
15530 distribution_type: distribution_type__.unwrap_or_default(),
15531 actors: actors__.unwrap_or_default(),
15532 state_table_ids: state_table_ids__.unwrap_or_default(),
15533 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
15534 maybe_vnode_count: maybe_vnode_count__,
15535 nodes: nodes__,
15536 })
15537 }
15538 }
15539 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
15540 }
15541}
15542impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
15543 #[allow(deprecated)]
15544 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15545 where
15546 S: serde::Serializer,
15547 {
15548 let variant = match self {
15549 Self::Unspecified => "UNSPECIFIED",
15550 Self::Single => "SINGLE",
15551 Self::Hash => "HASH",
15552 };
15553 serializer.serialize_str(variant)
15554 }
15555}
15556impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
15557 #[allow(deprecated)]
15558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15559 where
15560 D: serde::Deserializer<'de>,
15561 {
15562 const FIELDS: &[&str] = &[
15563 "UNSPECIFIED",
15564 "SINGLE",
15565 "HASH",
15566 ];
15567
15568 struct GeneratedVisitor;
15569
15570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15571 type Value = table_fragments::fragment::FragmentDistributionType;
15572
15573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15574 write!(formatter, "expected one of: {:?}", &FIELDS)
15575 }
15576
15577 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15578 where
15579 E: serde::de::Error,
15580 {
15581 i32::try_from(v)
15582 .ok()
15583 .and_then(|x| x.try_into().ok())
15584 .ok_or_else(|| {
15585 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15586 })
15587 }
15588
15589 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15590 where
15591 E: serde::de::Error,
15592 {
15593 i32::try_from(v)
15594 .ok()
15595 .and_then(|x| x.try_into().ok())
15596 .ok_or_else(|| {
15597 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15598 })
15599 }
15600
15601 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15602 where
15603 E: serde::de::Error,
15604 {
15605 match value {
15606 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
15607 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
15608 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
15609 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15610 }
15611 }
15612 }
15613 deserializer.deserialize_any(GeneratedVisitor)
15614 }
15615}
15616impl serde::Serialize for table_fragments::State {
15617 #[allow(deprecated)]
15618 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15619 where
15620 S: serde::Serializer,
15621 {
15622 let variant = match self {
15623 Self::Unspecified => "UNSPECIFIED",
15624 Self::Initial => "INITIAL",
15625 Self::Creating => "CREATING",
15626 Self::Created => "CREATED",
15627 };
15628 serializer.serialize_str(variant)
15629 }
15630}
15631impl<'de> serde::Deserialize<'de> for table_fragments::State {
15632 #[allow(deprecated)]
15633 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15634 where
15635 D: serde::Deserializer<'de>,
15636 {
15637 const FIELDS: &[&str] = &[
15638 "UNSPECIFIED",
15639 "INITIAL",
15640 "CREATING",
15641 "CREATED",
15642 ];
15643
15644 struct GeneratedVisitor;
15645
15646 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15647 type Value = table_fragments::State;
15648
15649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15650 write!(formatter, "expected one of: {:?}", &FIELDS)
15651 }
15652
15653 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15654 where
15655 E: serde::de::Error,
15656 {
15657 i32::try_from(v)
15658 .ok()
15659 .and_then(|x| x.try_into().ok())
15660 .ok_or_else(|| {
15661 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15662 })
15663 }
15664
15665 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15666 where
15667 E: serde::de::Error,
15668 {
15669 i32::try_from(v)
15670 .ok()
15671 .and_then(|x| x.try_into().ok())
15672 .ok_or_else(|| {
15673 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15674 })
15675 }
15676
15677 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15678 where
15679 E: serde::de::Error,
15680 {
15681 match value {
15682 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
15683 "INITIAL" => Ok(table_fragments::State::Initial),
15684 "CREATING" => Ok(table_fragments::State::Creating),
15685 "CREATED" => Ok(table_fragments::State::Created),
15686 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15687 }
15688 }
15689 }
15690 deserializer.deserialize_any(GeneratedVisitor)
15691 }
15692}
15693impl serde::Serialize for TableParallelism {
15694 #[allow(deprecated)]
15695 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15696 where
15697 S: serde::Serializer,
15698 {
15699 use serde::ser::SerializeStruct;
15700 let mut len = 0;
15701 if self.parallelism.is_some() {
15702 len += 1;
15703 }
15704 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
15705 if let Some(v) = self.parallelism.as_ref() {
15706 match v {
15707 table_parallelism::Parallelism::Fixed(v) => {
15708 struct_ser.serialize_field("fixed", v)?;
15709 }
15710 table_parallelism::Parallelism::Auto(v) => {
15711 struct_ser.serialize_field("auto", v)?;
15712 }
15713 table_parallelism::Parallelism::Custom(v) => {
15714 struct_ser.serialize_field("custom", v)?;
15715 }
15716 table_parallelism::Parallelism::Adaptive(v) => {
15717 struct_ser.serialize_field("adaptive", v)?;
15718 }
15719 }
15720 }
15721 struct_ser.end()
15722 }
15723}
15724impl<'de> serde::Deserialize<'de> for TableParallelism {
15725 #[allow(deprecated)]
15726 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15727 where
15728 D: serde::Deserializer<'de>,
15729 {
15730 const FIELDS: &[&str] = &[
15731 "fixed",
15732 "auto",
15733 "custom",
15734 "adaptive",
15735 ];
15736
15737 #[allow(clippy::enum_variant_names)]
15738 enum GeneratedField {
15739 Fixed,
15740 Auto,
15741 Custom,
15742 Adaptive,
15743 }
15744 impl<'de> serde::Deserialize<'de> for GeneratedField {
15745 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15746 where
15747 D: serde::Deserializer<'de>,
15748 {
15749 struct GeneratedVisitor;
15750
15751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15752 type Value = GeneratedField;
15753
15754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15755 write!(formatter, "expected one of: {:?}", &FIELDS)
15756 }
15757
15758 #[allow(unused_variables)]
15759 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15760 where
15761 E: serde::de::Error,
15762 {
15763 match value {
15764 "fixed" => Ok(GeneratedField::Fixed),
15765 "auto" => Ok(GeneratedField::Auto),
15766 "custom" => Ok(GeneratedField::Custom),
15767 "adaptive" => Ok(GeneratedField::Adaptive),
15768 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15769 }
15770 }
15771 }
15772 deserializer.deserialize_identifier(GeneratedVisitor)
15773 }
15774 }
15775 struct GeneratedVisitor;
15776 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15777 type Value = TableParallelism;
15778
15779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15780 formatter.write_str("struct meta.TableParallelism")
15781 }
15782
15783 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
15784 where
15785 V: serde::de::MapAccess<'de>,
15786 {
15787 let mut parallelism__ = None;
15788 while let Some(k) = map_.next_key()? {
15789 match k {
15790 GeneratedField::Fixed => {
15791 if parallelism__.is_some() {
15792 return Err(serde::de::Error::duplicate_field("fixed"));
15793 }
15794 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
15795;
15796 }
15797 GeneratedField::Auto => {
15798 if parallelism__.is_some() {
15799 return Err(serde::de::Error::duplicate_field("auto"));
15800 }
15801 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
15802;
15803 }
15804 GeneratedField::Custom => {
15805 if parallelism__.is_some() {
15806 return Err(serde::de::Error::duplicate_field("custom"));
15807 }
15808 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
15809;
15810 }
15811 GeneratedField::Adaptive => {
15812 if parallelism__.is_some() {
15813 return Err(serde::de::Error::duplicate_field("adaptive"));
15814 }
15815 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
15816;
15817 }
15818 }
15819 }
15820 Ok(TableParallelism {
15821 parallelism: parallelism__,
15822 })
15823 }
15824 }
15825 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
15826 }
15827}
15828impl serde::Serialize for table_parallelism::AdaptiveParallelism {
15829 #[allow(deprecated)]
15830 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15831 where
15832 S: serde::Serializer,
15833 {
15834 use serde::ser::SerializeStruct;
15835 let len = 0;
15836 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
15837 struct_ser.end()
15838 }
15839}
15840impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
15841 #[allow(deprecated)]
15842 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15843 where
15844 D: serde::Deserializer<'de>,
15845 {
15846 const FIELDS: &[&str] = &[
15847 ];
15848
15849 #[allow(clippy::enum_variant_names)]
15850 enum GeneratedField {
15851 }
15852 impl<'de> serde::Deserialize<'de> for GeneratedField {
15853 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15854 where
15855 D: serde::Deserializer<'de>,
15856 {
15857 struct GeneratedVisitor;
15858
15859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15860 type Value = GeneratedField;
15861
15862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15863 write!(formatter, "expected one of: {:?}", &FIELDS)
15864 }
15865
15866 #[allow(unused_variables)]
15867 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15868 where
15869 E: serde::de::Error,
15870 {
15871 Err(serde::de::Error::unknown_field(value, FIELDS))
15872 }
15873 }
15874 deserializer.deserialize_identifier(GeneratedVisitor)
15875 }
15876 }
15877 struct GeneratedVisitor;
15878 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15879 type Value = table_parallelism::AdaptiveParallelism;
15880
15881 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15882 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
15883 }
15884
15885 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
15886 where
15887 V: serde::de::MapAccess<'de>,
15888 {
15889 while map_.next_key::<GeneratedField>()?.is_some() {
15890 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15891 }
15892 Ok(table_parallelism::AdaptiveParallelism {
15893 })
15894 }
15895 }
15896 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
15897 }
15898}
15899impl serde::Serialize for table_parallelism::AutoParallelism {
15900 #[allow(deprecated)]
15901 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15902 where
15903 S: serde::Serializer,
15904 {
15905 use serde::ser::SerializeStruct;
15906 let len = 0;
15907 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
15908 struct_ser.end()
15909 }
15910}
15911impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
15912 #[allow(deprecated)]
15913 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15914 where
15915 D: serde::Deserializer<'de>,
15916 {
15917 const FIELDS: &[&str] = &[
15918 ];
15919
15920 #[allow(clippy::enum_variant_names)]
15921 enum GeneratedField {
15922 }
15923 impl<'de> serde::Deserialize<'de> for GeneratedField {
15924 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15925 where
15926 D: serde::Deserializer<'de>,
15927 {
15928 struct GeneratedVisitor;
15929
15930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15931 type Value = GeneratedField;
15932
15933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15934 write!(formatter, "expected one of: {:?}", &FIELDS)
15935 }
15936
15937 #[allow(unused_variables)]
15938 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15939 where
15940 E: serde::de::Error,
15941 {
15942 Err(serde::de::Error::unknown_field(value, FIELDS))
15943 }
15944 }
15945 deserializer.deserialize_identifier(GeneratedVisitor)
15946 }
15947 }
15948 struct GeneratedVisitor;
15949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15950 type Value = table_parallelism::AutoParallelism;
15951
15952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15953 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
15954 }
15955
15956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
15957 where
15958 V: serde::de::MapAccess<'de>,
15959 {
15960 while map_.next_key::<GeneratedField>()?.is_some() {
15961 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15962 }
15963 Ok(table_parallelism::AutoParallelism {
15964 })
15965 }
15966 }
15967 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
15968 }
15969}
15970impl serde::Serialize for table_parallelism::CustomParallelism {
15971 #[allow(deprecated)]
15972 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15973 where
15974 S: serde::Serializer,
15975 {
15976 use serde::ser::SerializeStruct;
15977 let len = 0;
15978 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
15979 struct_ser.end()
15980 }
15981}
15982impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
15983 #[allow(deprecated)]
15984 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15985 where
15986 D: serde::Deserializer<'de>,
15987 {
15988 const FIELDS: &[&str] = &[
15989 ];
15990
15991 #[allow(clippy::enum_variant_names)]
15992 enum GeneratedField {
15993 }
15994 impl<'de> serde::Deserialize<'de> for GeneratedField {
15995 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15996 where
15997 D: serde::Deserializer<'de>,
15998 {
15999 struct GeneratedVisitor;
16000
16001 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16002 type Value = GeneratedField;
16003
16004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16005 write!(formatter, "expected one of: {:?}", &FIELDS)
16006 }
16007
16008 #[allow(unused_variables)]
16009 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16010 where
16011 E: serde::de::Error,
16012 {
16013 Err(serde::de::Error::unknown_field(value, FIELDS))
16014 }
16015 }
16016 deserializer.deserialize_identifier(GeneratedVisitor)
16017 }
16018 }
16019 struct GeneratedVisitor;
16020 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16021 type Value = table_parallelism::CustomParallelism;
16022
16023 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16024 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
16025 }
16026
16027 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
16028 where
16029 V: serde::de::MapAccess<'de>,
16030 {
16031 while map_.next_key::<GeneratedField>()?.is_some() {
16032 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16033 }
16034 Ok(table_parallelism::CustomParallelism {
16035 })
16036 }
16037 }
16038 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
16039 }
16040}
16041impl serde::Serialize for table_parallelism::FixedParallelism {
16042 #[allow(deprecated)]
16043 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16044 where
16045 S: serde::Serializer,
16046 {
16047 use serde::ser::SerializeStruct;
16048 let mut len = 0;
16049 if self.parallelism != 0 {
16050 len += 1;
16051 }
16052 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
16053 if self.parallelism != 0 {
16054 struct_ser.serialize_field("parallelism", &self.parallelism)?;
16055 }
16056 struct_ser.end()
16057 }
16058}
16059impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
16060 #[allow(deprecated)]
16061 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16062 where
16063 D: serde::Deserializer<'de>,
16064 {
16065 const FIELDS: &[&str] = &[
16066 "parallelism",
16067 ];
16068
16069 #[allow(clippy::enum_variant_names)]
16070 enum GeneratedField {
16071 Parallelism,
16072 }
16073 impl<'de> serde::Deserialize<'de> for GeneratedField {
16074 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16075 where
16076 D: serde::Deserializer<'de>,
16077 {
16078 struct GeneratedVisitor;
16079
16080 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16081 type Value = GeneratedField;
16082
16083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16084 write!(formatter, "expected one of: {:?}", &FIELDS)
16085 }
16086
16087 #[allow(unused_variables)]
16088 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16089 where
16090 E: serde::de::Error,
16091 {
16092 match value {
16093 "parallelism" => Ok(GeneratedField::Parallelism),
16094 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16095 }
16096 }
16097 }
16098 deserializer.deserialize_identifier(GeneratedVisitor)
16099 }
16100 }
16101 struct GeneratedVisitor;
16102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16103 type Value = table_parallelism::FixedParallelism;
16104
16105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16106 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
16107 }
16108
16109 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
16110 where
16111 V: serde::de::MapAccess<'de>,
16112 {
16113 let mut parallelism__ = None;
16114 while let Some(k) = map_.next_key()? {
16115 match k {
16116 GeneratedField::Parallelism => {
16117 if parallelism__.is_some() {
16118 return Err(serde::de::Error::duplicate_field("parallelism"));
16119 }
16120 parallelism__ =
16121 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16122 ;
16123 }
16124 }
16125 }
16126 Ok(table_parallelism::FixedParallelism {
16127 parallelism: parallelism__.unwrap_or_default(),
16128 })
16129 }
16130 }
16131 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
16132 }
16133}
16134impl serde::Serialize for TelemetryInfoResponse {
16135 #[allow(deprecated)]
16136 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16137 where
16138 S: serde::Serializer,
16139 {
16140 use serde::ser::SerializeStruct;
16141 let mut len = 0;
16142 if self.tracking_id.is_some() {
16143 len += 1;
16144 }
16145 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
16146 if let Some(v) = self.tracking_id.as_ref() {
16147 struct_ser.serialize_field("trackingId", v)?;
16148 }
16149 struct_ser.end()
16150 }
16151}
16152impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
16153 #[allow(deprecated)]
16154 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16155 where
16156 D: serde::Deserializer<'de>,
16157 {
16158 const FIELDS: &[&str] = &[
16159 "tracking_id",
16160 "trackingId",
16161 ];
16162
16163 #[allow(clippy::enum_variant_names)]
16164 enum GeneratedField {
16165 TrackingId,
16166 }
16167 impl<'de> serde::Deserialize<'de> for GeneratedField {
16168 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16169 where
16170 D: serde::Deserializer<'de>,
16171 {
16172 struct GeneratedVisitor;
16173
16174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16175 type Value = GeneratedField;
16176
16177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16178 write!(formatter, "expected one of: {:?}", &FIELDS)
16179 }
16180
16181 #[allow(unused_variables)]
16182 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16183 where
16184 E: serde::de::Error,
16185 {
16186 match value {
16187 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
16188 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16189 }
16190 }
16191 }
16192 deserializer.deserialize_identifier(GeneratedVisitor)
16193 }
16194 }
16195 struct GeneratedVisitor;
16196 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16197 type Value = TelemetryInfoResponse;
16198
16199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16200 formatter.write_str("struct meta.TelemetryInfoResponse")
16201 }
16202
16203 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
16204 where
16205 V: serde::de::MapAccess<'de>,
16206 {
16207 let mut tracking_id__ = None;
16208 while let Some(k) = map_.next_key()? {
16209 match k {
16210 GeneratedField::TrackingId => {
16211 if tracking_id__.is_some() {
16212 return Err(serde::de::Error::duplicate_field("trackingId"));
16213 }
16214 tracking_id__ = map_.next_value()?;
16215 }
16216 }
16217 }
16218 Ok(TelemetryInfoResponse {
16219 tracking_id: tracking_id__,
16220 })
16221 }
16222 }
16223 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
16224 }
16225}
16226impl serde::Serialize for ThrottleTarget {
16227 #[allow(deprecated)]
16228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16229 where
16230 S: serde::Serializer,
16231 {
16232 let variant = match self {
16233 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
16234 Self::Source => "SOURCE",
16235 Self::Mv => "MV",
16236 Self::TableWithSource => "TABLE_WITH_SOURCE",
16237 Self::CdcTable => "CDC_TABLE",
16238 Self::TableDml => "TABLE_DML",
16239 Self::Sink => "SINK",
16240 Self::Fragment => "FRAGMENT",
16241 };
16242 serializer.serialize_str(variant)
16243 }
16244}
16245impl<'de> serde::Deserialize<'de> for ThrottleTarget {
16246 #[allow(deprecated)]
16247 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16248 where
16249 D: serde::Deserializer<'de>,
16250 {
16251 const FIELDS: &[&str] = &[
16252 "THROTTLE_TARGET_UNSPECIFIED",
16253 "SOURCE",
16254 "MV",
16255 "TABLE_WITH_SOURCE",
16256 "CDC_TABLE",
16257 "TABLE_DML",
16258 "SINK",
16259 "FRAGMENT",
16260 ];
16261
16262 struct GeneratedVisitor;
16263
16264 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16265 type Value = ThrottleTarget;
16266
16267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16268 write!(formatter, "expected one of: {:?}", &FIELDS)
16269 }
16270
16271 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16272 where
16273 E: serde::de::Error,
16274 {
16275 i32::try_from(v)
16276 .ok()
16277 .and_then(|x| x.try_into().ok())
16278 .ok_or_else(|| {
16279 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16280 })
16281 }
16282
16283 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16284 where
16285 E: serde::de::Error,
16286 {
16287 i32::try_from(v)
16288 .ok()
16289 .and_then(|x| x.try_into().ok())
16290 .ok_or_else(|| {
16291 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16292 })
16293 }
16294
16295 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16296 where
16297 E: serde::de::Error,
16298 {
16299 match value {
16300 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
16301 "SOURCE" => Ok(ThrottleTarget::Source),
16302 "MV" => Ok(ThrottleTarget::Mv),
16303 "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
16304 "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
16305 "TABLE_DML" => Ok(ThrottleTarget::TableDml),
16306 "SINK" => Ok(ThrottleTarget::Sink),
16307 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
16308 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16309 }
16310 }
16311 }
16312 deserializer.deserialize_any(GeneratedVisitor)
16313 }
16314}
16315impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
16316 #[allow(deprecated)]
16317 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16318 where
16319 S: serde::Serializer,
16320 {
16321 use serde::ser::SerializeStruct;
16322 let mut len = 0;
16323 if self.id != 0 {
16324 len += 1;
16325 }
16326 if !self.node_label.is_empty() {
16327 len += 1;
16328 }
16329 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
16330 if self.id != 0 {
16331 struct_ser.serialize_field("id", &self.id)?;
16332 }
16333 if !self.node_label.is_empty() {
16334 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
16335 }
16336 struct_ser.end()
16337 }
16338}
16339impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
16340 #[allow(deprecated)]
16341 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16342 where
16343 D: serde::Deserializer<'de>,
16344 {
16345 const FIELDS: &[&str] = &[
16346 "id",
16347 "node_label",
16348 "nodeLabel",
16349 ];
16350
16351 #[allow(clippy::enum_variant_names)]
16352 enum GeneratedField {
16353 Id,
16354 NodeLabel,
16355 }
16356 impl<'de> serde::Deserialize<'de> for GeneratedField {
16357 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16358 where
16359 D: serde::Deserializer<'de>,
16360 {
16361 struct GeneratedVisitor;
16362
16363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16364 type Value = GeneratedField;
16365
16366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16367 write!(formatter, "expected one of: {:?}", &FIELDS)
16368 }
16369
16370 #[allow(unused_variables)]
16371 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16372 where
16373 E: serde::de::Error,
16374 {
16375 match value {
16376 "id" => Ok(GeneratedField::Id),
16377 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
16378 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16379 }
16380 }
16381 }
16382 deserializer.deserialize_identifier(GeneratedVisitor)
16383 }
16384 }
16385 struct GeneratedVisitor;
16386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16387 type Value = UpdateStreamingJobNodeLabelsRequest;
16388
16389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16390 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
16391 }
16392
16393 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
16394 where
16395 V: serde::de::MapAccess<'de>,
16396 {
16397 let mut id__ = None;
16398 let mut node_label__ = None;
16399 while let Some(k) = map_.next_key()? {
16400 match k {
16401 GeneratedField::Id => {
16402 if id__.is_some() {
16403 return Err(serde::de::Error::duplicate_field("id"));
16404 }
16405 id__ =
16406 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16407 ;
16408 }
16409 GeneratedField::NodeLabel => {
16410 if node_label__.is_some() {
16411 return Err(serde::de::Error::duplicate_field("nodeLabel"));
16412 }
16413 node_label__ = Some(map_.next_value()?);
16414 }
16415 }
16416 }
16417 Ok(UpdateStreamingJobNodeLabelsRequest {
16418 id: id__.unwrap_or_default(),
16419 node_label: node_label__.unwrap_or_default(),
16420 })
16421 }
16422 }
16423 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
16424 }
16425}
16426impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
16427 #[allow(deprecated)]
16428 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16429 where
16430 S: serde::Serializer,
16431 {
16432 use serde::ser::SerializeStruct;
16433 let len = 0;
16434 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
16435 struct_ser.end()
16436 }
16437}
16438impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
16439 #[allow(deprecated)]
16440 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16441 where
16442 D: serde::Deserializer<'de>,
16443 {
16444 const FIELDS: &[&str] = &[
16445 ];
16446
16447 #[allow(clippy::enum_variant_names)]
16448 enum GeneratedField {
16449 }
16450 impl<'de> serde::Deserialize<'de> for GeneratedField {
16451 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16452 where
16453 D: serde::Deserializer<'de>,
16454 {
16455 struct GeneratedVisitor;
16456
16457 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16458 type Value = GeneratedField;
16459
16460 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16461 write!(formatter, "expected one of: {:?}", &FIELDS)
16462 }
16463
16464 #[allow(unused_variables)]
16465 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16466 where
16467 E: serde::de::Error,
16468 {
16469 Err(serde::de::Error::unknown_field(value, FIELDS))
16470 }
16471 }
16472 deserializer.deserialize_identifier(GeneratedVisitor)
16473 }
16474 }
16475 struct GeneratedVisitor;
16476 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16477 type Value = UpdateStreamingJobNodeLabelsResponse;
16478
16479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16480 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
16481 }
16482
16483 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
16484 where
16485 V: serde::de::MapAccess<'de>,
16486 {
16487 while map_.next_key::<GeneratedField>()?.is_some() {
16488 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16489 }
16490 Ok(UpdateStreamingJobNodeLabelsResponse {
16491 })
16492 }
16493 }
16494 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
16495 }
16496}
16497impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
16498 #[allow(deprecated)]
16499 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16500 where
16501 S: serde::Serializer,
16502 {
16503 use serde::ser::SerializeStruct;
16504 let mut len = 0;
16505 if !self.worker_ids.is_empty() {
16506 len += 1;
16507 }
16508 if self.schedulability != 0 {
16509 len += 1;
16510 }
16511 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
16512 if !self.worker_ids.is_empty() {
16513 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
16514 }
16515 if self.schedulability != 0 {
16516 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
16517 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
16518 struct_ser.serialize_field("schedulability", &v)?;
16519 }
16520 struct_ser.end()
16521 }
16522}
16523impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
16524 #[allow(deprecated)]
16525 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16526 where
16527 D: serde::Deserializer<'de>,
16528 {
16529 const FIELDS: &[&str] = &[
16530 "worker_ids",
16531 "workerIds",
16532 "schedulability",
16533 ];
16534
16535 #[allow(clippy::enum_variant_names)]
16536 enum GeneratedField {
16537 WorkerIds,
16538 Schedulability,
16539 }
16540 impl<'de> serde::Deserialize<'de> for GeneratedField {
16541 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16542 where
16543 D: serde::Deserializer<'de>,
16544 {
16545 struct GeneratedVisitor;
16546
16547 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16548 type Value = GeneratedField;
16549
16550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16551 write!(formatter, "expected one of: {:?}", &FIELDS)
16552 }
16553
16554 #[allow(unused_variables)]
16555 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16556 where
16557 E: serde::de::Error,
16558 {
16559 match value {
16560 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
16561 "schedulability" => Ok(GeneratedField::Schedulability),
16562 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16563 }
16564 }
16565 }
16566 deserializer.deserialize_identifier(GeneratedVisitor)
16567 }
16568 }
16569 struct GeneratedVisitor;
16570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16571 type Value = UpdateWorkerNodeSchedulabilityRequest;
16572
16573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16574 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
16575 }
16576
16577 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
16578 where
16579 V: serde::de::MapAccess<'de>,
16580 {
16581 let mut worker_ids__ = None;
16582 let mut schedulability__ = None;
16583 while let Some(k) = map_.next_key()? {
16584 match k {
16585 GeneratedField::WorkerIds => {
16586 if worker_ids__.is_some() {
16587 return Err(serde::de::Error::duplicate_field("workerIds"));
16588 }
16589 worker_ids__ =
16590 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16591 .into_iter().map(|x| x.0).collect())
16592 ;
16593 }
16594 GeneratedField::Schedulability => {
16595 if schedulability__.is_some() {
16596 return Err(serde::de::Error::duplicate_field("schedulability"));
16597 }
16598 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
16599 }
16600 }
16601 }
16602 Ok(UpdateWorkerNodeSchedulabilityRequest {
16603 worker_ids: worker_ids__.unwrap_or_default(),
16604 schedulability: schedulability__.unwrap_or_default(),
16605 })
16606 }
16607 }
16608 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
16609 }
16610}
16611impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
16612 #[allow(deprecated)]
16613 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16614 where
16615 S: serde::Serializer,
16616 {
16617 let variant = match self {
16618 Self::Unspecified => "UNSPECIFIED",
16619 Self::Schedulable => "SCHEDULABLE",
16620 Self::Unschedulable => "UNSCHEDULABLE",
16621 };
16622 serializer.serialize_str(variant)
16623 }
16624}
16625impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
16626 #[allow(deprecated)]
16627 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16628 where
16629 D: serde::Deserializer<'de>,
16630 {
16631 const FIELDS: &[&str] = &[
16632 "UNSPECIFIED",
16633 "SCHEDULABLE",
16634 "UNSCHEDULABLE",
16635 ];
16636
16637 struct GeneratedVisitor;
16638
16639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16640 type Value = update_worker_node_schedulability_request::Schedulability;
16641
16642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16643 write!(formatter, "expected one of: {:?}", &FIELDS)
16644 }
16645
16646 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16647 where
16648 E: serde::de::Error,
16649 {
16650 i32::try_from(v)
16651 .ok()
16652 .and_then(|x| x.try_into().ok())
16653 .ok_or_else(|| {
16654 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16655 })
16656 }
16657
16658 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16659 where
16660 E: serde::de::Error,
16661 {
16662 i32::try_from(v)
16663 .ok()
16664 .and_then(|x| x.try_into().ok())
16665 .ok_or_else(|| {
16666 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16667 })
16668 }
16669
16670 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16671 where
16672 E: serde::de::Error,
16673 {
16674 match value {
16675 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
16676 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
16677 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
16678 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16679 }
16680 }
16681 }
16682 deserializer.deserialize_any(GeneratedVisitor)
16683 }
16684}
16685impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
16686 #[allow(deprecated)]
16687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16688 where
16689 S: serde::Serializer,
16690 {
16691 use serde::ser::SerializeStruct;
16692 let mut len = 0;
16693 if self.status.is_some() {
16694 len += 1;
16695 }
16696 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
16697 if let Some(v) = self.status.as_ref() {
16698 struct_ser.serialize_field("status", v)?;
16699 }
16700 struct_ser.end()
16701 }
16702}
16703impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
16704 #[allow(deprecated)]
16705 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16706 where
16707 D: serde::Deserializer<'de>,
16708 {
16709 const FIELDS: &[&str] = &[
16710 "status",
16711 ];
16712
16713 #[allow(clippy::enum_variant_names)]
16714 enum GeneratedField {
16715 Status,
16716 }
16717 impl<'de> serde::Deserialize<'de> for GeneratedField {
16718 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16719 where
16720 D: serde::Deserializer<'de>,
16721 {
16722 struct GeneratedVisitor;
16723
16724 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16725 type Value = GeneratedField;
16726
16727 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16728 write!(formatter, "expected one of: {:?}", &FIELDS)
16729 }
16730
16731 #[allow(unused_variables)]
16732 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16733 where
16734 E: serde::de::Error,
16735 {
16736 match value {
16737 "status" => Ok(GeneratedField::Status),
16738 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16739 }
16740 }
16741 }
16742 deserializer.deserialize_identifier(GeneratedVisitor)
16743 }
16744 }
16745 struct GeneratedVisitor;
16746 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16747 type Value = UpdateWorkerNodeSchedulabilityResponse;
16748
16749 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16750 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
16751 }
16752
16753 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
16754 where
16755 V: serde::de::MapAccess<'de>,
16756 {
16757 let mut status__ = None;
16758 while let Some(k) = map_.next_key()? {
16759 match k {
16760 GeneratedField::Status => {
16761 if status__.is_some() {
16762 return Err(serde::de::Error::duplicate_field("status"));
16763 }
16764 status__ = map_.next_value()?;
16765 }
16766 }
16767 }
16768 Ok(UpdateWorkerNodeSchedulabilityResponse {
16769 status: status__,
16770 })
16771 }
16772 }
16773 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
16774 }
16775}
16776impl serde::Serialize for WorkerReschedule {
16777 #[allow(deprecated)]
16778 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16779 where
16780 S: serde::Serializer,
16781 {
16782 use serde::ser::SerializeStruct;
16783 let mut len = 0;
16784 if !self.worker_actor_diff.is_empty() {
16785 len += 1;
16786 }
16787 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
16788 if !self.worker_actor_diff.is_empty() {
16789 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
16790 }
16791 struct_ser.end()
16792 }
16793}
16794impl<'de> serde::Deserialize<'de> for WorkerReschedule {
16795 #[allow(deprecated)]
16796 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16797 where
16798 D: serde::Deserializer<'de>,
16799 {
16800 const FIELDS: &[&str] = &[
16801 "worker_actor_diff",
16802 "workerActorDiff",
16803 ];
16804
16805 #[allow(clippy::enum_variant_names)]
16806 enum GeneratedField {
16807 WorkerActorDiff,
16808 }
16809 impl<'de> serde::Deserialize<'de> for GeneratedField {
16810 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16811 where
16812 D: serde::Deserializer<'de>,
16813 {
16814 struct GeneratedVisitor;
16815
16816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16817 type Value = GeneratedField;
16818
16819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16820 write!(formatter, "expected one of: {:?}", &FIELDS)
16821 }
16822
16823 #[allow(unused_variables)]
16824 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16825 where
16826 E: serde::de::Error,
16827 {
16828 match value {
16829 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
16830 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16831 }
16832 }
16833 }
16834 deserializer.deserialize_identifier(GeneratedVisitor)
16835 }
16836 }
16837 struct GeneratedVisitor;
16838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16839 type Value = WorkerReschedule;
16840
16841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16842 formatter.write_str("struct meta.WorkerReschedule")
16843 }
16844
16845 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
16846 where
16847 V: serde::de::MapAccess<'de>,
16848 {
16849 let mut worker_actor_diff__ = None;
16850 while let Some(k) = map_.next_key()? {
16851 match k {
16852 GeneratedField::WorkerActorDiff => {
16853 if worker_actor_diff__.is_some() {
16854 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
16855 }
16856 worker_actor_diff__ = Some(
16857 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
16858 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
16859 );
16860 }
16861 }
16862 }
16863 Ok(WorkerReschedule {
16864 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
16865 })
16866 }
16867 }
16868 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
16869 }
16870}