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 add_event_log_request::Event::AutoSchemaChangeFail(v) => {
683 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
684 }
685 }
686 }
687 struct_ser.end()
688 }
689}
690impl<'de> serde::Deserialize<'de> for AddEventLogRequest {
691 #[allow(deprecated)]
692 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
693 where
694 D: serde::Deserializer<'de>,
695 {
696 const FIELDS: &[&str] = &[
697 "worker_node_panic",
698 "workerNodePanic",
699 "sink_fail",
700 "sinkFail",
701 "auto_schema_change_fail",
702 "autoSchemaChangeFail",
703 ];
704
705 #[allow(clippy::enum_variant_names)]
706 enum GeneratedField {
707 WorkerNodePanic,
708 SinkFail,
709 AutoSchemaChangeFail,
710 }
711 impl<'de> serde::Deserialize<'de> for GeneratedField {
712 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
713 where
714 D: serde::Deserializer<'de>,
715 {
716 struct GeneratedVisitor;
717
718 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
719 type Value = GeneratedField;
720
721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
722 write!(formatter, "expected one of: {:?}", &FIELDS)
723 }
724
725 #[allow(unused_variables)]
726 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
727 where
728 E: serde::de::Error,
729 {
730 match value {
731 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
732 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
733 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
734 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
735 }
736 }
737 }
738 deserializer.deserialize_identifier(GeneratedVisitor)
739 }
740 }
741 struct GeneratedVisitor;
742 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
743 type Value = AddEventLogRequest;
744
745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
746 formatter.write_str("struct meta.AddEventLogRequest")
747 }
748
749 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogRequest, V::Error>
750 where
751 V: serde::de::MapAccess<'de>,
752 {
753 let mut event__ = None;
754 while let Some(k) = map_.next_key()? {
755 match k {
756 GeneratedField::WorkerNodePanic => {
757 if event__.is_some() {
758 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
759 }
760 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::WorkerNodePanic)
761;
762 }
763 GeneratedField::SinkFail => {
764 if event__.is_some() {
765 return Err(serde::de::Error::duplicate_field("sinkFail"));
766 }
767 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::SinkFail)
768;
769 }
770 GeneratedField::AutoSchemaChangeFail => {
771 if event__.is_some() {
772 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
773 }
774 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::AutoSchemaChangeFail)
775;
776 }
777 }
778 }
779 Ok(AddEventLogRequest {
780 event: event__,
781 })
782 }
783 }
784 deserializer.deserialize_struct("meta.AddEventLogRequest", FIELDS, GeneratedVisitor)
785 }
786}
787impl serde::Serialize for AddEventLogResponse {
788 #[allow(deprecated)]
789 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
790 where
791 S: serde::Serializer,
792 {
793 use serde::ser::SerializeStruct;
794 let len = 0;
795 let struct_ser = serializer.serialize_struct("meta.AddEventLogResponse", len)?;
796 struct_ser.end()
797 }
798}
799impl<'de> serde::Deserialize<'de> for AddEventLogResponse {
800 #[allow(deprecated)]
801 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
802 where
803 D: serde::Deserializer<'de>,
804 {
805 const FIELDS: &[&str] = &[
806 ];
807
808 #[allow(clippy::enum_variant_names)]
809 enum GeneratedField {
810 }
811 impl<'de> serde::Deserialize<'de> for GeneratedField {
812 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
813 where
814 D: serde::Deserializer<'de>,
815 {
816 struct GeneratedVisitor;
817
818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
819 type Value = GeneratedField;
820
821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
822 write!(formatter, "expected one of: {:?}", &FIELDS)
823 }
824
825 #[allow(unused_variables)]
826 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
827 where
828 E: serde::de::Error,
829 {
830 Err(serde::de::Error::unknown_field(value, FIELDS))
831 }
832 }
833 deserializer.deserialize_identifier(GeneratedVisitor)
834 }
835 }
836 struct GeneratedVisitor;
837 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
838 type Value = AddEventLogResponse;
839
840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
841 formatter.write_str("struct meta.AddEventLogResponse")
842 }
843
844 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogResponse, V::Error>
845 where
846 V: serde::de::MapAccess<'de>,
847 {
848 while map_.next_key::<GeneratedField>()?.is_some() {
849 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
850 }
851 Ok(AddEventLogResponse {
852 })
853 }
854 }
855 deserializer.deserialize_struct("meta.AddEventLogResponse", FIELDS, GeneratedVisitor)
856 }
857}
858impl serde::Serialize for AddWorkerNodeRequest {
859 #[allow(deprecated)]
860 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
861 where
862 S: serde::Serializer,
863 {
864 use serde::ser::SerializeStruct;
865 let mut len = 0;
866 if self.worker_type != 0 {
867 len += 1;
868 }
869 if self.host.is_some() {
870 len += 1;
871 }
872 if self.resource.is_some() {
873 len += 1;
874 }
875 if self.property.is_some() {
876 len += 1;
877 }
878 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeRequest", len)?;
879 if self.worker_type != 0 {
880 let v = super::common::WorkerType::try_from(self.worker_type)
881 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
882 struct_ser.serialize_field("workerType", &v)?;
883 }
884 if let Some(v) = self.host.as_ref() {
885 struct_ser.serialize_field("host", v)?;
886 }
887 if let Some(v) = self.resource.as_ref() {
888 struct_ser.serialize_field("resource", v)?;
889 }
890 if let Some(v) = self.property.as_ref() {
891 struct_ser.serialize_field("property", v)?;
892 }
893 struct_ser.end()
894 }
895}
896impl<'de> serde::Deserialize<'de> for AddWorkerNodeRequest {
897 #[allow(deprecated)]
898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
899 where
900 D: serde::Deserializer<'de>,
901 {
902 const FIELDS: &[&str] = &[
903 "worker_type",
904 "workerType",
905 "host",
906 "resource",
907 "property",
908 ];
909
910 #[allow(clippy::enum_variant_names)]
911 enum GeneratedField {
912 WorkerType,
913 Host,
914 Resource,
915 Property,
916 }
917 impl<'de> serde::Deserialize<'de> for GeneratedField {
918 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
919 where
920 D: serde::Deserializer<'de>,
921 {
922 struct GeneratedVisitor;
923
924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
925 type Value = GeneratedField;
926
927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
928 write!(formatter, "expected one of: {:?}", &FIELDS)
929 }
930
931 #[allow(unused_variables)]
932 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
933 where
934 E: serde::de::Error,
935 {
936 match value {
937 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
938 "host" => Ok(GeneratedField::Host),
939 "resource" => Ok(GeneratedField::Resource),
940 "property" => Ok(GeneratedField::Property),
941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
942 }
943 }
944 }
945 deserializer.deserialize_identifier(GeneratedVisitor)
946 }
947 }
948 struct GeneratedVisitor;
949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
950 type Value = AddWorkerNodeRequest;
951
952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
953 formatter.write_str("struct meta.AddWorkerNodeRequest")
954 }
955
956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeRequest, V::Error>
957 where
958 V: serde::de::MapAccess<'de>,
959 {
960 let mut worker_type__ = None;
961 let mut host__ = None;
962 let mut resource__ = None;
963 let mut property__ = None;
964 while let Some(k) = map_.next_key()? {
965 match k {
966 GeneratedField::WorkerType => {
967 if worker_type__.is_some() {
968 return Err(serde::de::Error::duplicate_field("workerType"));
969 }
970 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
971 }
972 GeneratedField::Host => {
973 if host__.is_some() {
974 return Err(serde::de::Error::duplicate_field("host"));
975 }
976 host__ = map_.next_value()?;
977 }
978 GeneratedField::Resource => {
979 if resource__.is_some() {
980 return Err(serde::de::Error::duplicate_field("resource"));
981 }
982 resource__ = map_.next_value()?;
983 }
984 GeneratedField::Property => {
985 if property__.is_some() {
986 return Err(serde::de::Error::duplicate_field("property"));
987 }
988 property__ = map_.next_value()?;
989 }
990 }
991 }
992 Ok(AddWorkerNodeRequest {
993 worker_type: worker_type__.unwrap_or_default(),
994 host: host__,
995 resource: resource__,
996 property: property__,
997 })
998 }
999 }
1000 deserializer.deserialize_struct("meta.AddWorkerNodeRequest", FIELDS, GeneratedVisitor)
1001 }
1002}
1003impl serde::Serialize for AddWorkerNodeResponse {
1004 #[allow(deprecated)]
1005 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1006 where
1007 S: serde::Serializer,
1008 {
1009 use serde::ser::SerializeStruct;
1010 let mut len = 0;
1011 if self.node_id.is_some() {
1012 len += 1;
1013 }
1014 if !self.cluster_id.is_empty() {
1015 len += 1;
1016 }
1017 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeResponse", len)?;
1018 if let Some(v) = self.node_id.as_ref() {
1019 struct_ser.serialize_field("nodeId", v)?;
1020 }
1021 if !self.cluster_id.is_empty() {
1022 struct_ser.serialize_field("clusterId", &self.cluster_id)?;
1023 }
1024 struct_ser.end()
1025 }
1026}
1027impl<'de> serde::Deserialize<'de> for AddWorkerNodeResponse {
1028 #[allow(deprecated)]
1029 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1030 where
1031 D: serde::Deserializer<'de>,
1032 {
1033 const FIELDS: &[&str] = &[
1034 "node_id",
1035 "nodeId",
1036 "cluster_id",
1037 "clusterId",
1038 ];
1039
1040 #[allow(clippy::enum_variant_names)]
1041 enum GeneratedField {
1042 NodeId,
1043 ClusterId,
1044 }
1045 impl<'de> serde::Deserialize<'de> for GeneratedField {
1046 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1047 where
1048 D: serde::Deserializer<'de>,
1049 {
1050 struct GeneratedVisitor;
1051
1052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1053 type Value = GeneratedField;
1054
1055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1056 write!(formatter, "expected one of: {:?}", &FIELDS)
1057 }
1058
1059 #[allow(unused_variables)]
1060 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1061 where
1062 E: serde::de::Error,
1063 {
1064 match value {
1065 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
1066 "clusterId" | "cluster_id" => Ok(GeneratedField::ClusterId),
1067 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1068 }
1069 }
1070 }
1071 deserializer.deserialize_identifier(GeneratedVisitor)
1072 }
1073 }
1074 struct GeneratedVisitor;
1075 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1076 type Value = AddWorkerNodeResponse;
1077
1078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1079 formatter.write_str("struct meta.AddWorkerNodeResponse")
1080 }
1081
1082 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeResponse, V::Error>
1083 where
1084 V: serde::de::MapAccess<'de>,
1085 {
1086 let mut node_id__ = None;
1087 let mut cluster_id__ = None;
1088 while let Some(k) = map_.next_key()? {
1089 match k {
1090 GeneratedField::NodeId => {
1091 if node_id__.is_some() {
1092 return Err(serde::de::Error::duplicate_field("nodeId"));
1093 }
1094 node_id__ =
1095 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1096 ;
1097 }
1098 GeneratedField::ClusterId => {
1099 if cluster_id__.is_some() {
1100 return Err(serde::de::Error::duplicate_field("clusterId"));
1101 }
1102 cluster_id__ = Some(map_.next_value()?);
1103 }
1104 }
1105 }
1106 Ok(AddWorkerNodeResponse {
1107 node_id: node_id__,
1108 cluster_id: cluster_id__.unwrap_or_default(),
1109 })
1110 }
1111 }
1112 deserializer.deserialize_struct("meta.AddWorkerNodeResponse", FIELDS, GeneratedVisitor)
1113 }
1114}
1115impl serde::Serialize for AlterConnectorPropsRequest {
1116 #[allow(deprecated)]
1117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1118 where
1119 S: serde::Serializer,
1120 {
1121 use serde::ser::SerializeStruct;
1122 let mut len = 0;
1123 if self.object_id != 0 {
1124 len += 1;
1125 }
1126 if !self.changed_props.is_empty() {
1127 len += 1;
1128 }
1129 if !self.changed_secret_refs.is_empty() {
1130 len += 1;
1131 }
1132 if self.connector_conn_ref.is_some() {
1133 len += 1;
1134 }
1135 if self.object_type != 0 {
1136 len += 1;
1137 }
1138 if self.extra_options.is_some() {
1139 len += 1;
1140 }
1141 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest", len)?;
1142 if self.object_id != 0 {
1143 struct_ser.serialize_field("objectId", &self.object_id)?;
1144 }
1145 if !self.changed_props.is_empty() {
1146 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1147 }
1148 if !self.changed_secret_refs.is_empty() {
1149 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1150 }
1151 if let Some(v) = self.connector_conn_ref.as_ref() {
1152 struct_ser.serialize_field("connectorConnRef", v)?;
1153 }
1154 if self.object_type != 0 {
1155 let v = alter_connector_props_request::AlterConnectorPropsObject::try_from(self.object_type)
1156 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
1157 struct_ser.serialize_field("objectType", &v)?;
1158 }
1159 if let Some(v) = self.extra_options.as_ref() {
1160 match v {
1161 alter_connector_props_request::ExtraOptions::AlterIcebergTableIds(v) => {
1162 struct_ser.serialize_field("alterIcebergTableIds", v)?;
1163 }
1164 }
1165 }
1166 struct_ser.end()
1167 }
1168}
1169impl<'de> serde::Deserialize<'de> for AlterConnectorPropsRequest {
1170 #[allow(deprecated)]
1171 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1172 where
1173 D: serde::Deserializer<'de>,
1174 {
1175 const FIELDS: &[&str] = &[
1176 "object_id",
1177 "objectId",
1178 "changed_props",
1179 "changedProps",
1180 "changed_secret_refs",
1181 "changedSecretRefs",
1182 "connector_conn_ref",
1183 "connectorConnRef",
1184 "object_type",
1185 "objectType",
1186 "alter_iceberg_table_ids",
1187 "alterIcebergTableIds",
1188 ];
1189
1190 #[allow(clippy::enum_variant_names)]
1191 enum GeneratedField {
1192 ObjectId,
1193 ChangedProps,
1194 ChangedSecretRefs,
1195 ConnectorConnRef,
1196 ObjectType,
1197 AlterIcebergTableIds,
1198 }
1199 impl<'de> serde::Deserialize<'de> for GeneratedField {
1200 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1201 where
1202 D: serde::Deserializer<'de>,
1203 {
1204 struct GeneratedVisitor;
1205
1206 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1207 type Value = GeneratedField;
1208
1209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1210 write!(formatter, "expected one of: {:?}", &FIELDS)
1211 }
1212
1213 #[allow(unused_variables)]
1214 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1215 where
1216 E: serde::de::Error,
1217 {
1218 match value {
1219 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
1220 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1221 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1222 "connectorConnRef" | "connector_conn_ref" => Ok(GeneratedField::ConnectorConnRef),
1223 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
1224 "alterIcebergTableIds" | "alter_iceberg_table_ids" => Ok(GeneratedField::AlterIcebergTableIds),
1225 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1226 }
1227 }
1228 }
1229 deserializer.deserialize_identifier(GeneratedVisitor)
1230 }
1231 }
1232 struct GeneratedVisitor;
1233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1234 type Value = AlterConnectorPropsRequest;
1235
1236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1237 formatter.write_str("struct meta.AlterConnectorPropsRequest")
1238 }
1239
1240 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsRequest, V::Error>
1241 where
1242 V: serde::de::MapAccess<'de>,
1243 {
1244 let mut object_id__ = None;
1245 let mut changed_props__ = None;
1246 let mut changed_secret_refs__ = None;
1247 let mut connector_conn_ref__ = None;
1248 let mut object_type__ = None;
1249 let mut extra_options__ = None;
1250 while let Some(k) = map_.next_key()? {
1251 match k {
1252 GeneratedField::ObjectId => {
1253 if object_id__.is_some() {
1254 return Err(serde::de::Error::duplicate_field("objectId"));
1255 }
1256 object_id__ =
1257 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1258 ;
1259 }
1260 GeneratedField::ChangedProps => {
1261 if changed_props__.is_some() {
1262 return Err(serde::de::Error::duplicate_field("changedProps"));
1263 }
1264 changed_props__ = Some(
1265 map_.next_value::<std::collections::HashMap<_, _>>()?
1266 );
1267 }
1268 GeneratedField::ChangedSecretRefs => {
1269 if changed_secret_refs__.is_some() {
1270 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1271 }
1272 changed_secret_refs__ = Some(
1273 map_.next_value::<std::collections::HashMap<_, _>>()?
1274 );
1275 }
1276 GeneratedField::ConnectorConnRef => {
1277 if connector_conn_ref__.is_some() {
1278 return Err(serde::de::Error::duplicate_field("connectorConnRef"));
1279 }
1280 connector_conn_ref__ =
1281 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1282 ;
1283 }
1284 GeneratedField::ObjectType => {
1285 if object_type__.is_some() {
1286 return Err(serde::de::Error::duplicate_field("objectType"));
1287 }
1288 object_type__ = Some(map_.next_value::<alter_connector_props_request::AlterConnectorPropsObject>()? as i32);
1289 }
1290 GeneratedField::AlterIcebergTableIds => {
1291 if extra_options__.is_some() {
1292 return Err(serde::de::Error::duplicate_field("alterIcebergTableIds"));
1293 }
1294 extra_options__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_connector_props_request::ExtraOptions::AlterIcebergTableIds)
1295;
1296 }
1297 }
1298 }
1299 Ok(AlterConnectorPropsRequest {
1300 object_id: object_id__.unwrap_or_default(),
1301 changed_props: changed_props__.unwrap_or_default(),
1302 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1303 connector_conn_ref: connector_conn_ref__,
1304 object_type: object_type__.unwrap_or_default(),
1305 extra_options: extra_options__,
1306 })
1307 }
1308 }
1309 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest", FIELDS, GeneratedVisitor)
1310 }
1311}
1312impl serde::Serialize for alter_connector_props_request::AlterConnectorPropsObject {
1313 #[allow(deprecated)]
1314 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1315 where
1316 S: serde::Serializer,
1317 {
1318 let variant = match self {
1319 Self::Unspecified => "UNSPECIFIED",
1320 Self::Source => "SOURCE",
1321 Self::Sink => "SINK",
1322 Self::Connection => "CONNECTION",
1323 Self::IcebergTable => "ICEBERG_TABLE",
1324 };
1325 serializer.serialize_str(variant)
1326 }
1327}
1328impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterConnectorPropsObject {
1329 #[allow(deprecated)]
1330 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1331 where
1332 D: serde::Deserializer<'de>,
1333 {
1334 const FIELDS: &[&str] = &[
1335 "UNSPECIFIED",
1336 "SOURCE",
1337 "SINK",
1338 "CONNECTION",
1339 "ICEBERG_TABLE",
1340 ];
1341
1342 struct GeneratedVisitor;
1343
1344 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1345 type Value = alter_connector_props_request::AlterConnectorPropsObject;
1346
1347 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1348 write!(formatter, "expected one of: {:?}", &FIELDS)
1349 }
1350
1351 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1352 where
1353 E: serde::de::Error,
1354 {
1355 i32::try_from(v)
1356 .ok()
1357 .and_then(|x| x.try_into().ok())
1358 .ok_or_else(|| {
1359 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1360 })
1361 }
1362
1363 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1364 where
1365 E: serde::de::Error,
1366 {
1367 i32::try_from(v)
1368 .ok()
1369 .and_then(|x| x.try_into().ok())
1370 .ok_or_else(|| {
1371 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1372 })
1373 }
1374
1375 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1376 where
1377 E: serde::de::Error,
1378 {
1379 match value {
1380 "UNSPECIFIED" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Unspecified),
1381 "SOURCE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Source),
1382 "SINK" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Sink),
1383 "CONNECTION" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Connection),
1384 "ICEBERG_TABLE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::IcebergTable),
1385 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1386 }
1387 }
1388 }
1389 deserializer.deserialize_any(GeneratedVisitor)
1390 }
1391}
1392impl serde::Serialize for alter_connector_props_request::AlterIcebergTableIds {
1393 #[allow(deprecated)]
1394 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1395 where
1396 S: serde::Serializer,
1397 {
1398 use serde::ser::SerializeStruct;
1399 let mut len = 0;
1400 if self.source_id != 0 {
1401 len += 1;
1402 }
1403 if self.sink_id != 0 {
1404 len += 1;
1405 }
1406 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", len)?;
1407 if self.source_id != 0 {
1408 struct_ser.serialize_field("sourceId", &self.source_id)?;
1409 }
1410 if self.sink_id != 0 {
1411 struct_ser.serialize_field("sinkId", &self.sink_id)?;
1412 }
1413 struct_ser.end()
1414 }
1415}
1416impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterIcebergTableIds {
1417 #[allow(deprecated)]
1418 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1419 where
1420 D: serde::Deserializer<'de>,
1421 {
1422 const FIELDS: &[&str] = &[
1423 "source_id",
1424 "sourceId",
1425 "sink_id",
1426 "sinkId",
1427 ];
1428
1429 #[allow(clippy::enum_variant_names)]
1430 enum GeneratedField {
1431 SourceId,
1432 SinkId,
1433 }
1434 impl<'de> serde::Deserialize<'de> for GeneratedField {
1435 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1436 where
1437 D: serde::Deserializer<'de>,
1438 {
1439 struct GeneratedVisitor;
1440
1441 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1442 type Value = GeneratedField;
1443
1444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1445 write!(formatter, "expected one of: {:?}", &FIELDS)
1446 }
1447
1448 #[allow(unused_variables)]
1449 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1450 where
1451 E: serde::de::Error,
1452 {
1453 match value {
1454 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1455 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1456 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1457 }
1458 }
1459 }
1460 deserializer.deserialize_identifier(GeneratedVisitor)
1461 }
1462 }
1463 struct GeneratedVisitor;
1464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1465 type Value = alter_connector_props_request::AlterIcebergTableIds;
1466
1467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1468 formatter.write_str("struct meta.AlterConnectorPropsRequest.AlterIcebergTableIds")
1469 }
1470
1471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_connector_props_request::AlterIcebergTableIds, V::Error>
1472 where
1473 V: serde::de::MapAccess<'de>,
1474 {
1475 let mut source_id__ = None;
1476 let mut sink_id__ = None;
1477 while let Some(k) = map_.next_key()? {
1478 match k {
1479 GeneratedField::SourceId => {
1480 if source_id__.is_some() {
1481 return Err(serde::de::Error::duplicate_field("sourceId"));
1482 }
1483 source_id__ =
1484 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1485 ;
1486 }
1487 GeneratedField::SinkId => {
1488 if sink_id__.is_some() {
1489 return Err(serde::de::Error::duplicate_field("sinkId"));
1490 }
1491 sink_id__ =
1492 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1493 ;
1494 }
1495 }
1496 }
1497 Ok(alter_connector_props_request::AlterIcebergTableIds {
1498 source_id: source_id__.unwrap_or_default(),
1499 sink_id: sink_id__.unwrap_or_default(),
1500 })
1501 }
1502 }
1503 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", FIELDS, GeneratedVisitor)
1504 }
1505}
1506impl serde::Serialize for AlterConnectorPropsResponse {
1507 #[allow(deprecated)]
1508 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1509 where
1510 S: serde::Serializer,
1511 {
1512 use serde::ser::SerializeStruct;
1513 let len = 0;
1514 let struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsResponse", len)?;
1515 struct_ser.end()
1516 }
1517}
1518impl<'de> serde::Deserialize<'de> for AlterConnectorPropsResponse {
1519 #[allow(deprecated)]
1520 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1521 where
1522 D: serde::Deserializer<'de>,
1523 {
1524 const FIELDS: &[&str] = &[
1525 ];
1526
1527 #[allow(clippy::enum_variant_names)]
1528 enum GeneratedField {
1529 }
1530 impl<'de> serde::Deserialize<'de> for GeneratedField {
1531 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1532 where
1533 D: serde::Deserializer<'de>,
1534 {
1535 struct GeneratedVisitor;
1536
1537 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1538 type Value = GeneratedField;
1539
1540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1541 write!(formatter, "expected one of: {:?}", &FIELDS)
1542 }
1543
1544 #[allow(unused_variables)]
1545 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1546 where
1547 E: serde::de::Error,
1548 {
1549 Err(serde::de::Error::unknown_field(value, FIELDS))
1550 }
1551 }
1552 deserializer.deserialize_identifier(GeneratedVisitor)
1553 }
1554 }
1555 struct GeneratedVisitor;
1556 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1557 type Value = AlterConnectorPropsResponse;
1558
1559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1560 formatter.write_str("struct meta.AlterConnectorPropsResponse")
1561 }
1562
1563 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsResponse, V::Error>
1564 where
1565 V: serde::de::MapAccess<'de>,
1566 {
1567 while map_.next_key::<GeneratedField>()?.is_some() {
1568 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1569 }
1570 Ok(AlterConnectorPropsResponse {
1571 })
1572 }
1573 }
1574 deserializer.deserialize_struct("meta.AlterConnectorPropsResponse", FIELDS, GeneratedVisitor)
1575 }
1576}
1577impl serde::Serialize for ApplyThrottleRequest {
1578 #[allow(deprecated)]
1579 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1580 where
1581 S: serde::Serializer,
1582 {
1583 use serde::ser::SerializeStruct;
1584 let mut len = 0;
1585 if self.kind != 0 {
1586 len += 1;
1587 }
1588 if self.id != 0 {
1589 len += 1;
1590 }
1591 if self.rate.is_some() {
1592 len += 1;
1593 }
1594 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1595 if self.kind != 0 {
1596 let v = ThrottleTarget::try_from(self.kind)
1597 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1598 struct_ser.serialize_field("kind", &v)?;
1599 }
1600 if self.id != 0 {
1601 struct_ser.serialize_field("id", &self.id)?;
1602 }
1603 if let Some(v) = self.rate.as_ref() {
1604 struct_ser.serialize_field("rate", v)?;
1605 }
1606 struct_ser.end()
1607 }
1608}
1609impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1610 #[allow(deprecated)]
1611 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1612 where
1613 D: serde::Deserializer<'de>,
1614 {
1615 const FIELDS: &[&str] = &[
1616 "kind",
1617 "id",
1618 "rate",
1619 ];
1620
1621 #[allow(clippy::enum_variant_names)]
1622 enum GeneratedField {
1623 Kind,
1624 Id,
1625 Rate,
1626 }
1627 impl<'de> serde::Deserialize<'de> for GeneratedField {
1628 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1629 where
1630 D: serde::Deserializer<'de>,
1631 {
1632 struct GeneratedVisitor;
1633
1634 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1635 type Value = GeneratedField;
1636
1637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1638 write!(formatter, "expected one of: {:?}", &FIELDS)
1639 }
1640
1641 #[allow(unused_variables)]
1642 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1643 where
1644 E: serde::de::Error,
1645 {
1646 match value {
1647 "kind" => Ok(GeneratedField::Kind),
1648 "id" => Ok(GeneratedField::Id),
1649 "rate" => Ok(GeneratedField::Rate),
1650 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1651 }
1652 }
1653 }
1654 deserializer.deserialize_identifier(GeneratedVisitor)
1655 }
1656 }
1657 struct GeneratedVisitor;
1658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1659 type Value = ApplyThrottleRequest;
1660
1661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1662 formatter.write_str("struct meta.ApplyThrottleRequest")
1663 }
1664
1665 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1666 where
1667 V: serde::de::MapAccess<'de>,
1668 {
1669 let mut kind__ = None;
1670 let mut id__ = None;
1671 let mut rate__ = None;
1672 while let Some(k) = map_.next_key()? {
1673 match k {
1674 GeneratedField::Kind => {
1675 if kind__.is_some() {
1676 return Err(serde::de::Error::duplicate_field("kind"));
1677 }
1678 kind__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1679 }
1680 GeneratedField::Id => {
1681 if id__.is_some() {
1682 return Err(serde::de::Error::duplicate_field("id"));
1683 }
1684 id__ =
1685 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1686 ;
1687 }
1688 GeneratedField::Rate => {
1689 if rate__.is_some() {
1690 return Err(serde::de::Error::duplicate_field("rate"));
1691 }
1692 rate__ =
1693 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1694 ;
1695 }
1696 }
1697 }
1698 Ok(ApplyThrottleRequest {
1699 kind: kind__.unwrap_or_default(),
1700 id: id__.unwrap_or_default(),
1701 rate: rate__,
1702 })
1703 }
1704 }
1705 deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1706 }
1707}
1708impl serde::Serialize for ApplyThrottleResponse {
1709 #[allow(deprecated)]
1710 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1711 where
1712 S: serde::Serializer,
1713 {
1714 use serde::ser::SerializeStruct;
1715 let mut len = 0;
1716 if self.status.is_some() {
1717 len += 1;
1718 }
1719 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1720 if let Some(v) = self.status.as_ref() {
1721 struct_ser.serialize_field("status", v)?;
1722 }
1723 struct_ser.end()
1724 }
1725}
1726impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1727 #[allow(deprecated)]
1728 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1729 where
1730 D: serde::Deserializer<'de>,
1731 {
1732 const FIELDS: &[&str] = &[
1733 "status",
1734 ];
1735
1736 #[allow(clippy::enum_variant_names)]
1737 enum GeneratedField {
1738 Status,
1739 }
1740 impl<'de> serde::Deserialize<'de> for GeneratedField {
1741 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1742 where
1743 D: serde::Deserializer<'de>,
1744 {
1745 struct GeneratedVisitor;
1746
1747 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1748 type Value = GeneratedField;
1749
1750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1751 write!(formatter, "expected one of: {:?}", &FIELDS)
1752 }
1753
1754 #[allow(unused_variables)]
1755 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1756 where
1757 E: serde::de::Error,
1758 {
1759 match value {
1760 "status" => Ok(GeneratedField::Status),
1761 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1762 }
1763 }
1764 }
1765 deserializer.deserialize_identifier(GeneratedVisitor)
1766 }
1767 }
1768 struct GeneratedVisitor;
1769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1770 type Value = ApplyThrottleResponse;
1771
1772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1773 formatter.write_str("struct meta.ApplyThrottleResponse")
1774 }
1775
1776 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
1777 where
1778 V: serde::de::MapAccess<'de>,
1779 {
1780 let mut status__ = None;
1781 while let Some(k) = map_.next_key()? {
1782 match k {
1783 GeneratedField::Status => {
1784 if status__.is_some() {
1785 return Err(serde::de::Error::duplicate_field("status"));
1786 }
1787 status__ = map_.next_value()?;
1788 }
1789 }
1790 }
1791 Ok(ApplyThrottleResponse {
1792 status: status__,
1793 })
1794 }
1795 }
1796 deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
1797 }
1798}
1799impl serde::Serialize for CancelCreatingJobsRequest {
1800 #[allow(deprecated)]
1801 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1802 where
1803 S: serde::Serializer,
1804 {
1805 use serde::ser::SerializeStruct;
1806 let mut len = 0;
1807 if self.jobs.is_some() {
1808 len += 1;
1809 }
1810 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
1811 if let Some(v) = self.jobs.as_ref() {
1812 match v {
1813 cancel_creating_jobs_request::Jobs::Infos(v) => {
1814 struct_ser.serialize_field("infos", v)?;
1815 }
1816 cancel_creating_jobs_request::Jobs::Ids(v) => {
1817 struct_ser.serialize_field("ids", v)?;
1818 }
1819 }
1820 }
1821 struct_ser.end()
1822 }
1823}
1824impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
1825 #[allow(deprecated)]
1826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1827 where
1828 D: serde::Deserializer<'de>,
1829 {
1830 const FIELDS: &[&str] = &[
1831 "infos",
1832 "ids",
1833 ];
1834
1835 #[allow(clippy::enum_variant_names)]
1836 enum GeneratedField {
1837 Infos,
1838 Ids,
1839 }
1840 impl<'de> serde::Deserialize<'de> for GeneratedField {
1841 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1842 where
1843 D: serde::Deserializer<'de>,
1844 {
1845 struct GeneratedVisitor;
1846
1847 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1848 type Value = GeneratedField;
1849
1850 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1851 write!(formatter, "expected one of: {:?}", &FIELDS)
1852 }
1853
1854 #[allow(unused_variables)]
1855 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1856 where
1857 E: serde::de::Error,
1858 {
1859 match value {
1860 "infos" => Ok(GeneratedField::Infos),
1861 "ids" => Ok(GeneratedField::Ids),
1862 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1863 }
1864 }
1865 }
1866 deserializer.deserialize_identifier(GeneratedVisitor)
1867 }
1868 }
1869 struct GeneratedVisitor;
1870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1871 type Value = CancelCreatingJobsRequest;
1872
1873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1874 formatter.write_str("struct meta.CancelCreatingJobsRequest")
1875 }
1876
1877 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
1878 where
1879 V: serde::de::MapAccess<'de>,
1880 {
1881 let mut jobs__ = None;
1882 while let Some(k) = map_.next_key()? {
1883 match k {
1884 GeneratedField::Infos => {
1885 if jobs__.is_some() {
1886 return Err(serde::de::Error::duplicate_field("infos"));
1887 }
1888 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
1889;
1890 }
1891 GeneratedField::Ids => {
1892 if jobs__.is_some() {
1893 return Err(serde::de::Error::duplicate_field("ids"));
1894 }
1895 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
1896;
1897 }
1898 }
1899 }
1900 Ok(CancelCreatingJobsRequest {
1901 jobs: jobs__,
1902 })
1903 }
1904 }
1905 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
1906 }
1907}
1908impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
1909 #[allow(deprecated)]
1910 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1911 where
1912 S: serde::Serializer,
1913 {
1914 use serde::ser::SerializeStruct;
1915 let mut len = 0;
1916 if !self.job_ids.is_empty() {
1917 len += 1;
1918 }
1919 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
1920 if !self.job_ids.is_empty() {
1921 struct_ser.serialize_field("jobIds", &self.job_ids)?;
1922 }
1923 struct_ser.end()
1924 }
1925}
1926impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
1927 #[allow(deprecated)]
1928 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1929 where
1930 D: serde::Deserializer<'de>,
1931 {
1932 const FIELDS: &[&str] = &[
1933 "job_ids",
1934 "jobIds",
1935 ];
1936
1937 #[allow(clippy::enum_variant_names)]
1938 enum GeneratedField {
1939 JobIds,
1940 }
1941 impl<'de> serde::Deserialize<'de> for GeneratedField {
1942 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1943 where
1944 D: serde::Deserializer<'de>,
1945 {
1946 struct GeneratedVisitor;
1947
1948 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1949 type Value = GeneratedField;
1950
1951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1952 write!(formatter, "expected one of: {:?}", &FIELDS)
1953 }
1954
1955 #[allow(unused_variables)]
1956 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1957 where
1958 E: serde::de::Error,
1959 {
1960 match value {
1961 "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
1962 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1963 }
1964 }
1965 }
1966 deserializer.deserialize_identifier(GeneratedVisitor)
1967 }
1968 }
1969 struct GeneratedVisitor;
1970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1971 type Value = cancel_creating_jobs_request::CreatingJobIds;
1972
1973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1974 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
1975 }
1976
1977 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
1978 where
1979 V: serde::de::MapAccess<'de>,
1980 {
1981 let mut job_ids__ = None;
1982 while let Some(k) = map_.next_key()? {
1983 match k {
1984 GeneratedField::JobIds => {
1985 if job_ids__.is_some() {
1986 return Err(serde::de::Error::duplicate_field("jobIds"));
1987 }
1988 job_ids__ =
1989 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1990 .into_iter().map(|x| x.0).collect())
1991 ;
1992 }
1993 }
1994 }
1995 Ok(cancel_creating_jobs_request::CreatingJobIds {
1996 job_ids: job_ids__.unwrap_or_default(),
1997 })
1998 }
1999 }
2000 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
2001 }
2002}
2003impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
2004 #[allow(deprecated)]
2005 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2006 where
2007 S: serde::Serializer,
2008 {
2009 use serde::ser::SerializeStruct;
2010 let mut len = 0;
2011 if self.database_id != 0 {
2012 len += 1;
2013 }
2014 if self.schema_id != 0 {
2015 len += 1;
2016 }
2017 if !self.name.is_empty() {
2018 len += 1;
2019 }
2020 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
2021 if self.database_id != 0 {
2022 struct_ser.serialize_field("databaseId", &self.database_id)?;
2023 }
2024 if self.schema_id != 0 {
2025 struct_ser.serialize_field("schemaId", &self.schema_id)?;
2026 }
2027 if !self.name.is_empty() {
2028 struct_ser.serialize_field("name", &self.name)?;
2029 }
2030 struct_ser.end()
2031 }
2032}
2033impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
2034 #[allow(deprecated)]
2035 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2036 where
2037 D: serde::Deserializer<'de>,
2038 {
2039 const FIELDS: &[&str] = &[
2040 "database_id",
2041 "databaseId",
2042 "schema_id",
2043 "schemaId",
2044 "name",
2045 ];
2046
2047 #[allow(clippy::enum_variant_names)]
2048 enum GeneratedField {
2049 DatabaseId,
2050 SchemaId,
2051 Name,
2052 }
2053 impl<'de> serde::Deserialize<'de> for GeneratedField {
2054 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2055 where
2056 D: serde::Deserializer<'de>,
2057 {
2058 struct GeneratedVisitor;
2059
2060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2061 type Value = GeneratedField;
2062
2063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2064 write!(formatter, "expected one of: {:?}", &FIELDS)
2065 }
2066
2067 #[allow(unused_variables)]
2068 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2069 where
2070 E: serde::de::Error,
2071 {
2072 match value {
2073 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2074 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2075 "name" => Ok(GeneratedField::Name),
2076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2077 }
2078 }
2079 }
2080 deserializer.deserialize_identifier(GeneratedVisitor)
2081 }
2082 }
2083 struct GeneratedVisitor;
2084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2085 type Value = cancel_creating_jobs_request::CreatingJobInfo;
2086
2087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2088 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
2089 }
2090
2091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
2092 where
2093 V: serde::de::MapAccess<'de>,
2094 {
2095 let mut database_id__ = None;
2096 let mut schema_id__ = None;
2097 let mut name__ = None;
2098 while let Some(k) = map_.next_key()? {
2099 match k {
2100 GeneratedField::DatabaseId => {
2101 if database_id__.is_some() {
2102 return Err(serde::de::Error::duplicate_field("databaseId"));
2103 }
2104 database_id__ =
2105 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2106 ;
2107 }
2108 GeneratedField::SchemaId => {
2109 if schema_id__.is_some() {
2110 return Err(serde::de::Error::duplicate_field("schemaId"));
2111 }
2112 schema_id__ =
2113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2114 ;
2115 }
2116 GeneratedField::Name => {
2117 if name__.is_some() {
2118 return Err(serde::de::Error::duplicate_field("name"));
2119 }
2120 name__ = Some(map_.next_value()?);
2121 }
2122 }
2123 }
2124 Ok(cancel_creating_jobs_request::CreatingJobInfo {
2125 database_id: database_id__.unwrap_or_default(),
2126 schema_id: schema_id__.unwrap_or_default(),
2127 name: name__.unwrap_or_default(),
2128 })
2129 }
2130 }
2131 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
2132 }
2133}
2134impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
2135 #[allow(deprecated)]
2136 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2137 where
2138 S: serde::Serializer,
2139 {
2140 use serde::ser::SerializeStruct;
2141 let mut len = 0;
2142 if !self.infos.is_empty() {
2143 len += 1;
2144 }
2145 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
2146 if !self.infos.is_empty() {
2147 struct_ser.serialize_field("infos", &self.infos)?;
2148 }
2149 struct_ser.end()
2150 }
2151}
2152impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
2153 #[allow(deprecated)]
2154 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2155 where
2156 D: serde::Deserializer<'de>,
2157 {
2158 const FIELDS: &[&str] = &[
2159 "infos",
2160 ];
2161
2162 #[allow(clippy::enum_variant_names)]
2163 enum GeneratedField {
2164 Infos,
2165 }
2166 impl<'de> serde::Deserialize<'de> for GeneratedField {
2167 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2168 where
2169 D: serde::Deserializer<'de>,
2170 {
2171 struct GeneratedVisitor;
2172
2173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2174 type Value = GeneratedField;
2175
2176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2177 write!(formatter, "expected one of: {:?}", &FIELDS)
2178 }
2179
2180 #[allow(unused_variables)]
2181 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2182 where
2183 E: serde::de::Error,
2184 {
2185 match value {
2186 "infos" => Ok(GeneratedField::Infos),
2187 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2188 }
2189 }
2190 }
2191 deserializer.deserialize_identifier(GeneratedVisitor)
2192 }
2193 }
2194 struct GeneratedVisitor;
2195 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2196 type Value = cancel_creating_jobs_request::CreatingJobInfos;
2197
2198 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2199 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2200 }
2201
2202 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2203 where
2204 V: serde::de::MapAccess<'de>,
2205 {
2206 let mut infos__ = None;
2207 while let Some(k) = map_.next_key()? {
2208 match k {
2209 GeneratedField::Infos => {
2210 if infos__.is_some() {
2211 return Err(serde::de::Error::duplicate_field("infos"));
2212 }
2213 infos__ = Some(map_.next_value()?);
2214 }
2215 }
2216 }
2217 Ok(cancel_creating_jobs_request::CreatingJobInfos {
2218 infos: infos__.unwrap_or_default(),
2219 })
2220 }
2221 }
2222 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2223 }
2224}
2225impl serde::Serialize for CancelCreatingJobsResponse {
2226 #[allow(deprecated)]
2227 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2228 where
2229 S: serde::Serializer,
2230 {
2231 use serde::ser::SerializeStruct;
2232 let mut len = 0;
2233 if self.status.is_some() {
2234 len += 1;
2235 }
2236 if !self.canceled_jobs.is_empty() {
2237 len += 1;
2238 }
2239 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2240 if let Some(v) = self.status.as_ref() {
2241 struct_ser.serialize_field("status", v)?;
2242 }
2243 if !self.canceled_jobs.is_empty() {
2244 struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2245 }
2246 struct_ser.end()
2247 }
2248}
2249impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2250 #[allow(deprecated)]
2251 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2252 where
2253 D: serde::Deserializer<'de>,
2254 {
2255 const FIELDS: &[&str] = &[
2256 "status",
2257 "canceled_jobs",
2258 "canceledJobs",
2259 ];
2260
2261 #[allow(clippy::enum_variant_names)]
2262 enum GeneratedField {
2263 Status,
2264 CanceledJobs,
2265 }
2266 impl<'de> serde::Deserialize<'de> for GeneratedField {
2267 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2268 where
2269 D: serde::Deserializer<'de>,
2270 {
2271 struct GeneratedVisitor;
2272
2273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2274 type Value = GeneratedField;
2275
2276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2277 write!(formatter, "expected one of: {:?}", &FIELDS)
2278 }
2279
2280 #[allow(unused_variables)]
2281 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2282 where
2283 E: serde::de::Error,
2284 {
2285 match value {
2286 "status" => Ok(GeneratedField::Status),
2287 "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2289 }
2290 }
2291 }
2292 deserializer.deserialize_identifier(GeneratedVisitor)
2293 }
2294 }
2295 struct GeneratedVisitor;
2296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2297 type Value = CancelCreatingJobsResponse;
2298
2299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2300 formatter.write_str("struct meta.CancelCreatingJobsResponse")
2301 }
2302
2303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2304 where
2305 V: serde::de::MapAccess<'de>,
2306 {
2307 let mut status__ = None;
2308 let mut canceled_jobs__ = None;
2309 while let Some(k) = map_.next_key()? {
2310 match k {
2311 GeneratedField::Status => {
2312 if status__.is_some() {
2313 return Err(serde::de::Error::duplicate_field("status"));
2314 }
2315 status__ = map_.next_value()?;
2316 }
2317 GeneratedField::CanceledJobs => {
2318 if canceled_jobs__.is_some() {
2319 return Err(serde::de::Error::duplicate_field("canceledJobs"));
2320 }
2321 canceled_jobs__ =
2322 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2323 .into_iter().map(|x| x.0).collect())
2324 ;
2325 }
2326 }
2327 }
2328 Ok(CancelCreatingJobsResponse {
2329 status: status__,
2330 canceled_jobs: canceled_jobs__.unwrap_or_default(),
2331 })
2332 }
2333 }
2334 deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2335 }
2336}
2337impl serde::Serialize for ClusterLimit {
2338 #[allow(deprecated)]
2339 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2340 where
2341 S: serde::Serializer,
2342 {
2343 use serde::ser::SerializeStruct;
2344 let mut len = 0;
2345 if self.limit.is_some() {
2346 len += 1;
2347 }
2348 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2349 if let Some(v) = self.limit.as_ref() {
2350 match v {
2351 cluster_limit::Limit::ActorCount(v) => {
2352 struct_ser.serialize_field("actorCount", v)?;
2353 }
2354 }
2355 }
2356 struct_ser.end()
2357 }
2358}
2359impl<'de> serde::Deserialize<'de> for ClusterLimit {
2360 #[allow(deprecated)]
2361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2362 where
2363 D: serde::Deserializer<'de>,
2364 {
2365 const FIELDS: &[&str] = &[
2366 "actor_count",
2367 "actorCount",
2368 ];
2369
2370 #[allow(clippy::enum_variant_names)]
2371 enum GeneratedField {
2372 ActorCount,
2373 }
2374 impl<'de> serde::Deserialize<'de> for GeneratedField {
2375 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2376 where
2377 D: serde::Deserializer<'de>,
2378 {
2379 struct GeneratedVisitor;
2380
2381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2382 type Value = GeneratedField;
2383
2384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2385 write!(formatter, "expected one of: {:?}", &FIELDS)
2386 }
2387
2388 #[allow(unused_variables)]
2389 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2390 where
2391 E: serde::de::Error,
2392 {
2393 match value {
2394 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2395 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2396 }
2397 }
2398 }
2399 deserializer.deserialize_identifier(GeneratedVisitor)
2400 }
2401 }
2402 struct GeneratedVisitor;
2403 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2404 type Value = ClusterLimit;
2405
2406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2407 formatter.write_str("struct meta.ClusterLimit")
2408 }
2409
2410 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2411 where
2412 V: serde::de::MapAccess<'de>,
2413 {
2414 let mut limit__ = None;
2415 while let Some(k) = map_.next_key()? {
2416 match k {
2417 GeneratedField::ActorCount => {
2418 if limit__.is_some() {
2419 return Err(serde::de::Error::duplicate_field("actorCount"));
2420 }
2421 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2422;
2423 }
2424 }
2425 }
2426 Ok(ClusterLimit {
2427 limit: limit__,
2428 })
2429 }
2430 }
2431 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2432 }
2433}
2434impl serde::Serialize for DeleteWorkerNodeRequest {
2435 #[allow(deprecated)]
2436 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2437 where
2438 S: serde::Serializer,
2439 {
2440 use serde::ser::SerializeStruct;
2441 let mut len = 0;
2442 if self.host.is_some() {
2443 len += 1;
2444 }
2445 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2446 if let Some(v) = self.host.as_ref() {
2447 struct_ser.serialize_field("host", v)?;
2448 }
2449 struct_ser.end()
2450 }
2451}
2452impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2453 #[allow(deprecated)]
2454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2455 where
2456 D: serde::Deserializer<'de>,
2457 {
2458 const FIELDS: &[&str] = &[
2459 "host",
2460 ];
2461
2462 #[allow(clippy::enum_variant_names)]
2463 enum GeneratedField {
2464 Host,
2465 }
2466 impl<'de> serde::Deserialize<'de> for GeneratedField {
2467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2468 where
2469 D: serde::Deserializer<'de>,
2470 {
2471 struct GeneratedVisitor;
2472
2473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2474 type Value = GeneratedField;
2475
2476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2477 write!(formatter, "expected one of: {:?}", &FIELDS)
2478 }
2479
2480 #[allow(unused_variables)]
2481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2482 where
2483 E: serde::de::Error,
2484 {
2485 match value {
2486 "host" => Ok(GeneratedField::Host),
2487 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2488 }
2489 }
2490 }
2491 deserializer.deserialize_identifier(GeneratedVisitor)
2492 }
2493 }
2494 struct GeneratedVisitor;
2495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2496 type Value = DeleteWorkerNodeRequest;
2497
2498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2499 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2500 }
2501
2502 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2503 where
2504 V: serde::de::MapAccess<'de>,
2505 {
2506 let mut host__ = None;
2507 while let Some(k) = map_.next_key()? {
2508 match k {
2509 GeneratedField::Host => {
2510 if host__.is_some() {
2511 return Err(serde::de::Error::duplicate_field("host"));
2512 }
2513 host__ = map_.next_value()?;
2514 }
2515 }
2516 }
2517 Ok(DeleteWorkerNodeRequest {
2518 host: host__,
2519 })
2520 }
2521 }
2522 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2523 }
2524}
2525impl serde::Serialize for DeleteWorkerNodeResponse {
2526 #[allow(deprecated)]
2527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2528 where
2529 S: serde::Serializer,
2530 {
2531 use serde::ser::SerializeStruct;
2532 let mut len = 0;
2533 if self.status.is_some() {
2534 len += 1;
2535 }
2536 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2537 if let Some(v) = self.status.as_ref() {
2538 struct_ser.serialize_field("status", v)?;
2539 }
2540 struct_ser.end()
2541 }
2542}
2543impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2544 #[allow(deprecated)]
2545 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2546 where
2547 D: serde::Deserializer<'de>,
2548 {
2549 const FIELDS: &[&str] = &[
2550 "status",
2551 ];
2552
2553 #[allow(clippy::enum_variant_names)]
2554 enum GeneratedField {
2555 Status,
2556 }
2557 impl<'de> serde::Deserialize<'de> for GeneratedField {
2558 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2559 where
2560 D: serde::Deserializer<'de>,
2561 {
2562 struct GeneratedVisitor;
2563
2564 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2565 type Value = GeneratedField;
2566
2567 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2568 write!(formatter, "expected one of: {:?}", &FIELDS)
2569 }
2570
2571 #[allow(unused_variables)]
2572 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2573 where
2574 E: serde::de::Error,
2575 {
2576 match value {
2577 "status" => Ok(GeneratedField::Status),
2578 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2579 }
2580 }
2581 }
2582 deserializer.deserialize_identifier(GeneratedVisitor)
2583 }
2584 }
2585 struct GeneratedVisitor;
2586 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2587 type Value = DeleteWorkerNodeResponse;
2588
2589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2590 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2591 }
2592
2593 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2594 where
2595 V: serde::de::MapAccess<'de>,
2596 {
2597 let mut status__ = None;
2598 while let Some(k) = map_.next_key()? {
2599 match k {
2600 GeneratedField::Status => {
2601 if status__.is_some() {
2602 return Err(serde::de::Error::duplicate_field("status"));
2603 }
2604 status__ = map_.next_value()?;
2605 }
2606 }
2607 }
2608 Ok(DeleteWorkerNodeResponse {
2609 status: status__,
2610 })
2611 }
2612 }
2613 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2614 }
2615}
2616impl serde::Serialize for EventLog {
2617 #[allow(deprecated)]
2618 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2619 where
2620 S: serde::Serializer,
2621 {
2622 use serde::ser::SerializeStruct;
2623 let mut len = 0;
2624 if self.unique_id.is_some() {
2625 len += 1;
2626 }
2627 if self.timestamp.is_some() {
2628 len += 1;
2629 }
2630 if self.event.is_some() {
2631 len += 1;
2632 }
2633 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2634 if let Some(v) = self.unique_id.as_ref() {
2635 struct_ser.serialize_field("uniqueId", v)?;
2636 }
2637 if let Some(v) = self.timestamp.as_ref() {
2638 #[allow(clippy::needless_borrow)]
2639 #[allow(clippy::needless_borrows_for_generic_args)]
2640 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2641 }
2642 if let Some(v) = self.event.as_ref() {
2643 match v {
2644 event_log::Event::CreateStreamJobFail(v) => {
2645 struct_ser.serialize_field("createStreamJobFail", v)?;
2646 }
2647 event_log::Event::DirtyStreamJobClear(v) => {
2648 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2649 }
2650 event_log::Event::MetaNodeStart(v) => {
2651 struct_ser.serialize_field("metaNodeStart", v)?;
2652 }
2653 event_log::Event::BarrierComplete(v) => {
2654 struct_ser.serialize_field("barrierComplete", v)?;
2655 }
2656 event_log::Event::InjectBarrierFail(v) => {
2657 struct_ser.serialize_field("injectBarrierFail", v)?;
2658 }
2659 event_log::Event::CollectBarrierFail(v) => {
2660 struct_ser.serialize_field("collectBarrierFail", v)?;
2661 }
2662 event_log::Event::WorkerNodePanic(v) => {
2663 struct_ser.serialize_field("workerNodePanic", v)?;
2664 }
2665 event_log::Event::AutoSchemaChangeFail(v) => {
2666 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2667 }
2668 event_log::Event::SinkFail(v) => {
2669 struct_ser.serialize_field("sinkFail", v)?;
2670 }
2671 event_log::Event::Recovery(v) => {
2672 struct_ser.serialize_field("recovery", v)?;
2673 }
2674 }
2675 }
2676 struct_ser.end()
2677 }
2678}
2679impl<'de> serde::Deserialize<'de> for EventLog {
2680 #[allow(deprecated)]
2681 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2682 where
2683 D: serde::Deserializer<'de>,
2684 {
2685 const FIELDS: &[&str] = &[
2686 "unique_id",
2687 "uniqueId",
2688 "timestamp",
2689 "create_stream_job_fail",
2690 "createStreamJobFail",
2691 "dirty_stream_job_clear",
2692 "dirtyStreamJobClear",
2693 "meta_node_start",
2694 "metaNodeStart",
2695 "barrier_complete",
2696 "barrierComplete",
2697 "inject_barrier_fail",
2698 "injectBarrierFail",
2699 "collect_barrier_fail",
2700 "collectBarrierFail",
2701 "worker_node_panic",
2702 "workerNodePanic",
2703 "auto_schema_change_fail",
2704 "autoSchemaChangeFail",
2705 "sink_fail",
2706 "sinkFail",
2707 "recovery",
2708 ];
2709
2710 #[allow(clippy::enum_variant_names)]
2711 enum GeneratedField {
2712 UniqueId,
2713 Timestamp,
2714 CreateStreamJobFail,
2715 DirtyStreamJobClear,
2716 MetaNodeStart,
2717 BarrierComplete,
2718 InjectBarrierFail,
2719 CollectBarrierFail,
2720 WorkerNodePanic,
2721 AutoSchemaChangeFail,
2722 SinkFail,
2723 Recovery,
2724 }
2725 impl<'de> serde::Deserialize<'de> for GeneratedField {
2726 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2727 where
2728 D: serde::Deserializer<'de>,
2729 {
2730 struct GeneratedVisitor;
2731
2732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2733 type Value = GeneratedField;
2734
2735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2736 write!(formatter, "expected one of: {:?}", &FIELDS)
2737 }
2738
2739 #[allow(unused_variables)]
2740 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2741 where
2742 E: serde::de::Error,
2743 {
2744 match value {
2745 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2746 "timestamp" => Ok(GeneratedField::Timestamp),
2747 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2748 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2749 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2750 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2751 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2752 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2753 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2754 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
2755 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
2756 "recovery" => Ok(GeneratedField::Recovery),
2757 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2758 }
2759 }
2760 }
2761 deserializer.deserialize_identifier(GeneratedVisitor)
2762 }
2763 }
2764 struct GeneratedVisitor;
2765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2766 type Value = EventLog;
2767
2768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2769 formatter.write_str("struct meta.EventLog")
2770 }
2771
2772 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
2773 where
2774 V: serde::de::MapAccess<'de>,
2775 {
2776 let mut unique_id__ = None;
2777 let mut timestamp__ = None;
2778 let mut event__ = None;
2779 while let Some(k) = map_.next_key()? {
2780 match k {
2781 GeneratedField::UniqueId => {
2782 if unique_id__.is_some() {
2783 return Err(serde::de::Error::duplicate_field("uniqueId"));
2784 }
2785 unique_id__ = map_.next_value()?;
2786 }
2787 GeneratedField::Timestamp => {
2788 if timestamp__.is_some() {
2789 return Err(serde::de::Error::duplicate_field("timestamp"));
2790 }
2791 timestamp__ =
2792 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2793 ;
2794 }
2795 GeneratedField::CreateStreamJobFail => {
2796 if event__.is_some() {
2797 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
2798 }
2799 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
2800;
2801 }
2802 GeneratedField::DirtyStreamJobClear => {
2803 if event__.is_some() {
2804 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
2805 }
2806 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
2807;
2808 }
2809 GeneratedField::MetaNodeStart => {
2810 if event__.is_some() {
2811 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
2812 }
2813 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
2814;
2815 }
2816 GeneratedField::BarrierComplete => {
2817 if event__.is_some() {
2818 return Err(serde::de::Error::duplicate_field("barrierComplete"));
2819 }
2820 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
2821;
2822 }
2823 GeneratedField::InjectBarrierFail => {
2824 if event__.is_some() {
2825 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
2826 }
2827 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
2828;
2829 }
2830 GeneratedField::CollectBarrierFail => {
2831 if event__.is_some() {
2832 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
2833 }
2834 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
2835;
2836 }
2837 GeneratedField::WorkerNodePanic => {
2838 if event__.is_some() {
2839 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
2840 }
2841 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
2842;
2843 }
2844 GeneratedField::AutoSchemaChangeFail => {
2845 if event__.is_some() {
2846 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
2847 }
2848 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
2849;
2850 }
2851 GeneratedField::SinkFail => {
2852 if event__.is_some() {
2853 return Err(serde::de::Error::duplicate_field("sinkFail"));
2854 }
2855 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
2856;
2857 }
2858 GeneratedField::Recovery => {
2859 if event__.is_some() {
2860 return Err(serde::de::Error::duplicate_field("recovery"));
2861 }
2862 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
2863;
2864 }
2865 }
2866 }
2867 Ok(EventLog {
2868 unique_id: unique_id__,
2869 timestamp: timestamp__,
2870 event: event__,
2871 })
2872 }
2873 }
2874 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
2875 }
2876}
2877impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
2878 #[allow(deprecated)]
2879 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2880 where
2881 S: serde::Serializer,
2882 {
2883 use serde::ser::SerializeStruct;
2884 let mut len = 0;
2885 if self.table_id != 0 {
2886 len += 1;
2887 }
2888 if !self.table_name.is_empty() {
2889 len += 1;
2890 }
2891 if !self.cdc_table_id.is_empty() {
2892 len += 1;
2893 }
2894 if !self.upstream_ddl.is_empty() {
2895 len += 1;
2896 }
2897 if !self.fail_info.is_empty() {
2898 len += 1;
2899 }
2900 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
2901 if self.table_id != 0 {
2902 struct_ser.serialize_field("tableId", &self.table_id)?;
2903 }
2904 if !self.table_name.is_empty() {
2905 struct_ser.serialize_field("tableName", &self.table_name)?;
2906 }
2907 if !self.cdc_table_id.is_empty() {
2908 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
2909 }
2910 if !self.upstream_ddl.is_empty() {
2911 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
2912 }
2913 if !self.fail_info.is_empty() {
2914 struct_ser.serialize_field("failInfo", &self.fail_info)?;
2915 }
2916 struct_ser.end()
2917 }
2918}
2919impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
2920 #[allow(deprecated)]
2921 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2922 where
2923 D: serde::Deserializer<'de>,
2924 {
2925 const FIELDS: &[&str] = &[
2926 "table_id",
2927 "tableId",
2928 "table_name",
2929 "tableName",
2930 "cdc_table_id",
2931 "cdcTableId",
2932 "upstream_ddl",
2933 "upstreamDdl",
2934 "fail_info",
2935 "failInfo",
2936 ];
2937
2938 #[allow(clippy::enum_variant_names)]
2939 enum GeneratedField {
2940 TableId,
2941 TableName,
2942 CdcTableId,
2943 UpstreamDdl,
2944 FailInfo,
2945 }
2946 impl<'de> serde::Deserialize<'de> for GeneratedField {
2947 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2948 where
2949 D: serde::Deserializer<'de>,
2950 {
2951 struct GeneratedVisitor;
2952
2953 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2954 type Value = GeneratedField;
2955
2956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2957 write!(formatter, "expected one of: {:?}", &FIELDS)
2958 }
2959
2960 #[allow(unused_variables)]
2961 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2962 where
2963 E: serde::de::Error,
2964 {
2965 match value {
2966 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2967 "tableName" | "table_name" => Ok(GeneratedField::TableName),
2968 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
2969 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
2970 "failInfo" | "fail_info" => Ok(GeneratedField::FailInfo),
2971 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2972 }
2973 }
2974 }
2975 deserializer.deserialize_identifier(GeneratedVisitor)
2976 }
2977 }
2978 struct GeneratedVisitor;
2979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2980 type Value = event_log::EventAutoSchemaChangeFail;
2981
2982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2983 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
2984 }
2985
2986 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
2987 where
2988 V: serde::de::MapAccess<'de>,
2989 {
2990 let mut table_id__ = None;
2991 let mut table_name__ = None;
2992 let mut cdc_table_id__ = None;
2993 let mut upstream_ddl__ = None;
2994 let mut fail_info__ = None;
2995 while let Some(k) = map_.next_key()? {
2996 match k {
2997 GeneratedField::TableId => {
2998 if table_id__.is_some() {
2999 return Err(serde::de::Error::duplicate_field("tableId"));
3000 }
3001 table_id__ =
3002 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3003 ;
3004 }
3005 GeneratedField::TableName => {
3006 if table_name__.is_some() {
3007 return Err(serde::de::Error::duplicate_field("tableName"));
3008 }
3009 table_name__ = Some(map_.next_value()?);
3010 }
3011 GeneratedField::CdcTableId => {
3012 if cdc_table_id__.is_some() {
3013 return Err(serde::de::Error::duplicate_field("cdcTableId"));
3014 }
3015 cdc_table_id__ = Some(map_.next_value()?);
3016 }
3017 GeneratedField::UpstreamDdl => {
3018 if upstream_ddl__.is_some() {
3019 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
3020 }
3021 upstream_ddl__ = Some(map_.next_value()?);
3022 }
3023 GeneratedField::FailInfo => {
3024 if fail_info__.is_some() {
3025 return Err(serde::de::Error::duplicate_field("failInfo"));
3026 }
3027 fail_info__ = Some(map_.next_value()?);
3028 }
3029 }
3030 }
3031 Ok(event_log::EventAutoSchemaChangeFail {
3032 table_id: table_id__.unwrap_or_default(),
3033 table_name: table_name__.unwrap_or_default(),
3034 cdc_table_id: cdc_table_id__.unwrap_or_default(),
3035 upstream_ddl: upstream_ddl__.unwrap_or_default(),
3036 fail_info: fail_info__.unwrap_or_default(),
3037 })
3038 }
3039 }
3040 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
3041 }
3042}
3043impl serde::Serialize for event_log::EventBarrierComplete {
3044 #[allow(deprecated)]
3045 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3046 where
3047 S: serde::Serializer,
3048 {
3049 use serde::ser::SerializeStruct;
3050 let mut len = 0;
3051 if self.prev_epoch != 0 {
3052 len += 1;
3053 }
3054 if self.cur_epoch != 0 {
3055 len += 1;
3056 }
3057 if self.duration_sec != 0. {
3058 len += 1;
3059 }
3060 if !self.command.is_empty() {
3061 len += 1;
3062 }
3063 if !self.barrier_kind.is_empty() {
3064 len += 1;
3065 }
3066 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
3067 if self.prev_epoch != 0 {
3068 #[allow(clippy::needless_borrow)]
3069 #[allow(clippy::needless_borrows_for_generic_args)]
3070 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3071 }
3072 if self.cur_epoch != 0 {
3073 #[allow(clippy::needless_borrow)]
3074 #[allow(clippy::needless_borrows_for_generic_args)]
3075 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3076 }
3077 if self.duration_sec != 0. {
3078 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
3079 }
3080 if !self.command.is_empty() {
3081 struct_ser.serialize_field("command", &self.command)?;
3082 }
3083 if !self.barrier_kind.is_empty() {
3084 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
3085 }
3086 struct_ser.end()
3087 }
3088}
3089impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
3090 #[allow(deprecated)]
3091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3092 where
3093 D: serde::Deserializer<'de>,
3094 {
3095 const FIELDS: &[&str] = &[
3096 "prev_epoch",
3097 "prevEpoch",
3098 "cur_epoch",
3099 "curEpoch",
3100 "duration_sec",
3101 "durationSec",
3102 "command",
3103 "barrier_kind",
3104 "barrierKind",
3105 ];
3106
3107 #[allow(clippy::enum_variant_names)]
3108 enum GeneratedField {
3109 PrevEpoch,
3110 CurEpoch,
3111 DurationSec,
3112 Command,
3113 BarrierKind,
3114 }
3115 impl<'de> serde::Deserialize<'de> for GeneratedField {
3116 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3117 where
3118 D: serde::Deserializer<'de>,
3119 {
3120 struct GeneratedVisitor;
3121
3122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3123 type Value = GeneratedField;
3124
3125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3126 write!(formatter, "expected one of: {:?}", &FIELDS)
3127 }
3128
3129 #[allow(unused_variables)]
3130 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3131 where
3132 E: serde::de::Error,
3133 {
3134 match value {
3135 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3136 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3137 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
3138 "command" => Ok(GeneratedField::Command),
3139 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
3140 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3141 }
3142 }
3143 }
3144 deserializer.deserialize_identifier(GeneratedVisitor)
3145 }
3146 }
3147 struct GeneratedVisitor;
3148 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3149 type Value = event_log::EventBarrierComplete;
3150
3151 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3152 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
3153 }
3154
3155 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
3156 where
3157 V: serde::de::MapAccess<'de>,
3158 {
3159 let mut prev_epoch__ = None;
3160 let mut cur_epoch__ = None;
3161 let mut duration_sec__ = None;
3162 let mut command__ = None;
3163 let mut barrier_kind__ = None;
3164 while let Some(k) = map_.next_key()? {
3165 match k {
3166 GeneratedField::PrevEpoch => {
3167 if prev_epoch__.is_some() {
3168 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3169 }
3170 prev_epoch__ =
3171 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3172 ;
3173 }
3174 GeneratedField::CurEpoch => {
3175 if cur_epoch__.is_some() {
3176 return Err(serde::de::Error::duplicate_field("curEpoch"));
3177 }
3178 cur_epoch__ =
3179 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3180 ;
3181 }
3182 GeneratedField::DurationSec => {
3183 if duration_sec__.is_some() {
3184 return Err(serde::de::Error::duplicate_field("durationSec"));
3185 }
3186 duration_sec__ =
3187 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3188 ;
3189 }
3190 GeneratedField::Command => {
3191 if command__.is_some() {
3192 return Err(serde::de::Error::duplicate_field("command"));
3193 }
3194 command__ = Some(map_.next_value()?);
3195 }
3196 GeneratedField::BarrierKind => {
3197 if barrier_kind__.is_some() {
3198 return Err(serde::de::Error::duplicate_field("barrierKind"));
3199 }
3200 barrier_kind__ = Some(map_.next_value()?);
3201 }
3202 }
3203 }
3204 Ok(event_log::EventBarrierComplete {
3205 prev_epoch: prev_epoch__.unwrap_or_default(),
3206 cur_epoch: cur_epoch__.unwrap_or_default(),
3207 duration_sec: duration_sec__.unwrap_or_default(),
3208 command: command__.unwrap_or_default(),
3209 barrier_kind: barrier_kind__.unwrap_or_default(),
3210 })
3211 }
3212 }
3213 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3214 }
3215}
3216impl serde::Serialize for event_log::EventCollectBarrierFail {
3217 #[allow(deprecated)]
3218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3219 where
3220 S: serde::Serializer,
3221 {
3222 use serde::ser::SerializeStruct;
3223 let mut len = 0;
3224 if !self.error.is_empty() {
3225 len += 1;
3226 }
3227 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3228 if !self.error.is_empty() {
3229 struct_ser.serialize_field("error", &self.error)?;
3230 }
3231 struct_ser.end()
3232 }
3233}
3234impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3235 #[allow(deprecated)]
3236 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3237 where
3238 D: serde::Deserializer<'de>,
3239 {
3240 const FIELDS: &[&str] = &[
3241 "error",
3242 ];
3243
3244 #[allow(clippy::enum_variant_names)]
3245 enum GeneratedField {
3246 Error,
3247 }
3248 impl<'de> serde::Deserialize<'de> for GeneratedField {
3249 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3250 where
3251 D: serde::Deserializer<'de>,
3252 {
3253 struct GeneratedVisitor;
3254
3255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3256 type Value = GeneratedField;
3257
3258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3259 write!(formatter, "expected one of: {:?}", &FIELDS)
3260 }
3261
3262 #[allow(unused_variables)]
3263 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3264 where
3265 E: serde::de::Error,
3266 {
3267 match value {
3268 "error" => Ok(GeneratedField::Error),
3269 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3270 }
3271 }
3272 }
3273 deserializer.deserialize_identifier(GeneratedVisitor)
3274 }
3275 }
3276 struct GeneratedVisitor;
3277 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3278 type Value = event_log::EventCollectBarrierFail;
3279
3280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3281 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3282 }
3283
3284 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3285 where
3286 V: serde::de::MapAccess<'de>,
3287 {
3288 let mut error__ = None;
3289 while let Some(k) = map_.next_key()? {
3290 match k {
3291 GeneratedField::Error => {
3292 if error__.is_some() {
3293 return Err(serde::de::Error::duplicate_field("error"));
3294 }
3295 error__ = Some(map_.next_value()?);
3296 }
3297 }
3298 }
3299 Ok(event_log::EventCollectBarrierFail {
3300 error: error__.unwrap_or_default(),
3301 })
3302 }
3303 }
3304 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3305 }
3306}
3307impl serde::Serialize for event_log::EventCreateStreamJobFail {
3308 #[allow(deprecated)]
3309 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3310 where
3311 S: serde::Serializer,
3312 {
3313 use serde::ser::SerializeStruct;
3314 let mut len = 0;
3315 if self.id != 0 {
3316 len += 1;
3317 }
3318 if !self.name.is_empty() {
3319 len += 1;
3320 }
3321 if !self.definition.is_empty() {
3322 len += 1;
3323 }
3324 if !self.error.is_empty() {
3325 len += 1;
3326 }
3327 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3328 if self.id != 0 {
3329 struct_ser.serialize_field("id", &self.id)?;
3330 }
3331 if !self.name.is_empty() {
3332 struct_ser.serialize_field("name", &self.name)?;
3333 }
3334 if !self.definition.is_empty() {
3335 struct_ser.serialize_field("definition", &self.definition)?;
3336 }
3337 if !self.error.is_empty() {
3338 struct_ser.serialize_field("error", &self.error)?;
3339 }
3340 struct_ser.end()
3341 }
3342}
3343impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3344 #[allow(deprecated)]
3345 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3346 where
3347 D: serde::Deserializer<'de>,
3348 {
3349 const FIELDS: &[&str] = &[
3350 "id",
3351 "name",
3352 "definition",
3353 "error",
3354 ];
3355
3356 #[allow(clippy::enum_variant_names)]
3357 enum GeneratedField {
3358 Id,
3359 Name,
3360 Definition,
3361 Error,
3362 }
3363 impl<'de> serde::Deserialize<'de> for GeneratedField {
3364 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3365 where
3366 D: serde::Deserializer<'de>,
3367 {
3368 struct GeneratedVisitor;
3369
3370 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3371 type Value = GeneratedField;
3372
3373 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3374 write!(formatter, "expected one of: {:?}", &FIELDS)
3375 }
3376
3377 #[allow(unused_variables)]
3378 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3379 where
3380 E: serde::de::Error,
3381 {
3382 match value {
3383 "id" => Ok(GeneratedField::Id),
3384 "name" => Ok(GeneratedField::Name),
3385 "definition" => Ok(GeneratedField::Definition),
3386 "error" => Ok(GeneratedField::Error),
3387 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3388 }
3389 }
3390 }
3391 deserializer.deserialize_identifier(GeneratedVisitor)
3392 }
3393 }
3394 struct GeneratedVisitor;
3395 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3396 type Value = event_log::EventCreateStreamJobFail;
3397
3398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3399 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3400 }
3401
3402 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3403 where
3404 V: serde::de::MapAccess<'de>,
3405 {
3406 let mut id__ = None;
3407 let mut name__ = None;
3408 let mut definition__ = None;
3409 let mut error__ = None;
3410 while let Some(k) = map_.next_key()? {
3411 match k {
3412 GeneratedField::Id => {
3413 if id__.is_some() {
3414 return Err(serde::de::Error::duplicate_field("id"));
3415 }
3416 id__ =
3417 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3418 ;
3419 }
3420 GeneratedField::Name => {
3421 if name__.is_some() {
3422 return Err(serde::de::Error::duplicate_field("name"));
3423 }
3424 name__ = Some(map_.next_value()?);
3425 }
3426 GeneratedField::Definition => {
3427 if definition__.is_some() {
3428 return Err(serde::de::Error::duplicate_field("definition"));
3429 }
3430 definition__ = Some(map_.next_value()?);
3431 }
3432 GeneratedField::Error => {
3433 if error__.is_some() {
3434 return Err(serde::de::Error::duplicate_field("error"));
3435 }
3436 error__ = Some(map_.next_value()?);
3437 }
3438 }
3439 }
3440 Ok(event_log::EventCreateStreamJobFail {
3441 id: id__.unwrap_or_default(),
3442 name: name__.unwrap_or_default(),
3443 definition: definition__.unwrap_or_default(),
3444 error: error__.unwrap_or_default(),
3445 })
3446 }
3447 }
3448 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3449 }
3450}
3451impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3452 #[allow(deprecated)]
3453 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3454 where
3455 S: serde::Serializer,
3456 {
3457 use serde::ser::SerializeStruct;
3458 let mut len = 0;
3459 if self.id != 0 {
3460 len += 1;
3461 }
3462 if !self.name.is_empty() {
3463 len += 1;
3464 }
3465 if !self.definition.is_empty() {
3466 len += 1;
3467 }
3468 if !self.error.is_empty() {
3469 len += 1;
3470 }
3471 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3472 if self.id != 0 {
3473 struct_ser.serialize_field("id", &self.id)?;
3474 }
3475 if !self.name.is_empty() {
3476 struct_ser.serialize_field("name", &self.name)?;
3477 }
3478 if !self.definition.is_empty() {
3479 struct_ser.serialize_field("definition", &self.definition)?;
3480 }
3481 if !self.error.is_empty() {
3482 struct_ser.serialize_field("error", &self.error)?;
3483 }
3484 struct_ser.end()
3485 }
3486}
3487impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3488 #[allow(deprecated)]
3489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3490 where
3491 D: serde::Deserializer<'de>,
3492 {
3493 const FIELDS: &[&str] = &[
3494 "id",
3495 "name",
3496 "definition",
3497 "error",
3498 ];
3499
3500 #[allow(clippy::enum_variant_names)]
3501 enum GeneratedField {
3502 Id,
3503 Name,
3504 Definition,
3505 Error,
3506 }
3507 impl<'de> serde::Deserialize<'de> for GeneratedField {
3508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3509 where
3510 D: serde::Deserializer<'de>,
3511 {
3512 struct GeneratedVisitor;
3513
3514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3515 type Value = GeneratedField;
3516
3517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3518 write!(formatter, "expected one of: {:?}", &FIELDS)
3519 }
3520
3521 #[allow(unused_variables)]
3522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3523 where
3524 E: serde::de::Error,
3525 {
3526 match value {
3527 "id" => Ok(GeneratedField::Id),
3528 "name" => Ok(GeneratedField::Name),
3529 "definition" => Ok(GeneratedField::Definition),
3530 "error" => Ok(GeneratedField::Error),
3531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3532 }
3533 }
3534 }
3535 deserializer.deserialize_identifier(GeneratedVisitor)
3536 }
3537 }
3538 struct GeneratedVisitor;
3539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3540 type Value = event_log::EventDirtyStreamJobClear;
3541
3542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3543 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3544 }
3545
3546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3547 where
3548 V: serde::de::MapAccess<'de>,
3549 {
3550 let mut id__ = None;
3551 let mut name__ = None;
3552 let mut definition__ = None;
3553 let mut error__ = None;
3554 while let Some(k) = map_.next_key()? {
3555 match k {
3556 GeneratedField::Id => {
3557 if id__.is_some() {
3558 return Err(serde::de::Error::duplicate_field("id"));
3559 }
3560 id__ =
3561 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3562 ;
3563 }
3564 GeneratedField::Name => {
3565 if name__.is_some() {
3566 return Err(serde::de::Error::duplicate_field("name"));
3567 }
3568 name__ = Some(map_.next_value()?);
3569 }
3570 GeneratedField::Definition => {
3571 if definition__.is_some() {
3572 return Err(serde::de::Error::duplicate_field("definition"));
3573 }
3574 definition__ = Some(map_.next_value()?);
3575 }
3576 GeneratedField::Error => {
3577 if error__.is_some() {
3578 return Err(serde::de::Error::duplicate_field("error"));
3579 }
3580 error__ = Some(map_.next_value()?);
3581 }
3582 }
3583 }
3584 Ok(event_log::EventDirtyStreamJobClear {
3585 id: id__.unwrap_or_default(),
3586 name: name__.unwrap_or_default(),
3587 definition: definition__.unwrap_or_default(),
3588 error: error__.unwrap_or_default(),
3589 })
3590 }
3591 }
3592 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3593 }
3594}
3595impl serde::Serialize for event_log::EventInjectBarrierFail {
3596 #[allow(deprecated)]
3597 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3598 where
3599 S: serde::Serializer,
3600 {
3601 use serde::ser::SerializeStruct;
3602 let mut len = 0;
3603 if self.prev_epoch != 0 {
3604 len += 1;
3605 }
3606 if self.cur_epoch != 0 {
3607 len += 1;
3608 }
3609 if !self.error.is_empty() {
3610 len += 1;
3611 }
3612 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3613 if self.prev_epoch != 0 {
3614 #[allow(clippy::needless_borrow)]
3615 #[allow(clippy::needless_borrows_for_generic_args)]
3616 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3617 }
3618 if self.cur_epoch != 0 {
3619 #[allow(clippy::needless_borrow)]
3620 #[allow(clippy::needless_borrows_for_generic_args)]
3621 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3622 }
3623 if !self.error.is_empty() {
3624 struct_ser.serialize_field("error", &self.error)?;
3625 }
3626 struct_ser.end()
3627 }
3628}
3629impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3630 #[allow(deprecated)]
3631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3632 where
3633 D: serde::Deserializer<'de>,
3634 {
3635 const FIELDS: &[&str] = &[
3636 "prev_epoch",
3637 "prevEpoch",
3638 "cur_epoch",
3639 "curEpoch",
3640 "error",
3641 ];
3642
3643 #[allow(clippy::enum_variant_names)]
3644 enum GeneratedField {
3645 PrevEpoch,
3646 CurEpoch,
3647 Error,
3648 }
3649 impl<'de> serde::Deserialize<'de> for GeneratedField {
3650 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3651 where
3652 D: serde::Deserializer<'de>,
3653 {
3654 struct GeneratedVisitor;
3655
3656 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3657 type Value = GeneratedField;
3658
3659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3660 write!(formatter, "expected one of: {:?}", &FIELDS)
3661 }
3662
3663 #[allow(unused_variables)]
3664 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3665 where
3666 E: serde::de::Error,
3667 {
3668 match value {
3669 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3670 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3671 "error" => Ok(GeneratedField::Error),
3672 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3673 }
3674 }
3675 }
3676 deserializer.deserialize_identifier(GeneratedVisitor)
3677 }
3678 }
3679 struct GeneratedVisitor;
3680 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3681 type Value = event_log::EventInjectBarrierFail;
3682
3683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3684 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3685 }
3686
3687 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3688 where
3689 V: serde::de::MapAccess<'de>,
3690 {
3691 let mut prev_epoch__ = None;
3692 let mut cur_epoch__ = None;
3693 let mut error__ = None;
3694 while let Some(k) = map_.next_key()? {
3695 match k {
3696 GeneratedField::PrevEpoch => {
3697 if prev_epoch__.is_some() {
3698 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3699 }
3700 prev_epoch__ =
3701 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3702 ;
3703 }
3704 GeneratedField::CurEpoch => {
3705 if cur_epoch__.is_some() {
3706 return Err(serde::de::Error::duplicate_field("curEpoch"));
3707 }
3708 cur_epoch__ =
3709 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3710 ;
3711 }
3712 GeneratedField::Error => {
3713 if error__.is_some() {
3714 return Err(serde::de::Error::duplicate_field("error"));
3715 }
3716 error__ = Some(map_.next_value()?);
3717 }
3718 }
3719 }
3720 Ok(event_log::EventInjectBarrierFail {
3721 prev_epoch: prev_epoch__.unwrap_or_default(),
3722 cur_epoch: cur_epoch__.unwrap_or_default(),
3723 error: error__.unwrap_or_default(),
3724 })
3725 }
3726 }
3727 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3728 }
3729}
3730impl serde::Serialize for event_log::EventMetaNodeStart {
3731 #[allow(deprecated)]
3732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3733 where
3734 S: serde::Serializer,
3735 {
3736 use serde::ser::SerializeStruct;
3737 let mut len = 0;
3738 if !self.advertise_addr.is_empty() {
3739 len += 1;
3740 }
3741 if !self.listen_addr.is_empty() {
3742 len += 1;
3743 }
3744 if !self.opts.is_empty() {
3745 len += 1;
3746 }
3747 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
3748 if !self.advertise_addr.is_empty() {
3749 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
3750 }
3751 if !self.listen_addr.is_empty() {
3752 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
3753 }
3754 if !self.opts.is_empty() {
3755 struct_ser.serialize_field("opts", &self.opts)?;
3756 }
3757 struct_ser.end()
3758 }
3759}
3760impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
3761 #[allow(deprecated)]
3762 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3763 where
3764 D: serde::Deserializer<'de>,
3765 {
3766 const FIELDS: &[&str] = &[
3767 "advertise_addr",
3768 "advertiseAddr",
3769 "listen_addr",
3770 "listenAddr",
3771 "opts",
3772 ];
3773
3774 #[allow(clippy::enum_variant_names)]
3775 enum GeneratedField {
3776 AdvertiseAddr,
3777 ListenAddr,
3778 Opts,
3779 }
3780 impl<'de> serde::Deserialize<'de> for GeneratedField {
3781 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3782 where
3783 D: serde::Deserializer<'de>,
3784 {
3785 struct GeneratedVisitor;
3786
3787 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3788 type Value = GeneratedField;
3789
3790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3791 write!(formatter, "expected one of: {:?}", &FIELDS)
3792 }
3793
3794 #[allow(unused_variables)]
3795 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3796 where
3797 E: serde::de::Error,
3798 {
3799 match value {
3800 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
3801 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
3802 "opts" => Ok(GeneratedField::Opts),
3803 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3804 }
3805 }
3806 }
3807 deserializer.deserialize_identifier(GeneratedVisitor)
3808 }
3809 }
3810 struct GeneratedVisitor;
3811 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3812 type Value = event_log::EventMetaNodeStart;
3813
3814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3815 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
3816 }
3817
3818 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
3819 where
3820 V: serde::de::MapAccess<'de>,
3821 {
3822 let mut advertise_addr__ = None;
3823 let mut listen_addr__ = None;
3824 let mut opts__ = None;
3825 while let Some(k) = map_.next_key()? {
3826 match k {
3827 GeneratedField::AdvertiseAddr => {
3828 if advertise_addr__.is_some() {
3829 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
3830 }
3831 advertise_addr__ = Some(map_.next_value()?);
3832 }
3833 GeneratedField::ListenAddr => {
3834 if listen_addr__.is_some() {
3835 return Err(serde::de::Error::duplicate_field("listenAddr"));
3836 }
3837 listen_addr__ = Some(map_.next_value()?);
3838 }
3839 GeneratedField::Opts => {
3840 if opts__.is_some() {
3841 return Err(serde::de::Error::duplicate_field("opts"));
3842 }
3843 opts__ = Some(map_.next_value()?);
3844 }
3845 }
3846 }
3847 Ok(event_log::EventMetaNodeStart {
3848 advertise_addr: advertise_addr__.unwrap_or_default(),
3849 listen_addr: listen_addr__.unwrap_or_default(),
3850 opts: opts__.unwrap_or_default(),
3851 })
3852 }
3853 }
3854 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
3855 }
3856}
3857impl serde::Serialize for event_log::EventRecovery {
3858 #[allow(deprecated)]
3859 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3860 where
3861 S: serde::Serializer,
3862 {
3863 use serde::ser::SerializeStruct;
3864 let mut len = 0;
3865 if self.recovery_event.is_some() {
3866 len += 1;
3867 }
3868 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
3869 if let Some(v) = self.recovery_event.as_ref() {
3870 match v {
3871 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
3872 struct_ser.serialize_field("globalStart", v)?;
3873 }
3874 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
3875 struct_ser.serialize_field("globalSuccess", v)?;
3876 }
3877 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
3878 struct_ser.serialize_field("globalFailure", v)?;
3879 }
3880 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
3881 struct_ser.serialize_field("databaseStart", v)?;
3882 }
3883 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
3884 struct_ser.serialize_field("databaseFailure", v)?;
3885 }
3886 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
3887 struct_ser.serialize_field("databaseSuccess", v)?;
3888 }
3889 }
3890 }
3891 struct_ser.end()
3892 }
3893}
3894impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
3895 #[allow(deprecated)]
3896 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3897 where
3898 D: serde::Deserializer<'de>,
3899 {
3900 const FIELDS: &[&str] = &[
3901 "global_start",
3902 "globalStart",
3903 "global_success",
3904 "globalSuccess",
3905 "global_failure",
3906 "globalFailure",
3907 "database_start",
3908 "databaseStart",
3909 "database_failure",
3910 "databaseFailure",
3911 "database_success",
3912 "databaseSuccess",
3913 ];
3914
3915 #[allow(clippy::enum_variant_names)]
3916 enum GeneratedField {
3917 GlobalStart,
3918 GlobalSuccess,
3919 GlobalFailure,
3920 DatabaseStart,
3921 DatabaseFailure,
3922 DatabaseSuccess,
3923 }
3924 impl<'de> serde::Deserialize<'de> for GeneratedField {
3925 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3926 where
3927 D: serde::Deserializer<'de>,
3928 {
3929 struct GeneratedVisitor;
3930
3931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3932 type Value = GeneratedField;
3933
3934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3935 write!(formatter, "expected one of: {:?}", &FIELDS)
3936 }
3937
3938 #[allow(unused_variables)]
3939 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3940 where
3941 E: serde::de::Error,
3942 {
3943 match value {
3944 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
3945 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
3946 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
3947 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
3948 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
3949 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
3950 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3951 }
3952 }
3953 }
3954 deserializer.deserialize_identifier(GeneratedVisitor)
3955 }
3956 }
3957 struct GeneratedVisitor;
3958 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3959 type Value = event_log::EventRecovery;
3960
3961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3962 formatter.write_str("struct meta.EventLog.EventRecovery")
3963 }
3964
3965 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
3966 where
3967 V: serde::de::MapAccess<'de>,
3968 {
3969 let mut recovery_event__ = None;
3970 while let Some(k) = map_.next_key()? {
3971 match k {
3972 GeneratedField::GlobalStart => {
3973 if recovery_event__.is_some() {
3974 return Err(serde::de::Error::duplicate_field("globalStart"));
3975 }
3976 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
3977;
3978 }
3979 GeneratedField::GlobalSuccess => {
3980 if recovery_event__.is_some() {
3981 return Err(serde::de::Error::duplicate_field("globalSuccess"));
3982 }
3983 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
3984;
3985 }
3986 GeneratedField::GlobalFailure => {
3987 if recovery_event__.is_some() {
3988 return Err(serde::de::Error::duplicate_field("globalFailure"));
3989 }
3990 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
3991;
3992 }
3993 GeneratedField::DatabaseStart => {
3994 if recovery_event__.is_some() {
3995 return Err(serde::de::Error::duplicate_field("databaseStart"));
3996 }
3997 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
3998;
3999 }
4000 GeneratedField::DatabaseFailure => {
4001 if recovery_event__.is_some() {
4002 return Err(serde::de::Error::duplicate_field("databaseFailure"));
4003 }
4004 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
4005;
4006 }
4007 GeneratedField::DatabaseSuccess => {
4008 if recovery_event__.is_some() {
4009 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
4010 }
4011 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
4012;
4013 }
4014 }
4015 }
4016 Ok(event_log::EventRecovery {
4017 recovery_event: recovery_event__,
4018 })
4019 }
4020 }
4021 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
4022 }
4023}
4024impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
4025 #[allow(deprecated)]
4026 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4027 where
4028 S: serde::Serializer,
4029 {
4030 use serde::ser::SerializeStruct;
4031 let mut len = 0;
4032 if self.database_id != 0 {
4033 len += 1;
4034 }
4035 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
4036 if self.database_id != 0 {
4037 struct_ser.serialize_field("databaseId", &self.database_id)?;
4038 }
4039 struct_ser.end()
4040 }
4041}
4042impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
4043 #[allow(deprecated)]
4044 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4045 where
4046 D: serde::Deserializer<'de>,
4047 {
4048 const FIELDS: &[&str] = &[
4049 "database_id",
4050 "databaseId",
4051 ];
4052
4053 #[allow(clippy::enum_variant_names)]
4054 enum GeneratedField {
4055 DatabaseId,
4056 }
4057 impl<'de> serde::Deserialize<'de> for GeneratedField {
4058 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4059 where
4060 D: serde::Deserializer<'de>,
4061 {
4062 struct GeneratedVisitor;
4063
4064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4065 type Value = GeneratedField;
4066
4067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4068 write!(formatter, "expected one of: {:?}", &FIELDS)
4069 }
4070
4071 #[allow(unused_variables)]
4072 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4073 where
4074 E: serde::de::Error,
4075 {
4076 match value {
4077 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4078 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4079 }
4080 }
4081 }
4082 deserializer.deserialize_identifier(GeneratedVisitor)
4083 }
4084 }
4085 struct GeneratedVisitor;
4086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4087 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
4088
4089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4090 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
4091 }
4092
4093 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
4094 where
4095 V: serde::de::MapAccess<'de>,
4096 {
4097 let mut database_id__ = None;
4098 while let Some(k) = map_.next_key()? {
4099 match k {
4100 GeneratedField::DatabaseId => {
4101 if database_id__.is_some() {
4102 return Err(serde::de::Error::duplicate_field("databaseId"));
4103 }
4104 database_id__ =
4105 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4106 ;
4107 }
4108 }
4109 }
4110 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
4111 database_id: database_id__.unwrap_or_default(),
4112 })
4113 }
4114 }
4115 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
4116 }
4117}
4118impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
4119 #[allow(deprecated)]
4120 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4121 where
4122 S: serde::Serializer,
4123 {
4124 use serde::ser::SerializeStruct;
4125 let mut len = 0;
4126 if self.database_id != 0 {
4127 len += 1;
4128 }
4129 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
4130 if self.database_id != 0 {
4131 struct_ser.serialize_field("databaseId", &self.database_id)?;
4132 }
4133 struct_ser.end()
4134 }
4135}
4136impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
4137 #[allow(deprecated)]
4138 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4139 where
4140 D: serde::Deserializer<'de>,
4141 {
4142 const FIELDS: &[&str] = &[
4143 "database_id",
4144 "databaseId",
4145 ];
4146
4147 #[allow(clippy::enum_variant_names)]
4148 enum GeneratedField {
4149 DatabaseId,
4150 }
4151 impl<'de> serde::Deserialize<'de> for GeneratedField {
4152 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4153 where
4154 D: serde::Deserializer<'de>,
4155 {
4156 struct GeneratedVisitor;
4157
4158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4159 type Value = GeneratedField;
4160
4161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4162 write!(formatter, "expected one of: {:?}", &FIELDS)
4163 }
4164
4165 #[allow(unused_variables)]
4166 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4167 where
4168 E: serde::de::Error,
4169 {
4170 match value {
4171 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4172 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4173 }
4174 }
4175 }
4176 deserializer.deserialize_identifier(GeneratedVisitor)
4177 }
4178 }
4179 struct GeneratedVisitor;
4180 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4181 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4182
4183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4184 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4185 }
4186
4187 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4188 where
4189 V: serde::de::MapAccess<'de>,
4190 {
4191 let mut database_id__ = None;
4192 while let Some(k) = map_.next_key()? {
4193 match k {
4194 GeneratedField::DatabaseId => {
4195 if database_id__.is_some() {
4196 return Err(serde::de::Error::duplicate_field("databaseId"));
4197 }
4198 database_id__ =
4199 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4200 ;
4201 }
4202 }
4203 }
4204 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4205 database_id: database_id__.unwrap_or_default(),
4206 })
4207 }
4208 }
4209 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4210 }
4211}
4212impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4213 #[allow(deprecated)]
4214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4215 where
4216 S: serde::Serializer,
4217 {
4218 use serde::ser::SerializeStruct;
4219 let mut len = 0;
4220 if self.database_id != 0 {
4221 len += 1;
4222 }
4223 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4224 if self.database_id != 0 {
4225 struct_ser.serialize_field("databaseId", &self.database_id)?;
4226 }
4227 struct_ser.end()
4228 }
4229}
4230impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4231 #[allow(deprecated)]
4232 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4233 where
4234 D: serde::Deserializer<'de>,
4235 {
4236 const FIELDS: &[&str] = &[
4237 "database_id",
4238 "databaseId",
4239 ];
4240
4241 #[allow(clippy::enum_variant_names)]
4242 enum GeneratedField {
4243 DatabaseId,
4244 }
4245 impl<'de> serde::Deserialize<'de> for GeneratedField {
4246 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4247 where
4248 D: serde::Deserializer<'de>,
4249 {
4250 struct GeneratedVisitor;
4251
4252 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4253 type Value = GeneratedField;
4254
4255 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4256 write!(formatter, "expected one of: {:?}", &FIELDS)
4257 }
4258
4259 #[allow(unused_variables)]
4260 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4261 where
4262 E: serde::de::Error,
4263 {
4264 match value {
4265 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4266 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4267 }
4268 }
4269 }
4270 deserializer.deserialize_identifier(GeneratedVisitor)
4271 }
4272 }
4273 struct GeneratedVisitor;
4274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4275 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4276
4277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4278 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4279 }
4280
4281 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4282 where
4283 V: serde::de::MapAccess<'de>,
4284 {
4285 let mut database_id__ = None;
4286 while let Some(k) = map_.next_key()? {
4287 match k {
4288 GeneratedField::DatabaseId => {
4289 if database_id__.is_some() {
4290 return Err(serde::de::Error::duplicate_field("databaseId"));
4291 }
4292 database_id__ =
4293 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4294 ;
4295 }
4296 }
4297 }
4298 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4299 database_id: database_id__.unwrap_or_default(),
4300 })
4301 }
4302 }
4303 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4304 }
4305}
4306impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4307 #[allow(deprecated)]
4308 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4309 where
4310 S: serde::Serializer,
4311 {
4312 use serde::ser::SerializeStruct;
4313 let mut len = 0;
4314 if !self.reason.is_empty() {
4315 len += 1;
4316 }
4317 if !self.error.is_empty() {
4318 len += 1;
4319 }
4320 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4321 if !self.reason.is_empty() {
4322 struct_ser.serialize_field("reason", &self.reason)?;
4323 }
4324 if !self.error.is_empty() {
4325 struct_ser.serialize_field("error", &self.error)?;
4326 }
4327 struct_ser.end()
4328 }
4329}
4330impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4331 #[allow(deprecated)]
4332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4333 where
4334 D: serde::Deserializer<'de>,
4335 {
4336 const FIELDS: &[&str] = &[
4337 "reason",
4338 "error",
4339 ];
4340
4341 #[allow(clippy::enum_variant_names)]
4342 enum GeneratedField {
4343 Reason,
4344 Error,
4345 }
4346 impl<'de> serde::Deserialize<'de> for GeneratedField {
4347 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4348 where
4349 D: serde::Deserializer<'de>,
4350 {
4351 struct GeneratedVisitor;
4352
4353 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4354 type Value = GeneratedField;
4355
4356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4357 write!(formatter, "expected one of: {:?}", &FIELDS)
4358 }
4359
4360 #[allow(unused_variables)]
4361 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4362 where
4363 E: serde::de::Error,
4364 {
4365 match value {
4366 "reason" => Ok(GeneratedField::Reason),
4367 "error" => Ok(GeneratedField::Error),
4368 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4369 }
4370 }
4371 }
4372 deserializer.deserialize_identifier(GeneratedVisitor)
4373 }
4374 }
4375 struct GeneratedVisitor;
4376 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4377 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4378
4379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4380 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4381 }
4382
4383 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4384 where
4385 V: serde::de::MapAccess<'de>,
4386 {
4387 let mut reason__ = None;
4388 let mut error__ = None;
4389 while let Some(k) = map_.next_key()? {
4390 match k {
4391 GeneratedField::Reason => {
4392 if reason__.is_some() {
4393 return Err(serde::de::Error::duplicate_field("reason"));
4394 }
4395 reason__ = Some(map_.next_value()?);
4396 }
4397 GeneratedField::Error => {
4398 if error__.is_some() {
4399 return Err(serde::de::Error::duplicate_field("error"));
4400 }
4401 error__ = Some(map_.next_value()?);
4402 }
4403 }
4404 }
4405 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4406 reason: reason__.unwrap_or_default(),
4407 error: error__.unwrap_or_default(),
4408 })
4409 }
4410 }
4411 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4412 }
4413}
4414impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4415 #[allow(deprecated)]
4416 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4417 where
4418 S: serde::Serializer,
4419 {
4420 use serde::ser::SerializeStruct;
4421 let mut len = 0;
4422 if !self.reason.is_empty() {
4423 len += 1;
4424 }
4425 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4426 if !self.reason.is_empty() {
4427 struct_ser.serialize_field("reason", &self.reason)?;
4428 }
4429 struct_ser.end()
4430 }
4431}
4432impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4433 #[allow(deprecated)]
4434 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4435 where
4436 D: serde::Deserializer<'de>,
4437 {
4438 const FIELDS: &[&str] = &[
4439 "reason",
4440 ];
4441
4442 #[allow(clippy::enum_variant_names)]
4443 enum GeneratedField {
4444 Reason,
4445 }
4446 impl<'de> serde::Deserialize<'de> for GeneratedField {
4447 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4448 where
4449 D: serde::Deserializer<'de>,
4450 {
4451 struct GeneratedVisitor;
4452
4453 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4454 type Value = GeneratedField;
4455
4456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4457 write!(formatter, "expected one of: {:?}", &FIELDS)
4458 }
4459
4460 #[allow(unused_variables)]
4461 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4462 where
4463 E: serde::de::Error,
4464 {
4465 match value {
4466 "reason" => Ok(GeneratedField::Reason),
4467 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4468 }
4469 }
4470 }
4471 deserializer.deserialize_identifier(GeneratedVisitor)
4472 }
4473 }
4474 struct GeneratedVisitor;
4475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4476 type Value = event_log::event_recovery::GlobalRecoveryStart;
4477
4478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4479 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4480 }
4481
4482 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4483 where
4484 V: serde::de::MapAccess<'de>,
4485 {
4486 let mut reason__ = None;
4487 while let Some(k) = map_.next_key()? {
4488 match k {
4489 GeneratedField::Reason => {
4490 if reason__.is_some() {
4491 return Err(serde::de::Error::duplicate_field("reason"));
4492 }
4493 reason__ = Some(map_.next_value()?);
4494 }
4495 }
4496 }
4497 Ok(event_log::event_recovery::GlobalRecoveryStart {
4498 reason: reason__.unwrap_or_default(),
4499 })
4500 }
4501 }
4502 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4503 }
4504}
4505impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4506 #[allow(deprecated)]
4507 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4508 where
4509 S: serde::Serializer,
4510 {
4511 use serde::ser::SerializeStruct;
4512 let mut len = 0;
4513 if !self.reason.is_empty() {
4514 len += 1;
4515 }
4516 if self.duration_secs != 0. {
4517 len += 1;
4518 }
4519 if !self.running_database_ids.is_empty() {
4520 len += 1;
4521 }
4522 if !self.recovering_database_ids.is_empty() {
4523 len += 1;
4524 }
4525 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4526 if !self.reason.is_empty() {
4527 struct_ser.serialize_field("reason", &self.reason)?;
4528 }
4529 if self.duration_secs != 0. {
4530 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4531 }
4532 if !self.running_database_ids.is_empty() {
4533 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4534 }
4535 if !self.recovering_database_ids.is_empty() {
4536 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4537 }
4538 struct_ser.end()
4539 }
4540}
4541impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4542 #[allow(deprecated)]
4543 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4544 where
4545 D: serde::Deserializer<'de>,
4546 {
4547 const FIELDS: &[&str] = &[
4548 "reason",
4549 "duration_secs",
4550 "durationSecs",
4551 "running_database_ids",
4552 "runningDatabaseIds",
4553 "recovering_database_ids",
4554 "recoveringDatabaseIds",
4555 ];
4556
4557 #[allow(clippy::enum_variant_names)]
4558 enum GeneratedField {
4559 Reason,
4560 DurationSecs,
4561 RunningDatabaseIds,
4562 RecoveringDatabaseIds,
4563 }
4564 impl<'de> serde::Deserialize<'de> for GeneratedField {
4565 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4566 where
4567 D: serde::Deserializer<'de>,
4568 {
4569 struct GeneratedVisitor;
4570
4571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4572 type Value = GeneratedField;
4573
4574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4575 write!(formatter, "expected one of: {:?}", &FIELDS)
4576 }
4577
4578 #[allow(unused_variables)]
4579 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4580 where
4581 E: serde::de::Error,
4582 {
4583 match value {
4584 "reason" => Ok(GeneratedField::Reason),
4585 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4586 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4587 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4588 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4589 }
4590 }
4591 }
4592 deserializer.deserialize_identifier(GeneratedVisitor)
4593 }
4594 }
4595 struct GeneratedVisitor;
4596 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4597 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4598
4599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4600 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4601 }
4602
4603 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4604 where
4605 V: serde::de::MapAccess<'de>,
4606 {
4607 let mut reason__ = None;
4608 let mut duration_secs__ = None;
4609 let mut running_database_ids__ = None;
4610 let mut recovering_database_ids__ = None;
4611 while let Some(k) = map_.next_key()? {
4612 match k {
4613 GeneratedField::Reason => {
4614 if reason__.is_some() {
4615 return Err(serde::de::Error::duplicate_field("reason"));
4616 }
4617 reason__ = Some(map_.next_value()?);
4618 }
4619 GeneratedField::DurationSecs => {
4620 if duration_secs__.is_some() {
4621 return Err(serde::de::Error::duplicate_field("durationSecs"));
4622 }
4623 duration_secs__ =
4624 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4625 ;
4626 }
4627 GeneratedField::RunningDatabaseIds => {
4628 if running_database_ids__.is_some() {
4629 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4630 }
4631 running_database_ids__ =
4632 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4633 .into_iter().map(|x| x.0).collect())
4634 ;
4635 }
4636 GeneratedField::RecoveringDatabaseIds => {
4637 if recovering_database_ids__.is_some() {
4638 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4639 }
4640 recovering_database_ids__ =
4641 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4642 .into_iter().map(|x| x.0).collect())
4643 ;
4644 }
4645 }
4646 }
4647 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4648 reason: reason__.unwrap_or_default(),
4649 duration_secs: duration_secs__.unwrap_or_default(),
4650 running_database_ids: running_database_ids__.unwrap_or_default(),
4651 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4652 })
4653 }
4654 }
4655 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4656 }
4657}
4658impl serde::Serialize for event_log::EventSinkFail {
4659 #[allow(deprecated)]
4660 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4661 where
4662 S: serde::Serializer,
4663 {
4664 use serde::ser::SerializeStruct;
4665 let mut len = 0;
4666 if self.sink_id != 0 {
4667 len += 1;
4668 }
4669 if !self.sink_name.is_empty() {
4670 len += 1;
4671 }
4672 if !self.connector.is_empty() {
4673 len += 1;
4674 }
4675 if !self.error.is_empty() {
4676 len += 1;
4677 }
4678 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4679 if self.sink_id != 0 {
4680 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4681 }
4682 if !self.sink_name.is_empty() {
4683 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4684 }
4685 if !self.connector.is_empty() {
4686 struct_ser.serialize_field("connector", &self.connector)?;
4687 }
4688 if !self.error.is_empty() {
4689 struct_ser.serialize_field("error", &self.error)?;
4690 }
4691 struct_ser.end()
4692 }
4693}
4694impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4695 #[allow(deprecated)]
4696 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4697 where
4698 D: serde::Deserializer<'de>,
4699 {
4700 const FIELDS: &[&str] = &[
4701 "sink_id",
4702 "sinkId",
4703 "sink_name",
4704 "sinkName",
4705 "connector",
4706 "error",
4707 ];
4708
4709 #[allow(clippy::enum_variant_names)]
4710 enum GeneratedField {
4711 SinkId,
4712 SinkName,
4713 Connector,
4714 Error,
4715 }
4716 impl<'de> serde::Deserialize<'de> for GeneratedField {
4717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4718 where
4719 D: serde::Deserializer<'de>,
4720 {
4721 struct GeneratedVisitor;
4722
4723 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4724 type Value = GeneratedField;
4725
4726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4727 write!(formatter, "expected one of: {:?}", &FIELDS)
4728 }
4729
4730 #[allow(unused_variables)]
4731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4732 where
4733 E: serde::de::Error,
4734 {
4735 match value {
4736 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4737 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
4738 "connector" => Ok(GeneratedField::Connector),
4739 "error" => Ok(GeneratedField::Error),
4740 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4741 }
4742 }
4743 }
4744 deserializer.deserialize_identifier(GeneratedVisitor)
4745 }
4746 }
4747 struct GeneratedVisitor;
4748 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4749 type Value = event_log::EventSinkFail;
4750
4751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4752 formatter.write_str("struct meta.EventLog.EventSinkFail")
4753 }
4754
4755 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
4756 where
4757 V: serde::de::MapAccess<'de>,
4758 {
4759 let mut sink_id__ = None;
4760 let mut sink_name__ = None;
4761 let mut connector__ = None;
4762 let mut error__ = None;
4763 while let Some(k) = map_.next_key()? {
4764 match k {
4765 GeneratedField::SinkId => {
4766 if sink_id__.is_some() {
4767 return Err(serde::de::Error::duplicate_field("sinkId"));
4768 }
4769 sink_id__ =
4770 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4771 ;
4772 }
4773 GeneratedField::SinkName => {
4774 if sink_name__.is_some() {
4775 return Err(serde::de::Error::duplicate_field("sinkName"));
4776 }
4777 sink_name__ = Some(map_.next_value()?);
4778 }
4779 GeneratedField::Connector => {
4780 if connector__.is_some() {
4781 return Err(serde::de::Error::duplicate_field("connector"));
4782 }
4783 connector__ = Some(map_.next_value()?);
4784 }
4785 GeneratedField::Error => {
4786 if error__.is_some() {
4787 return Err(serde::de::Error::duplicate_field("error"));
4788 }
4789 error__ = Some(map_.next_value()?);
4790 }
4791 }
4792 }
4793 Ok(event_log::EventSinkFail {
4794 sink_id: sink_id__.unwrap_or_default(),
4795 sink_name: sink_name__.unwrap_or_default(),
4796 connector: connector__.unwrap_or_default(),
4797 error: error__.unwrap_or_default(),
4798 })
4799 }
4800 }
4801 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
4802 }
4803}
4804impl serde::Serialize for event_log::EventWorkerNodePanic {
4805 #[allow(deprecated)]
4806 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4807 where
4808 S: serde::Serializer,
4809 {
4810 use serde::ser::SerializeStruct;
4811 let mut len = 0;
4812 if self.worker_id != 0 {
4813 len += 1;
4814 }
4815 if self.worker_type != 0 {
4816 len += 1;
4817 }
4818 if self.host_addr.is_some() {
4819 len += 1;
4820 }
4821 if !self.panic_info.is_empty() {
4822 len += 1;
4823 }
4824 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
4825 if self.worker_id != 0 {
4826 struct_ser.serialize_field("workerId", &self.worker_id)?;
4827 }
4828 if self.worker_type != 0 {
4829 let v = super::common::WorkerType::try_from(self.worker_type)
4830 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
4831 struct_ser.serialize_field("workerType", &v)?;
4832 }
4833 if let Some(v) = self.host_addr.as_ref() {
4834 struct_ser.serialize_field("hostAddr", v)?;
4835 }
4836 if !self.panic_info.is_empty() {
4837 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
4838 }
4839 struct_ser.end()
4840 }
4841}
4842impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
4843 #[allow(deprecated)]
4844 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4845 where
4846 D: serde::Deserializer<'de>,
4847 {
4848 const FIELDS: &[&str] = &[
4849 "worker_id",
4850 "workerId",
4851 "worker_type",
4852 "workerType",
4853 "host_addr",
4854 "hostAddr",
4855 "panic_info",
4856 "panicInfo",
4857 ];
4858
4859 #[allow(clippy::enum_variant_names)]
4860 enum GeneratedField {
4861 WorkerId,
4862 WorkerType,
4863 HostAddr,
4864 PanicInfo,
4865 }
4866 impl<'de> serde::Deserialize<'de> for GeneratedField {
4867 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4868 where
4869 D: serde::Deserializer<'de>,
4870 {
4871 struct GeneratedVisitor;
4872
4873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4874 type Value = GeneratedField;
4875
4876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4877 write!(formatter, "expected one of: {:?}", &FIELDS)
4878 }
4879
4880 #[allow(unused_variables)]
4881 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4882 where
4883 E: serde::de::Error,
4884 {
4885 match value {
4886 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
4887 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
4888 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
4889 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
4890 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4891 }
4892 }
4893 }
4894 deserializer.deserialize_identifier(GeneratedVisitor)
4895 }
4896 }
4897 struct GeneratedVisitor;
4898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4899 type Value = event_log::EventWorkerNodePanic;
4900
4901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4902 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
4903 }
4904
4905 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
4906 where
4907 V: serde::de::MapAccess<'de>,
4908 {
4909 let mut worker_id__ = None;
4910 let mut worker_type__ = None;
4911 let mut host_addr__ = None;
4912 let mut panic_info__ = None;
4913 while let Some(k) = map_.next_key()? {
4914 match k {
4915 GeneratedField::WorkerId => {
4916 if worker_id__.is_some() {
4917 return Err(serde::de::Error::duplicate_field("workerId"));
4918 }
4919 worker_id__ =
4920 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4921 ;
4922 }
4923 GeneratedField::WorkerType => {
4924 if worker_type__.is_some() {
4925 return Err(serde::de::Error::duplicate_field("workerType"));
4926 }
4927 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
4928 }
4929 GeneratedField::HostAddr => {
4930 if host_addr__.is_some() {
4931 return Err(serde::de::Error::duplicate_field("hostAddr"));
4932 }
4933 host_addr__ = map_.next_value()?;
4934 }
4935 GeneratedField::PanicInfo => {
4936 if panic_info__.is_some() {
4937 return Err(serde::de::Error::duplicate_field("panicInfo"));
4938 }
4939 panic_info__ = Some(map_.next_value()?);
4940 }
4941 }
4942 }
4943 Ok(event_log::EventWorkerNodePanic {
4944 worker_id: worker_id__.unwrap_or_default(),
4945 worker_type: worker_type__.unwrap_or_default(),
4946 host_addr: host_addr__,
4947 panic_info: panic_info__.unwrap_or_default(),
4948 })
4949 }
4950 }
4951 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
4952 }
4953}
4954impl serde::Serialize for FlushRequest {
4955 #[allow(deprecated)]
4956 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4957 where
4958 S: serde::Serializer,
4959 {
4960 use serde::ser::SerializeStruct;
4961 let mut len = 0;
4962 if self.database_id != 0 {
4963 len += 1;
4964 }
4965 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
4966 if self.database_id != 0 {
4967 struct_ser.serialize_field("databaseId", &self.database_id)?;
4968 }
4969 struct_ser.end()
4970 }
4971}
4972impl<'de> serde::Deserialize<'de> for FlushRequest {
4973 #[allow(deprecated)]
4974 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4975 where
4976 D: serde::Deserializer<'de>,
4977 {
4978 const FIELDS: &[&str] = &[
4979 "database_id",
4980 "databaseId",
4981 ];
4982
4983 #[allow(clippy::enum_variant_names)]
4984 enum GeneratedField {
4985 DatabaseId,
4986 }
4987 impl<'de> serde::Deserialize<'de> for GeneratedField {
4988 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4989 where
4990 D: serde::Deserializer<'de>,
4991 {
4992 struct GeneratedVisitor;
4993
4994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4995 type Value = GeneratedField;
4996
4997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4998 write!(formatter, "expected one of: {:?}", &FIELDS)
4999 }
5000
5001 #[allow(unused_variables)]
5002 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5003 where
5004 E: serde::de::Error,
5005 {
5006 match value {
5007 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5008 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5009 }
5010 }
5011 }
5012 deserializer.deserialize_identifier(GeneratedVisitor)
5013 }
5014 }
5015 struct GeneratedVisitor;
5016 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5017 type Value = FlushRequest;
5018
5019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5020 formatter.write_str("struct meta.FlushRequest")
5021 }
5022
5023 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
5024 where
5025 V: serde::de::MapAccess<'de>,
5026 {
5027 let mut database_id__ = None;
5028 while let Some(k) = map_.next_key()? {
5029 match k {
5030 GeneratedField::DatabaseId => {
5031 if database_id__.is_some() {
5032 return Err(serde::de::Error::duplicate_field("databaseId"));
5033 }
5034 database_id__ =
5035 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5036 ;
5037 }
5038 }
5039 }
5040 Ok(FlushRequest {
5041 database_id: database_id__.unwrap_or_default(),
5042 })
5043 }
5044 }
5045 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
5046 }
5047}
5048impl serde::Serialize for FlushResponse {
5049 #[allow(deprecated)]
5050 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5051 where
5052 S: serde::Serializer,
5053 {
5054 use serde::ser::SerializeStruct;
5055 let mut len = 0;
5056 if self.status.is_some() {
5057 len += 1;
5058 }
5059 if self.hummock_version_id != 0 {
5060 len += 1;
5061 }
5062 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
5063 if let Some(v) = self.status.as_ref() {
5064 struct_ser.serialize_field("status", v)?;
5065 }
5066 if self.hummock_version_id != 0 {
5067 #[allow(clippy::needless_borrow)]
5068 #[allow(clippy::needless_borrows_for_generic_args)]
5069 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
5070 }
5071 struct_ser.end()
5072 }
5073}
5074impl<'de> serde::Deserialize<'de> for FlushResponse {
5075 #[allow(deprecated)]
5076 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5077 where
5078 D: serde::Deserializer<'de>,
5079 {
5080 const FIELDS: &[&str] = &[
5081 "status",
5082 "hummock_version_id",
5083 "hummockVersionId",
5084 ];
5085
5086 #[allow(clippy::enum_variant_names)]
5087 enum GeneratedField {
5088 Status,
5089 HummockVersionId,
5090 }
5091 impl<'de> serde::Deserialize<'de> for GeneratedField {
5092 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5093 where
5094 D: serde::Deserializer<'de>,
5095 {
5096 struct GeneratedVisitor;
5097
5098 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5099 type Value = GeneratedField;
5100
5101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5102 write!(formatter, "expected one of: {:?}", &FIELDS)
5103 }
5104
5105 #[allow(unused_variables)]
5106 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5107 where
5108 E: serde::de::Error,
5109 {
5110 match value {
5111 "status" => Ok(GeneratedField::Status),
5112 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
5113 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5114 }
5115 }
5116 }
5117 deserializer.deserialize_identifier(GeneratedVisitor)
5118 }
5119 }
5120 struct GeneratedVisitor;
5121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5122 type Value = FlushResponse;
5123
5124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5125 formatter.write_str("struct meta.FlushResponse")
5126 }
5127
5128 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
5129 where
5130 V: serde::de::MapAccess<'de>,
5131 {
5132 let mut status__ = None;
5133 let mut hummock_version_id__ = None;
5134 while let Some(k) = map_.next_key()? {
5135 match k {
5136 GeneratedField::Status => {
5137 if status__.is_some() {
5138 return Err(serde::de::Error::duplicate_field("status"));
5139 }
5140 status__ = map_.next_value()?;
5141 }
5142 GeneratedField::HummockVersionId => {
5143 if hummock_version_id__.is_some() {
5144 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
5145 }
5146 hummock_version_id__ =
5147 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5148 ;
5149 }
5150 }
5151 }
5152 Ok(FlushResponse {
5153 status: status__,
5154 hummock_version_id: hummock_version_id__.unwrap_or_default(),
5155 })
5156 }
5157 }
5158 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
5159 }
5160}
5161impl serde::Serialize for FragmentDistribution {
5162 #[allow(deprecated)]
5163 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5164 where
5165 S: serde::Serializer,
5166 {
5167 use serde::ser::SerializeStruct;
5168 let mut len = 0;
5169 if self.fragment_id != 0 {
5170 len += 1;
5171 }
5172 if self.table_id != 0 {
5173 len += 1;
5174 }
5175 if self.distribution_type != 0 {
5176 len += 1;
5177 }
5178 if !self.state_table_ids.is_empty() {
5179 len += 1;
5180 }
5181 if !self.upstream_fragment_ids.is_empty() {
5182 len += 1;
5183 }
5184 if self.fragment_type_mask != 0 {
5185 len += 1;
5186 }
5187 if self.parallelism != 0 {
5188 len += 1;
5189 }
5190 if self.vnode_count != 0 {
5191 len += 1;
5192 }
5193 if self.node.is_some() {
5194 len += 1;
5195 }
5196 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5197 if self.fragment_id != 0 {
5198 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5199 }
5200 if self.table_id != 0 {
5201 struct_ser.serialize_field("tableId", &self.table_id)?;
5202 }
5203 if self.distribution_type != 0 {
5204 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5205 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5206 struct_ser.serialize_field("distributionType", &v)?;
5207 }
5208 if !self.state_table_ids.is_empty() {
5209 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5210 }
5211 if !self.upstream_fragment_ids.is_empty() {
5212 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5213 }
5214 if self.fragment_type_mask != 0 {
5215 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5216 }
5217 if self.parallelism != 0 {
5218 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5219 }
5220 if self.vnode_count != 0 {
5221 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5222 }
5223 if let Some(v) = self.node.as_ref() {
5224 struct_ser.serialize_field("node", v)?;
5225 }
5226 struct_ser.end()
5227 }
5228}
5229impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5230 #[allow(deprecated)]
5231 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5232 where
5233 D: serde::Deserializer<'de>,
5234 {
5235 const FIELDS: &[&str] = &[
5236 "fragment_id",
5237 "fragmentId",
5238 "table_id",
5239 "tableId",
5240 "distribution_type",
5241 "distributionType",
5242 "state_table_ids",
5243 "stateTableIds",
5244 "upstream_fragment_ids",
5245 "upstreamFragmentIds",
5246 "fragment_type_mask",
5247 "fragmentTypeMask",
5248 "parallelism",
5249 "vnode_count",
5250 "vnodeCount",
5251 "node",
5252 ];
5253
5254 #[allow(clippy::enum_variant_names)]
5255 enum GeneratedField {
5256 FragmentId,
5257 TableId,
5258 DistributionType,
5259 StateTableIds,
5260 UpstreamFragmentIds,
5261 FragmentTypeMask,
5262 Parallelism,
5263 VnodeCount,
5264 Node,
5265 }
5266 impl<'de> serde::Deserialize<'de> for GeneratedField {
5267 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5268 where
5269 D: serde::Deserializer<'de>,
5270 {
5271 struct GeneratedVisitor;
5272
5273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5274 type Value = GeneratedField;
5275
5276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5277 write!(formatter, "expected one of: {:?}", &FIELDS)
5278 }
5279
5280 #[allow(unused_variables)]
5281 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5282 where
5283 E: serde::de::Error,
5284 {
5285 match value {
5286 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5287 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5288 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5289 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5290 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5291 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5292 "parallelism" => Ok(GeneratedField::Parallelism),
5293 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5294 "node" => Ok(GeneratedField::Node),
5295 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5296 }
5297 }
5298 }
5299 deserializer.deserialize_identifier(GeneratedVisitor)
5300 }
5301 }
5302 struct GeneratedVisitor;
5303 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5304 type Value = FragmentDistribution;
5305
5306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5307 formatter.write_str("struct meta.FragmentDistribution")
5308 }
5309
5310 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5311 where
5312 V: serde::de::MapAccess<'de>,
5313 {
5314 let mut fragment_id__ = None;
5315 let mut table_id__ = None;
5316 let mut distribution_type__ = None;
5317 let mut state_table_ids__ = None;
5318 let mut upstream_fragment_ids__ = None;
5319 let mut fragment_type_mask__ = None;
5320 let mut parallelism__ = None;
5321 let mut vnode_count__ = None;
5322 let mut node__ = None;
5323 while let Some(k) = map_.next_key()? {
5324 match k {
5325 GeneratedField::FragmentId => {
5326 if fragment_id__.is_some() {
5327 return Err(serde::de::Error::duplicate_field("fragmentId"));
5328 }
5329 fragment_id__ =
5330 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5331 ;
5332 }
5333 GeneratedField::TableId => {
5334 if table_id__.is_some() {
5335 return Err(serde::de::Error::duplicate_field("tableId"));
5336 }
5337 table_id__ =
5338 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5339 ;
5340 }
5341 GeneratedField::DistributionType => {
5342 if distribution_type__.is_some() {
5343 return Err(serde::de::Error::duplicate_field("distributionType"));
5344 }
5345 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5346 }
5347 GeneratedField::StateTableIds => {
5348 if state_table_ids__.is_some() {
5349 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5350 }
5351 state_table_ids__ =
5352 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5353 .into_iter().map(|x| x.0).collect())
5354 ;
5355 }
5356 GeneratedField::UpstreamFragmentIds => {
5357 if upstream_fragment_ids__.is_some() {
5358 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5359 }
5360 upstream_fragment_ids__ =
5361 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5362 .into_iter().map(|x| x.0).collect())
5363 ;
5364 }
5365 GeneratedField::FragmentTypeMask => {
5366 if fragment_type_mask__.is_some() {
5367 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5368 }
5369 fragment_type_mask__ =
5370 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5371 ;
5372 }
5373 GeneratedField::Parallelism => {
5374 if parallelism__.is_some() {
5375 return Err(serde::de::Error::duplicate_field("parallelism"));
5376 }
5377 parallelism__ =
5378 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5379 ;
5380 }
5381 GeneratedField::VnodeCount => {
5382 if vnode_count__.is_some() {
5383 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5384 }
5385 vnode_count__ =
5386 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5387 ;
5388 }
5389 GeneratedField::Node => {
5390 if node__.is_some() {
5391 return Err(serde::de::Error::duplicate_field("node"));
5392 }
5393 node__ = map_.next_value()?;
5394 }
5395 }
5396 }
5397 Ok(FragmentDistribution {
5398 fragment_id: fragment_id__.unwrap_or_default(),
5399 table_id: table_id__.unwrap_or_default(),
5400 distribution_type: distribution_type__.unwrap_or_default(),
5401 state_table_ids: state_table_ids__.unwrap_or_default(),
5402 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5403 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5404 parallelism: parallelism__.unwrap_or_default(),
5405 vnode_count: vnode_count__.unwrap_or_default(),
5406 node: node__,
5407 })
5408 }
5409 }
5410 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5411 }
5412}
5413impl serde::Serialize for FragmentIdToActorIdMap {
5414 #[allow(deprecated)]
5415 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5416 where
5417 S: serde::Serializer,
5418 {
5419 use serde::ser::SerializeStruct;
5420 let mut len = 0;
5421 if !self.map.is_empty() {
5422 len += 1;
5423 }
5424 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5425 if !self.map.is_empty() {
5426 struct_ser.serialize_field("map", &self.map)?;
5427 }
5428 struct_ser.end()
5429 }
5430}
5431impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5432 #[allow(deprecated)]
5433 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5434 where
5435 D: serde::Deserializer<'de>,
5436 {
5437 const FIELDS: &[&str] = &[
5438 "map",
5439 ];
5440
5441 #[allow(clippy::enum_variant_names)]
5442 enum GeneratedField {
5443 Map,
5444 }
5445 impl<'de> serde::Deserialize<'de> for GeneratedField {
5446 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5447 where
5448 D: serde::Deserializer<'de>,
5449 {
5450 struct GeneratedVisitor;
5451
5452 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5453 type Value = GeneratedField;
5454
5455 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5456 write!(formatter, "expected one of: {:?}", &FIELDS)
5457 }
5458
5459 #[allow(unused_variables)]
5460 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5461 where
5462 E: serde::de::Error,
5463 {
5464 match value {
5465 "map" => Ok(GeneratedField::Map),
5466 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5467 }
5468 }
5469 }
5470 deserializer.deserialize_identifier(GeneratedVisitor)
5471 }
5472 }
5473 struct GeneratedVisitor;
5474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5475 type Value = FragmentIdToActorIdMap;
5476
5477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5478 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5479 }
5480
5481 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5482 where
5483 V: serde::de::MapAccess<'de>,
5484 {
5485 let mut map__ = None;
5486 while let Some(k) = map_.next_key()? {
5487 match k {
5488 GeneratedField::Map => {
5489 if map__.is_some() {
5490 return Err(serde::de::Error::duplicate_field("map"));
5491 }
5492 map__ = Some(
5493 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5494 .into_iter().map(|(k,v)| (k.0, v)).collect()
5495 );
5496 }
5497 }
5498 }
5499 Ok(FragmentIdToActorIdMap {
5500 map: map__.unwrap_or_default(),
5501 })
5502 }
5503 }
5504 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5505 }
5506}
5507impl serde::Serialize for FragmentToRelationMap {
5508 #[allow(deprecated)]
5509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5510 where
5511 S: serde::Serializer,
5512 {
5513 use serde::ser::SerializeStruct;
5514 let mut len = 0;
5515 if !self.fragment_to_relation_map.is_empty() {
5516 len += 1;
5517 }
5518 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5519 if !self.fragment_to_relation_map.is_empty() {
5520 struct_ser.serialize_field("fragmentToRelationMap", &self.fragment_to_relation_map)?;
5521 }
5522 struct_ser.end()
5523 }
5524}
5525impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5526 #[allow(deprecated)]
5527 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5528 where
5529 D: serde::Deserializer<'de>,
5530 {
5531 const FIELDS: &[&str] = &[
5532 "fragment_to_relation_map",
5533 "fragmentToRelationMap",
5534 ];
5535
5536 #[allow(clippy::enum_variant_names)]
5537 enum GeneratedField {
5538 FragmentToRelationMap,
5539 }
5540 impl<'de> serde::Deserialize<'de> for GeneratedField {
5541 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5542 where
5543 D: serde::Deserializer<'de>,
5544 {
5545 struct GeneratedVisitor;
5546
5547 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5548 type Value = GeneratedField;
5549
5550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5551 write!(formatter, "expected one of: {:?}", &FIELDS)
5552 }
5553
5554 #[allow(unused_variables)]
5555 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5556 where
5557 E: serde::de::Error,
5558 {
5559 match value {
5560 "fragmentToRelationMap" | "fragment_to_relation_map" => Ok(GeneratedField::FragmentToRelationMap),
5561 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5562 }
5563 }
5564 }
5565 deserializer.deserialize_identifier(GeneratedVisitor)
5566 }
5567 }
5568 struct GeneratedVisitor;
5569 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5570 type Value = FragmentToRelationMap;
5571
5572 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5573 formatter.write_str("struct meta.FragmentToRelationMap")
5574 }
5575
5576 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5577 where
5578 V: serde::de::MapAccess<'de>,
5579 {
5580 let mut fragment_to_relation_map__ = None;
5581 while let Some(k) = map_.next_key()? {
5582 match k {
5583 GeneratedField::FragmentToRelationMap => {
5584 if fragment_to_relation_map__.is_some() {
5585 return Err(serde::de::Error::duplicate_field("fragmentToRelationMap"));
5586 }
5587 fragment_to_relation_map__ = Some(
5588 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5589 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
5590 );
5591 }
5592 }
5593 }
5594 Ok(FragmentToRelationMap {
5595 fragment_to_relation_map: fragment_to_relation_map__.unwrap_or_default(),
5596 })
5597 }
5598 }
5599 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5600 }
5601}
5602impl serde::Serialize for FragmentWorkerSlotMapping {
5603 #[allow(deprecated)]
5604 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5605 where
5606 S: serde::Serializer,
5607 {
5608 use serde::ser::SerializeStruct;
5609 let mut len = 0;
5610 if self.fragment_id != 0 {
5611 len += 1;
5612 }
5613 if self.mapping.is_some() {
5614 len += 1;
5615 }
5616 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5617 if self.fragment_id != 0 {
5618 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5619 }
5620 if let Some(v) = self.mapping.as_ref() {
5621 struct_ser.serialize_field("mapping", v)?;
5622 }
5623 struct_ser.end()
5624 }
5625}
5626impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5627 #[allow(deprecated)]
5628 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5629 where
5630 D: serde::Deserializer<'de>,
5631 {
5632 const FIELDS: &[&str] = &[
5633 "fragment_id",
5634 "fragmentId",
5635 "mapping",
5636 ];
5637
5638 #[allow(clippy::enum_variant_names)]
5639 enum GeneratedField {
5640 FragmentId,
5641 Mapping,
5642 }
5643 impl<'de> serde::Deserialize<'de> for GeneratedField {
5644 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5645 where
5646 D: serde::Deserializer<'de>,
5647 {
5648 struct GeneratedVisitor;
5649
5650 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5651 type Value = GeneratedField;
5652
5653 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5654 write!(formatter, "expected one of: {:?}", &FIELDS)
5655 }
5656
5657 #[allow(unused_variables)]
5658 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5659 where
5660 E: serde::de::Error,
5661 {
5662 match value {
5663 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5664 "mapping" => Ok(GeneratedField::Mapping),
5665 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5666 }
5667 }
5668 }
5669 deserializer.deserialize_identifier(GeneratedVisitor)
5670 }
5671 }
5672 struct GeneratedVisitor;
5673 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5674 type Value = FragmentWorkerSlotMapping;
5675
5676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5677 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5678 }
5679
5680 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5681 where
5682 V: serde::de::MapAccess<'de>,
5683 {
5684 let mut fragment_id__ = None;
5685 let mut mapping__ = None;
5686 while let Some(k) = map_.next_key()? {
5687 match k {
5688 GeneratedField::FragmentId => {
5689 if fragment_id__.is_some() {
5690 return Err(serde::de::Error::duplicate_field("fragmentId"));
5691 }
5692 fragment_id__ =
5693 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5694 ;
5695 }
5696 GeneratedField::Mapping => {
5697 if mapping__.is_some() {
5698 return Err(serde::de::Error::duplicate_field("mapping"));
5699 }
5700 mapping__ = map_.next_value()?;
5701 }
5702 }
5703 }
5704 Ok(FragmentWorkerSlotMapping {
5705 fragment_id: fragment_id__.unwrap_or_default(),
5706 mapping: mapping__,
5707 })
5708 }
5709 }
5710 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5711 }
5712}
5713impl serde::Serialize for FragmentWorkerSlotMappings {
5714 #[allow(deprecated)]
5715 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5716 where
5717 S: serde::Serializer,
5718 {
5719 use serde::ser::SerializeStruct;
5720 let mut len = 0;
5721 if !self.mappings.is_empty() {
5722 len += 1;
5723 }
5724 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
5725 if !self.mappings.is_empty() {
5726 struct_ser.serialize_field("mappings", &self.mappings)?;
5727 }
5728 struct_ser.end()
5729 }
5730}
5731impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
5732 #[allow(deprecated)]
5733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5734 where
5735 D: serde::Deserializer<'de>,
5736 {
5737 const FIELDS: &[&str] = &[
5738 "mappings",
5739 ];
5740
5741 #[allow(clippy::enum_variant_names)]
5742 enum GeneratedField {
5743 Mappings,
5744 }
5745 impl<'de> serde::Deserialize<'de> for GeneratedField {
5746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5747 where
5748 D: serde::Deserializer<'de>,
5749 {
5750 struct GeneratedVisitor;
5751
5752 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5753 type Value = GeneratedField;
5754
5755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5756 write!(formatter, "expected one of: {:?}", &FIELDS)
5757 }
5758
5759 #[allow(unused_variables)]
5760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5761 where
5762 E: serde::de::Error,
5763 {
5764 match value {
5765 "mappings" => Ok(GeneratedField::Mappings),
5766 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5767 }
5768 }
5769 }
5770 deserializer.deserialize_identifier(GeneratedVisitor)
5771 }
5772 }
5773 struct GeneratedVisitor;
5774 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5775 type Value = FragmentWorkerSlotMappings;
5776
5777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5778 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
5779 }
5780
5781 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
5782 where
5783 V: serde::de::MapAccess<'de>,
5784 {
5785 let mut mappings__ = None;
5786 while let Some(k) = map_.next_key()? {
5787 match k {
5788 GeneratedField::Mappings => {
5789 if mappings__.is_some() {
5790 return Err(serde::de::Error::duplicate_field("mappings"));
5791 }
5792 mappings__ = Some(map_.next_value()?);
5793 }
5794 }
5795 }
5796 Ok(FragmentWorkerSlotMappings {
5797 mappings: mappings__.unwrap_or_default(),
5798 })
5799 }
5800 }
5801 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
5802 }
5803}
5804impl serde::Serialize for GetClusterInfoRequest {
5805 #[allow(deprecated)]
5806 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5807 where
5808 S: serde::Serializer,
5809 {
5810 use serde::ser::SerializeStruct;
5811 let len = 0;
5812 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
5813 struct_ser.end()
5814 }
5815}
5816impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
5817 #[allow(deprecated)]
5818 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5819 where
5820 D: serde::Deserializer<'de>,
5821 {
5822 const FIELDS: &[&str] = &[
5823 ];
5824
5825 #[allow(clippy::enum_variant_names)]
5826 enum GeneratedField {
5827 }
5828 impl<'de> serde::Deserialize<'de> for GeneratedField {
5829 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5830 where
5831 D: serde::Deserializer<'de>,
5832 {
5833 struct GeneratedVisitor;
5834
5835 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5836 type Value = GeneratedField;
5837
5838 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5839 write!(formatter, "expected one of: {:?}", &FIELDS)
5840 }
5841
5842 #[allow(unused_variables)]
5843 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5844 where
5845 E: serde::de::Error,
5846 {
5847 Err(serde::de::Error::unknown_field(value, FIELDS))
5848 }
5849 }
5850 deserializer.deserialize_identifier(GeneratedVisitor)
5851 }
5852 }
5853 struct GeneratedVisitor;
5854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5855 type Value = GetClusterInfoRequest;
5856
5857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5858 formatter.write_str("struct meta.GetClusterInfoRequest")
5859 }
5860
5861 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
5862 where
5863 V: serde::de::MapAccess<'de>,
5864 {
5865 while map_.next_key::<GeneratedField>()?.is_some() {
5866 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5867 }
5868 Ok(GetClusterInfoRequest {
5869 })
5870 }
5871 }
5872 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
5873 }
5874}
5875impl serde::Serialize for GetClusterInfoResponse {
5876 #[allow(deprecated)]
5877 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5878 where
5879 S: serde::Serializer,
5880 {
5881 use serde::ser::SerializeStruct;
5882 let mut len = 0;
5883 if !self.worker_nodes.is_empty() {
5884 len += 1;
5885 }
5886 if !self.table_fragments.is_empty() {
5887 len += 1;
5888 }
5889 if !self.actor_splits.is_empty() {
5890 len += 1;
5891 }
5892 if !self.source_infos.is_empty() {
5893 len += 1;
5894 }
5895 if self.revision != 0 {
5896 len += 1;
5897 }
5898 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
5899 if !self.worker_nodes.is_empty() {
5900 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
5901 }
5902 if !self.table_fragments.is_empty() {
5903 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
5904 }
5905 if !self.actor_splits.is_empty() {
5906 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
5907 }
5908 if !self.source_infos.is_empty() {
5909 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
5910 }
5911 if self.revision != 0 {
5912 #[allow(clippy::needless_borrow)]
5913 #[allow(clippy::needless_borrows_for_generic_args)]
5914 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
5915 }
5916 struct_ser.end()
5917 }
5918}
5919impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
5920 #[allow(deprecated)]
5921 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5922 where
5923 D: serde::Deserializer<'de>,
5924 {
5925 const FIELDS: &[&str] = &[
5926 "worker_nodes",
5927 "workerNodes",
5928 "table_fragments",
5929 "tableFragments",
5930 "actor_splits",
5931 "actorSplits",
5932 "source_infos",
5933 "sourceInfos",
5934 "revision",
5935 ];
5936
5937 #[allow(clippy::enum_variant_names)]
5938 enum GeneratedField {
5939 WorkerNodes,
5940 TableFragments,
5941 ActorSplits,
5942 SourceInfos,
5943 Revision,
5944 }
5945 impl<'de> serde::Deserialize<'de> for GeneratedField {
5946 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5947 where
5948 D: serde::Deserializer<'de>,
5949 {
5950 struct GeneratedVisitor;
5951
5952 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5953 type Value = GeneratedField;
5954
5955 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5956 write!(formatter, "expected one of: {:?}", &FIELDS)
5957 }
5958
5959 #[allow(unused_variables)]
5960 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5961 where
5962 E: serde::de::Error,
5963 {
5964 match value {
5965 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
5966 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
5967 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
5968 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
5969 "revision" => Ok(GeneratedField::Revision),
5970 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5971 }
5972 }
5973 }
5974 deserializer.deserialize_identifier(GeneratedVisitor)
5975 }
5976 }
5977 struct GeneratedVisitor;
5978 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5979 type Value = GetClusterInfoResponse;
5980
5981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5982 formatter.write_str("struct meta.GetClusterInfoResponse")
5983 }
5984
5985 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
5986 where
5987 V: serde::de::MapAccess<'de>,
5988 {
5989 let mut worker_nodes__ = None;
5990 let mut table_fragments__ = None;
5991 let mut actor_splits__ = None;
5992 let mut source_infos__ = None;
5993 let mut revision__ = None;
5994 while let Some(k) = map_.next_key()? {
5995 match k {
5996 GeneratedField::WorkerNodes => {
5997 if worker_nodes__.is_some() {
5998 return Err(serde::de::Error::duplicate_field("workerNodes"));
5999 }
6000 worker_nodes__ = Some(map_.next_value()?);
6001 }
6002 GeneratedField::TableFragments => {
6003 if table_fragments__.is_some() {
6004 return Err(serde::de::Error::duplicate_field("tableFragments"));
6005 }
6006 table_fragments__ = Some(map_.next_value()?);
6007 }
6008 GeneratedField::ActorSplits => {
6009 if actor_splits__.is_some() {
6010 return Err(serde::de::Error::duplicate_field("actorSplits"));
6011 }
6012 actor_splits__ = Some(
6013 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6014 .into_iter().map(|(k,v)| (k.0, v)).collect()
6015 );
6016 }
6017 GeneratedField::SourceInfos => {
6018 if source_infos__.is_some() {
6019 return Err(serde::de::Error::duplicate_field("sourceInfos"));
6020 }
6021 source_infos__ = Some(
6022 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6023 .into_iter().map(|(k,v)| (k.0, v)).collect()
6024 );
6025 }
6026 GeneratedField::Revision => {
6027 if revision__.is_some() {
6028 return Err(serde::de::Error::duplicate_field("revision"));
6029 }
6030 revision__ =
6031 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6032 ;
6033 }
6034 }
6035 }
6036 Ok(GetClusterInfoResponse {
6037 worker_nodes: worker_nodes__.unwrap_or_default(),
6038 table_fragments: table_fragments__.unwrap_or_default(),
6039 actor_splits: actor_splits__.unwrap_or_default(),
6040 source_infos: source_infos__.unwrap_or_default(),
6041 revision: revision__.unwrap_or_default(),
6042 })
6043 }
6044 }
6045 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
6046 }
6047}
6048impl serde::Serialize for GetClusterLimitsRequest {
6049 #[allow(deprecated)]
6050 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6051 where
6052 S: serde::Serializer,
6053 {
6054 use serde::ser::SerializeStruct;
6055 let len = 0;
6056 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
6057 struct_ser.end()
6058 }
6059}
6060impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
6061 #[allow(deprecated)]
6062 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6063 where
6064 D: serde::Deserializer<'de>,
6065 {
6066 const FIELDS: &[&str] = &[
6067 ];
6068
6069 #[allow(clippy::enum_variant_names)]
6070 enum GeneratedField {
6071 }
6072 impl<'de> serde::Deserialize<'de> for GeneratedField {
6073 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6074 where
6075 D: serde::Deserializer<'de>,
6076 {
6077 struct GeneratedVisitor;
6078
6079 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6080 type Value = GeneratedField;
6081
6082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6083 write!(formatter, "expected one of: {:?}", &FIELDS)
6084 }
6085
6086 #[allow(unused_variables)]
6087 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6088 where
6089 E: serde::de::Error,
6090 {
6091 Err(serde::de::Error::unknown_field(value, FIELDS))
6092 }
6093 }
6094 deserializer.deserialize_identifier(GeneratedVisitor)
6095 }
6096 }
6097 struct GeneratedVisitor;
6098 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6099 type Value = GetClusterLimitsRequest;
6100
6101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6102 formatter.write_str("struct meta.GetClusterLimitsRequest")
6103 }
6104
6105 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
6106 where
6107 V: serde::de::MapAccess<'de>,
6108 {
6109 while map_.next_key::<GeneratedField>()?.is_some() {
6110 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6111 }
6112 Ok(GetClusterLimitsRequest {
6113 })
6114 }
6115 }
6116 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
6117 }
6118}
6119impl serde::Serialize for GetClusterLimitsResponse {
6120 #[allow(deprecated)]
6121 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6122 where
6123 S: serde::Serializer,
6124 {
6125 use serde::ser::SerializeStruct;
6126 let mut len = 0;
6127 if !self.active_limits.is_empty() {
6128 len += 1;
6129 }
6130 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
6131 if !self.active_limits.is_empty() {
6132 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
6133 }
6134 struct_ser.end()
6135 }
6136}
6137impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
6138 #[allow(deprecated)]
6139 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6140 where
6141 D: serde::Deserializer<'de>,
6142 {
6143 const FIELDS: &[&str] = &[
6144 "active_limits",
6145 "activeLimits",
6146 ];
6147
6148 #[allow(clippy::enum_variant_names)]
6149 enum GeneratedField {
6150 ActiveLimits,
6151 }
6152 impl<'de> serde::Deserialize<'de> for GeneratedField {
6153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6154 where
6155 D: serde::Deserializer<'de>,
6156 {
6157 struct GeneratedVisitor;
6158
6159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6160 type Value = GeneratedField;
6161
6162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6163 write!(formatter, "expected one of: {:?}", &FIELDS)
6164 }
6165
6166 #[allow(unused_variables)]
6167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6168 where
6169 E: serde::de::Error,
6170 {
6171 match value {
6172 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6173 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6174 }
6175 }
6176 }
6177 deserializer.deserialize_identifier(GeneratedVisitor)
6178 }
6179 }
6180 struct GeneratedVisitor;
6181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6182 type Value = GetClusterLimitsResponse;
6183
6184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6185 formatter.write_str("struct meta.GetClusterLimitsResponse")
6186 }
6187
6188 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6189 where
6190 V: serde::de::MapAccess<'de>,
6191 {
6192 let mut active_limits__ = None;
6193 while let Some(k) = map_.next_key()? {
6194 match k {
6195 GeneratedField::ActiveLimits => {
6196 if active_limits__.is_some() {
6197 return Err(serde::de::Error::duplicate_field("activeLimits"));
6198 }
6199 active_limits__ = Some(map_.next_value()?);
6200 }
6201 }
6202 }
6203 Ok(GetClusterLimitsResponse {
6204 active_limits: active_limits__.unwrap_or_default(),
6205 })
6206 }
6207 }
6208 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6209 }
6210}
6211impl serde::Serialize for GetClusterRecoveryStatusRequest {
6212 #[allow(deprecated)]
6213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6214 where
6215 S: serde::Serializer,
6216 {
6217 use serde::ser::SerializeStruct;
6218 let len = 0;
6219 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6220 struct_ser.end()
6221 }
6222}
6223impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6224 #[allow(deprecated)]
6225 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6226 where
6227 D: serde::Deserializer<'de>,
6228 {
6229 const FIELDS: &[&str] = &[
6230 ];
6231
6232 #[allow(clippy::enum_variant_names)]
6233 enum GeneratedField {
6234 }
6235 impl<'de> serde::Deserialize<'de> for GeneratedField {
6236 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6237 where
6238 D: serde::Deserializer<'de>,
6239 {
6240 struct GeneratedVisitor;
6241
6242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6243 type Value = GeneratedField;
6244
6245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6246 write!(formatter, "expected one of: {:?}", &FIELDS)
6247 }
6248
6249 #[allow(unused_variables)]
6250 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6251 where
6252 E: serde::de::Error,
6253 {
6254 Err(serde::de::Error::unknown_field(value, FIELDS))
6255 }
6256 }
6257 deserializer.deserialize_identifier(GeneratedVisitor)
6258 }
6259 }
6260 struct GeneratedVisitor;
6261 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6262 type Value = GetClusterRecoveryStatusRequest;
6263
6264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6265 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6266 }
6267
6268 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6269 where
6270 V: serde::de::MapAccess<'de>,
6271 {
6272 while map_.next_key::<GeneratedField>()?.is_some() {
6273 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6274 }
6275 Ok(GetClusterRecoveryStatusRequest {
6276 })
6277 }
6278 }
6279 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6280 }
6281}
6282impl serde::Serialize for GetClusterRecoveryStatusResponse {
6283 #[allow(deprecated)]
6284 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6285 where
6286 S: serde::Serializer,
6287 {
6288 use serde::ser::SerializeStruct;
6289 let mut len = 0;
6290 if self.status != 0 {
6291 len += 1;
6292 }
6293 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6294 if self.status != 0 {
6295 let v = RecoveryStatus::try_from(self.status)
6296 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6297 struct_ser.serialize_field("status", &v)?;
6298 }
6299 struct_ser.end()
6300 }
6301}
6302impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6303 #[allow(deprecated)]
6304 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6305 where
6306 D: serde::Deserializer<'de>,
6307 {
6308 const FIELDS: &[&str] = &[
6309 "status",
6310 ];
6311
6312 #[allow(clippy::enum_variant_names)]
6313 enum GeneratedField {
6314 Status,
6315 }
6316 impl<'de> serde::Deserialize<'de> for GeneratedField {
6317 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6318 where
6319 D: serde::Deserializer<'de>,
6320 {
6321 struct GeneratedVisitor;
6322
6323 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6324 type Value = GeneratedField;
6325
6326 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6327 write!(formatter, "expected one of: {:?}", &FIELDS)
6328 }
6329
6330 #[allow(unused_variables)]
6331 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6332 where
6333 E: serde::de::Error,
6334 {
6335 match value {
6336 "status" => Ok(GeneratedField::Status),
6337 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6338 }
6339 }
6340 }
6341 deserializer.deserialize_identifier(GeneratedVisitor)
6342 }
6343 }
6344 struct GeneratedVisitor;
6345 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6346 type Value = GetClusterRecoveryStatusResponse;
6347
6348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6349 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6350 }
6351
6352 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6353 where
6354 V: serde::de::MapAccess<'de>,
6355 {
6356 let mut status__ = None;
6357 while let Some(k) = map_.next_key()? {
6358 match k {
6359 GeneratedField::Status => {
6360 if status__.is_some() {
6361 return Err(serde::de::Error::duplicate_field("status"));
6362 }
6363 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6364 }
6365 }
6366 }
6367 Ok(GetClusterRecoveryStatusResponse {
6368 status: status__.unwrap_or_default(),
6369 })
6370 }
6371 }
6372 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6373 }
6374}
6375impl serde::Serialize for GetFragmentByIdRequest {
6376 #[allow(deprecated)]
6377 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6378 where
6379 S: serde::Serializer,
6380 {
6381 use serde::ser::SerializeStruct;
6382 let mut len = 0;
6383 if self.fragment_id != 0 {
6384 len += 1;
6385 }
6386 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6387 if self.fragment_id != 0 {
6388 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6389 }
6390 struct_ser.end()
6391 }
6392}
6393impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6394 #[allow(deprecated)]
6395 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6396 where
6397 D: serde::Deserializer<'de>,
6398 {
6399 const FIELDS: &[&str] = &[
6400 "fragment_id",
6401 "fragmentId",
6402 ];
6403
6404 #[allow(clippy::enum_variant_names)]
6405 enum GeneratedField {
6406 FragmentId,
6407 }
6408 impl<'de> serde::Deserialize<'de> for GeneratedField {
6409 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6410 where
6411 D: serde::Deserializer<'de>,
6412 {
6413 struct GeneratedVisitor;
6414
6415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6416 type Value = GeneratedField;
6417
6418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6419 write!(formatter, "expected one of: {:?}", &FIELDS)
6420 }
6421
6422 #[allow(unused_variables)]
6423 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6424 where
6425 E: serde::de::Error,
6426 {
6427 match value {
6428 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6429 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6430 }
6431 }
6432 }
6433 deserializer.deserialize_identifier(GeneratedVisitor)
6434 }
6435 }
6436 struct GeneratedVisitor;
6437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6438 type Value = GetFragmentByIdRequest;
6439
6440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6441 formatter.write_str("struct meta.GetFragmentByIdRequest")
6442 }
6443
6444 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6445 where
6446 V: serde::de::MapAccess<'de>,
6447 {
6448 let mut fragment_id__ = None;
6449 while let Some(k) = map_.next_key()? {
6450 match k {
6451 GeneratedField::FragmentId => {
6452 if fragment_id__.is_some() {
6453 return Err(serde::de::Error::duplicate_field("fragmentId"));
6454 }
6455 fragment_id__ =
6456 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6457 ;
6458 }
6459 }
6460 }
6461 Ok(GetFragmentByIdRequest {
6462 fragment_id: fragment_id__.unwrap_or_default(),
6463 })
6464 }
6465 }
6466 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6467 }
6468}
6469impl serde::Serialize for GetFragmentByIdResponse {
6470 #[allow(deprecated)]
6471 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6472 where
6473 S: serde::Serializer,
6474 {
6475 use serde::ser::SerializeStruct;
6476 let mut len = 0;
6477 if self.distribution.is_some() {
6478 len += 1;
6479 }
6480 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6481 if let Some(v) = self.distribution.as_ref() {
6482 struct_ser.serialize_field("distribution", v)?;
6483 }
6484 struct_ser.end()
6485 }
6486}
6487impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6488 #[allow(deprecated)]
6489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6490 where
6491 D: serde::Deserializer<'de>,
6492 {
6493 const FIELDS: &[&str] = &[
6494 "distribution",
6495 ];
6496
6497 #[allow(clippy::enum_variant_names)]
6498 enum GeneratedField {
6499 Distribution,
6500 }
6501 impl<'de> serde::Deserialize<'de> for GeneratedField {
6502 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6503 where
6504 D: serde::Deserializer<'de>,
6505 {
6506 struct GeneratedVisitor;
6507
6508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6509 type Value = GeneratedField;
6510
6511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6512 write!(formatter, "expected one of: {:?}", &FIELDS)
6513 }
6514
6515 #[allow(unused_variables)]
6516 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6517 where
6518 E: serde::de::Error,
6519 {
6520 match value {
6521 "distribution" => Ok(GeneratedField::Distribution),
6522 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6523 }
6524 }
6525 }
6526 deserializer.deserialize_identifier(GeneratedVisitor)
6527 }
6528 }
6529 struct GeneratedVisitor;
6530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6531 type Value = GetFragmentByIdResponse;
6532
6533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6534 formatter.write_str("struct meta.GetFragmentByIdResponse")
6535 }
6536
6537 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
6538 where
6539 V: serde::de::MapAccess<'de>,
6540 {
6541 let mut distribution__ = None;
6542 while let Some(k) = map_.next_key()? {
6543 match k {
6544 GeneratedField::Distribution => {
6545 if distribution__.is_some() {
6546 return Err(serde::de::Error::duplicate_field("distribution"));
6547 }
6548 distribution__ = map_.next_value()?;
6549 }
6550 }
6551 }
6552 Ok(GetFragmentByIdResponse {
6553 distribution: distribution__,
6554 })
6555 }
6556 }
6557 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
6558 }
6559}
6560impl serde::Serialize for GetMetaStoreInfoRequest {
6561 #[allow(deprecated)]
6562 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6563 where
6564 S: serde::Serializer,
6565 {
6566 use serde::ser::SerializeStruct;
6567 let len = 0;
6568 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
6569 struct_ser.end()
6570 }
6571}
6572impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
6573 #[allow(deprecated)]
6574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6575 where
6576 D: serde::Deserializer<'de>,
6577 {
6578 const FIELDS: &[&str] = &[
6579 ];
6580
6581 #[allow(clippy::enum_variant_names)]
6582 enum GeneratedField {
6583 }
6584 impl<'de> serde::Deserialize<'de> for GeneratedField {
6585 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6586 where
6587 D: serde::Deserializer<'de>,
6588 {
6589 struct GeneratedVisitor;
6590
6591 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6592 type Value = GeneratedField;
6593
6594 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6595 write!(formatter, "expected one of: {:?}", &FIELDS)
6596 }
6597
6598 #[allow(unused_variables)]
6599 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6600 where
6601 E: serde::de::Error,
6602 {
6603 Err(serde::de::Error::unknown_field(value, FIELDS))
6604 }
6605 }
6606 deserializer.deserialize_identifier(GeneratedVisitor)
6607 }
6608 }
6609 struct GeneratedVisitor;
6610 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6611 type Value = GetMetaStoreInfoRequest;
6612
6613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6614 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
6615 }
6616
6617 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
6618 where
6619 V: serde::de::MapAccess<'de>,
6620 {
6621 while map_.next_key::<GeneratedField>()?.is_some() {
6622 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6623 }
6624 Ok(GetMetaStoreInfoRequest {
6625 })
6626 }
6627 }
6628 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
6629 }
6630}
6631impl serde::Serialize for GetMetaStoreInfoResponse {
6632 #[allow(deprecated)]
6633 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6634 where
6635 S: serde::Serializer,
6636 {
6637 use serde::ser::SerializeStruct;
6638 let mut len = 0;
6639 if !self.meta_store_endpoint.is_empty() {
6640 len += 1;
6641 }
6642 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
6643 if !self.meta_store_endpoint.is_empty() {
6644 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
6645 }
6646 struct_ser.end()
6647 }
6648}
6649impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
6650 #[allow(deprecated)]
6651 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6652 where
6653 D: serde::Deserializer<'de>,
6654 {
6655 const FIELDS: &[&str] = &[
6656 "meta_store_endpoint",
6657 "metaStoreEndpoint",
6658 ];
6659
6660 #[allow(clippy::enum_variant_names)]
6661 enum GeneratedField {
6662 MetaStoreEndpoint,
6663 }
6664 impl<'de> serde::Deserialize<'de> for GeneratedField {
6665 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6666 where
6667 D: serde::Deserializer<'de>,
6668 {
6669 struct GeneratedVisitor;
6670
6671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6672 type Value = GeneratedField;
6673
6674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6675 write!(formatter, "expected one of: {:?}", &FIELDS)
6676 }
6677
6678 #[allow(unused_variables)]
6679 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6680 where
6681 E: serde::de::Error,
6682 {
6683 match value {
6684 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
6685 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6686 }
6687 }
6688 }
6689 deserializer.deserialize_identifier(GeneratedVisitor)
6690 }
6691 }
6692 struct GeneratedVisitor;
6693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6694 type Value = GetMetaStoreInfoResponse;
6695
6696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6697 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
6698 }
6699
6700 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
6701 where
6702 V: serde::de::MapAccess<'de>,
6703 {
6704 let mut meta_store_endpoint__ = None;
6705 while let Some(k) = map_.next_key()? {
6706 match k {
6707 GeneratedField::MetaStoreEndpoint => {
6708 if meta_store_endpoint__.is_some() {
6709 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
6710 }
6711 meta_store_endpoint__ = Some(map_.next_value()?);
6712 }
6713 }
6714 }
6715 Ok(GetMetaStoreInfoResponse {
6716 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
6717 })
6718 }
6719 }
6720 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
6721 }
6722}
6723impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
6724 #[allow(deprecated)]
6725 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6726 where
6727 S: serde::Serializer,
6728 {
6729 use serde::ser::SerializeStruct;
6730 let len = 0;
6731 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
6732 struct_ser.end()
6733 }
6734}
6735impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
6736 #[allow(deprecated)]
6737 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6738 where
6739 D: serde::Deserializer<'de>,
6740 {
6741 const FIELDS: &[&str] = &[
6742 ];
6743
6744 #[allow(clippy::enum_variant_names)]
6745 enum GeneratedField {
6746 }
6747 impl<'de> serde::Deserialize<'de> for GeneratedField {
6748 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6749 where
6750 D: serde::Deserializer<'de>,
6751 {
6752 struct GeneratedVisitor;
6753
6754 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6755 type Value = GeneratedField;
6756
6757 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6758 write!(formatter, "expected one of: {:?}", &FIELDS)
6759 }
6760
6761 #[allow(unused_variables)]
6762 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6763 where
6764 E: serde::de::Error,
6765 {
6766 Err(serde::de::Error::unknown_field(value, FIELDS))
6767 }
6768 }
6769 deserializer.deserialize_identifier(GeneratedVisitor)
6770 }
6771 }
6772 struct GeneratedVisitor;
6773 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6774 type Value = GetServerlessStreamingJobsStatusRequest;
6775
6776 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6777 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
6778 }
6779
6780 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
6781 where
6782 V: serde::de::MapAccess<'de>,
6783 {
6784 while map_.next_key::<GeneratedField>()?.is_some() {
6785 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6786 }
6787 Ok(GetServerlessStreamingJobsStatusRequest {
6788 })
6789 }
6790 }
6791 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
6792 }
6793}
6794impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
6795 #[allow(deprecated)]
6796 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6797 where
6798 S: serde::Serializer,
6799 {
6800 use serde::ser::SerializeStruct;
6801 let mut len = 0;
6802 if !self.streaming_job_statuses.is_empty() {
6803 len += 1;
6804 }
6805 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
6806 if !self.streaming_job_statuses.is_empty() {
6807 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
6808 }
6809 struct_ser.end()
6810 }
6811}
6812impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
6813 #[allow(deprecated)]
6814 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6815 where
6816 D: serde::Deserializer<'de>,
6817 {
6818 const FIELDS: &[&str] = &[
6819 "streaming_job_statuses",
6820 "streamingJobStatuses",
6821 ];
6822
6823 #[allow(clippy::enum_variant_names)]
6824 enum GeneratedField {
6825 StreamingJobStatuses,
6826 }
6827 impl<'de> serde::Deserialize<'de> for GeneratedField {
6828 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6829 where
6830 D: serde::Deserializer<'de>,
6831 {
6832 struct GeneratedVisitor;
6833
6834 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6835 type Value = GeneratedField;
6836
6837 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6838 write!(formatter, "expected one of: {:?}", &FIELDS)
6839 }
6840
6841 #[allow(unused_variables)]
6842 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6843 where
6844 E: serde::de::Error,
6845 {
6846 match value {
6847 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
6848 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6849 }
6850 }
6851 }
6852 deserializer.deserialize_identifier(GeneratedVisitor)
6853 }
6854 }
6855 struct GeneratedVisitor;
6856 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6857 type Value = GetServerlessStreamingJobsStatusResponse;
6858
6859 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6860 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
6861 }
6862
6863 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
6864 where
6865 V: serde::de::MapAccess<'de>,
6866 {
6867 let mut streaming_job_statuses__ = None;
6868 while let Some(k) = map_.next_key()? {
6869 match k {
6870 GeneratedField::StreamingJobStatuses => {
6871 if streaming_job_statuses__.is_some() {
6872 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
6873 }
6874 streaming_job_statuses__ = Some(map_.next_value()?);
6875 }
6876 }
6877 }
6878 Ok(GetServerlessStreamingJobsStatusResponse {
6879 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
6880 })
6881 }
6882 }
6883 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
6884 }
6885}
6886impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
6887 #[allow(deprecated)]
6888 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6889 where
6890 S: serde::Serializer,
6891 {
6892 use serde::ser::SerializeStruct;
6893 let mut len = 0;
6894 if self.table_id != 0 {
6895 len += 1;
6896 }
6897 if !self.node_label.is_empty() {
6898 len += 1;
6899 }
6900 if self.backfill_done {
6901 len += 1;
6902 }
6903 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
6904 if self.table_id != 0 {
6905 struct_ser.serialize_field("tableId", &self.table_id)?;
6906 }
6907 if !self.node_label.is_empty() {
6908 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
6909 }
6910 if self.backfill_done {
6911 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
6912 }
6913 struct_ser.end()
6914 }
6915}
6916impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
6917 #[allow(deprecated)]
6918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6919 where
6920 D: serde::Deserializer<'de>,
6921 {
6922 const FIELDS: &[&str] = &[
6923 "table_id",
6924 "tableId",
6925 "node_label",
6926 "nodeLabel",
6927 "backfill_done",
6928 "backfillDone",
6929 ];
6930
6931 #[allow(clippy::enum_variant_names)]
6932 enum GeneratedField {
6933 TableId,
6934 NodeLabel,
6935 BackfillDone,
6936 }
6937 impl<'de> serde::Deserialize<'de> for GeneratedField {
6938 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6939 where
6940 D: serde::Deserializer<'de>,
6941 {
6942 struct GeneratedVisitor;
6943
6944 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6945 type Value = GeneratedField;
6946
6947 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6948 write!(formatter, "expected one of: {:?}", &FIELDS)
6949 }
6950
6951 #[allow(unused_variables)]
6952 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6953 where
6954 E: serde::de::Error,
6955 {
6956 match value {
6957 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6958 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
6959 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
6960 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6961 }
6962 }
6963 }
6964 deserializer.deserialize_identifier(GeneratedVisitor)
6965 }
6966 }
6967 struct GeneratedVisitor;
6968 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6969 type Value = get_serverless_streaming_jobs_status_response::Status;
6970
6971 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6972 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
6973 }
6974
6975 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
6976 where
6977 V: serde::de::MapAccess<'de>,
6978 {
6979 let mut table_id__ = None;
6980 let mut node_label__ = None;
6981 let mut backfill_done__ = None;
6982 while let Some(k) = map_.next_key()? {
6983 match k {
6984 GeneratedField::TableId => {
6985 if table_id__.is_some() {
6986 return Err(serde::de::Error::duplicate_field("tableId"));
6987 }
6988 table_id__ =
6989 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6990 ;
6991 }
6992 GeneratedField::NodeLabel => {
6993 if node_label__.is_some() {
6994 return Err(serde::de::Error::duplicate_field("nodeLabel"));
6995 }
6996 node_label__ = Some(map_.next_value()?);
6997 }
6998 GeneratedField::BackfillDone => {
6999 if backfill_done__.is_some() {
7000 return Err(serde::de::Error::duplicate_field("backfillDone"));
7001 }
7002 backfill_done__ = Some(map_.next_value()?);
7003 }
7004 }
7005 }
7006 Ok(get_serverless_streaming_jobs_status_response::Status {
7007 table_id: table_id__.unwrap_or_default(),
7008 node_label: node_label__.unwrap_or_default(),
7009 backfill_done: backfill_done__.unwrap_or_default(),
7010 })
7011 }
7012 }
7013 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
7014 }
7015}
7016impl serde::Serialize for GetServingVnodeMappingsRequest {
7017 #[allow(deprecated)]
7018 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7019 where
7020 S: serde::Serializer,
7021 {
7022 use serde::ser::SerializeStruct;
7023 let len = 0;
7024 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
7025 struct_ser.end()
7026 }
7027}
7028impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
7029 #[allow(deprecated)]
7030 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7031 where
7032 D: serde::Deserializer<'de>,
7033 {
7034 const FIELDS: &[&str] = &[
7035 ];
7036
7037 #[allow(clippy::enum_variant_names)]
7038 enum GeneratedField {
7039 }
7040 impl<'de> serde::Deserialize<'de> for GeneratedField {
7041 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7042 where
7043 D: serde::Deserializer<'de>,
7044 {
7045 struct GeneratedVisitor;
7046
7047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7048 type Value = GeneratedField;
7049
7050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7051 write!(formatter, "expected one of: {:?}", &FIELDS)
7052 }
7053
7054 #[allow(unused_variables)]
7055 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7056 where
7057 E: serde::de::Error,
7058 {
7059 Err(serde::de::Error::unknown_field(value, FIELDS))
7060 }
7061 }
7062 deserializer.deserialize_identifier(GeneratedVisitor)
7063 }
7064 }
7065 struct GeneratedVisitor;
7066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7067 type Value = GetServingVnodeMappingsRequest;
7068
7069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7070 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
7071 }
7072
7073 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
7074 where
7075 V: serde::de::MapAccess<'de>,
7076 {
7077 while map_.next_key::<GeneratedField>()?.is_some() {
7078 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7079 }
7080 Ok(GetServingVnodeMappingsRequest {
7081 })
7082 }
7083 }
7084 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
7085 }
7086}
7087impl serde::Serialize for GetServingVnodeMappingsResponse {
7088 #[allow(deprecated)]
7089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7090 where
7091 S: serde::Serializer,
7092 {
7093 use serde::ser::SerializeStruct;
7094 let mut len = 0;
7095 if !self.fragment_to_table.is_empty() {
7096 len += 1;
7097 }
7098 if !self.worker_slot_mappings.is_empty() {
7099 len += 1;
7100 }
7101 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
7102 if !self.fragment_to_table.is_empty() {
7103 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
7104 }
7105 if !self.worker_slot_mappings.is_empty() {
7106 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
7107 }
7108 struct_ser.end()
7109 }
7110}
7111impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
7112 #[allow(deprecated)]
7113 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7114 where
7115 D: serde::Deserializer<'de>,
7116 {
7117 const FIELDS: &[&str] = &[
7118 "fragment_to_table",
7119 "fragmentToTable",
7120 "worker_slot_mappings",
7121 "workerSlotMappings",
7122 ];
7123
7124 #[allow(clippy::enum_variant_names)]
7125 enum GeneratedField {
7126 FragmentToTable,
7127 WorkerSlotMappings,
7128 }
7129 impl<'de> serde::Deserialize<'de> for GeneratedField {
7130 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7131 where
7132 D: serde::Deserializer<'de>,
7133 {
7134 struct GeneratedVisitor;
7135
7136 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7137 type Value = GeneratedField;
7138
7139 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7140 write!(formatter, "expected one of: {:?}", &FIELDS)
7141 }
7142
7143 #[allow(unused_variables)]
7144 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7145 where
7146 E: serde::de::Error,
7147 {
7148 match value {
7149 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
7150 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7151 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7152 }
7153 }
7154 }
7155 deserializer.deserialize_identifier(GeneratedVisitor)
7156 }
7157 }
7158 struct GeneratedVisitor;
7159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7160 type Value = GetServingVnodeMappingsResponse;
7161
7162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7163 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7164 }
7165
7166 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7167 where
7168 V: serde::de::MapAccess<'de>,
7169 {
7170 let mut fragment_to_table__ = None;
7171 let mut worker_slot_mappings__ = None;
7172 while let Some(k) = map_.next_key()? {
7173 match k {
7174 GeneratedField::FragmentToTable => {
7175 if fragment_to_table__.is_some() {
7176 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7177 }
7178 fragment_to_table__ = Some(
7179 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7180 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
7181 );
7182 }
7183 GeneratedField::WorkerSlotMappings => {
7184 if worker_slot_mappings__.is_some() {
7185 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7186 }
7187 worker_slot_mappings__ = Some(map_.next_value()?);
7188 }
7189 }
7190 }
7191 Ok(GetServingVnodeMappingsResponse {
7192 fragment_to_table: fragment_to_table__.unwrap_or_default(),
7193 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7194 })
7195 }
7196 }
7197 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7198 }
7199}
7200impl serde::Serialize for GetSessionParamsRequest {
7201 #[allow(deprecated)]
7202 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7203 where
7204 S: serde::Serializer,
7205 {
7206 use serde::ser::SerializeStruct;
7207 let len = 0;
7208 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7209 struct_ser.end()
7210 }
7211}
7212impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7213 #[allow(deprecated)]
7214 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7215 where
7216 D: serde::Deserializer<'de>,
7217 {
7218 const FIELDS: &[&str] = &[
7219 ];
7220
7221 #[allow(clippy::enum_variant_names)]
7222 enum GeneratedField {
7223 }
7224 impl<'de> serde::Deserialize<'de> for GeneratedField {
7225 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7226 where
7227 D: serde::Deserializer<'de>,
7228 {
7229 struct GeneratedVisitor;
7230
7231 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7232 type Value = GeneratedField;
7233
7234 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7235 write!(formatter, "expected one of: {:?}", &FIELDS)
7236 }
7237
7238 #[allow(unused_variables)]
7239 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7240 where
7241 E: serde::de::Error,
7242 {
7243 Err(serde::de::Error::unknown_field(value, FIELDS))
7244 }
7245 }
7246 deserializer.deserialize_identifier(GeneratedVisitor)
7247 }
7248 }
7249 struct GeneratedVisitor;
7250 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7251 type Value = GetSessionParamsRequest;
7252
7253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7254 formatter.write_str("struct meta.GetSessionParamsRequest")
7255 }
7256
7257 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
7258 where
7259 V: serde::de::MapAccess<'de>,
7260 {
7261 while map_.next_key::<GeneratedField>()?.is_some() {
7262 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7263 }
7264 Ok(GetSessionParamsRequest {
7265 })
7266 }
7267 }
7268 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
7269 }
7270}
7271impl serde::Serialize for GetSessionParamsResponse {
7272 #[allow(deprecated)]
7273 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7274 where
7275 S: serde::Serializer,
7276 {
7277 use serde::ser::SerializeStruct;
7278 let mut len = 0;
7279 if !self.params.is_empty() {
7280 len += 1;
7281 }
7282 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
7283 if !self.params.is_empty() {
7284 struct_ser.serialize_field("params", &self.params)?;
7285 }
7286 struct_ser.end()
7287 }
7288}
7289impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
7290 #[allow(deprecated)]
7291 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7292 where
7293 D: serde::Deserializer<'de>,
7294 {
7295 const FIELDS: &[&str] = &[
7296 "params",
7297 ];
7298
7299 #[allow(clippy::enum_variant_names)]
7300 enum GeneratedField {
7301 Params,
7302 }
7303 impl<'de> serde::Deserialize<'de> for GeneratedField {
7304 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7305 where
7306 D: serde::Deserializer<'de>,
7307 {
7308 struct GeneratedVisitor;
7309
7310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7311 type Value = GeneratedField;
7312
7313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7314 write!(formatter, "expected one of: {:?}", &FIELDS)
7315 }
7316
7317 #[allow(unused_variables)]
7318 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7319 where
7320 E: serde::de::Error,
7321 {
7322 match value {
7323 "params" => Ok(GeneratedField::Params),
7324 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7325 }
7326 }
7327 }
7328 deserializer.deserialize_identifier(GeneratedVisitor)
7329 }
7330 }
7331 struct GeneratedVisitor;
7332 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7333 type Value = GetSessionParamsResponse;
7334
7335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7336 formatter.write_str("struct meta.GetSessionParamsResponse")
7337 }
7338
7339 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
7340 where
7341 V: serde::de::MapAccess<'de>,
7342 {
7343 let mut params__ = None;
7344 while let Some(k) = map_.next_key()? {
7345 match k {
7346 GeneratedField::Params => {
7347 if params__.is_some() {
7348 return Err(serde::de::Error::duplicate_field("params"));
7349 }
7350 params__ = Some(map_.next_value()?);
7351 }
7352 }
7353 }
7354 Ok(GetSessionParamsResponse {
7355 params: params__.unwrap_or_default(),
7356 })
7357 }
7358 }
7359 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
7360 }
7361}
7362impl serde::Serialize for GetSystemParamsRequest {
7363 #[allow(deprecated)]
7364 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7365 where
7366 S: serde::Serializer,
7367 {
7368 use serde::ser::SerializeStruct;
7369 let len = 0;
7370 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
7371 struct_ser.end()
7372 }
7373}
7374impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
7375 #[allow(deprecated)]
7376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7377 where
7378 D: serde::Deserializer<'de>,
7379 {
7380 const FIELDS: &[&str] = &[
7381 ];
7382
7383 #[allow(clippy::enum_variant_names)]
7384 enum GeneratedField {
7385 }
7386 impl<'de> serde::Deserialize<'de> for GeneratedField {
7387 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7388 where
7389 D: serde::Deserializer<'de>,
7390 {
7391 struct GeneratedVisitor;
7392
7393 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7394 type Value = GeneratedField;
7395
7396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7397 write!(formatter, "expected one of: {:?}", &FIELDS)
7398 }
7399
7400 #[allow(unused_variables)]
7401 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7402 where
7403 E: serde::de::Error,
7404 {
7405 Err(serde::de::Error::unknown_field(value, FIELDS))
7406 }
7407 }
7408 deserializer.deserialize_identifier(GeneratedVisitor)
7409 }
7410 }
7411 struct GeneratedVisitor;
7412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7413 type Value = GetSystemParamsRequest;
7414
7415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7416 formatter.write_str("struct meta.GetSystemParamsRequest")
7417 }
7418
7419 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
7420 where
7421 V: serde::de::MapAccess<'de>,
7422 {
7423 while map_.next_key::<GeneratedField>()?.is_some() {
7424 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7425 }
7426 Ok(GetSystemParamsRequest {
7427 })
7428 }
7429 }
7430 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
7431 }
7432}
7433impl serde::Serialize for GetSystemParamsResponse {
7434 #[allow(deprecated)]
7435 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7436 where
7437 S: serde::Serializer,
7438 {
7439 use serde::ser::SerializeStruct;
7440 let mut len = 0;
7441 if self.params.is_some() {
7442 len += 1;
7443 }
7444 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
7445 if let Some(v) = self.params.as_ref() {
7446 struct_ser.serialize_field("params", v)?;
7447 }
7448 struct_ser.end()
7449 }
7450}
7451impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
7452 #[allow(deprecated)]
7453 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7454 where
7455 D: serde::Deserializer<'de>,
7456 {
7457 const FIELDS: &[&str] = &[
7458 "params",
7459 ];
7460
7461 #[allow(clippy::enum_variant_names)]
7462 enum GeneratedField {
7463 Params,
7464 }
7465 impl<'de> serde::Deserialize<'de> for GeneratedField {
7466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7467 where
7468 D: serde::Deserializer<'de>,
7469 {
7470 struct GeneratedVisitor;
7471
7472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7473 type Value = GeneratedField;
7474
7475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7476 write!(formatter, "expected one of: {:?}", &FIELDS)
7477 }
7478
7479 #[allow(unused_variables)]
7480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7481 where
7482 E: serde::de::Error,
7483 {
7484 match value {
7485 "params" => Ok(GeneratedField::Params),
7486 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7487 }
7488 }
7489 }
7490 deserializer.deserialize_identifier(GeneratedVisitor)
7491 }
7492 }
7493 struct GeneratedVisitor;
7494 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7495 type Value = GetSystemParamsResponse;
7496
7497 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7498 formatter.write_str("struct meta.GetSystemParamsResponse")
7499 }
7500
7501 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
7502 where
7503 V: serde::de::MapAccess<'de>,
7504 {
7505 let mut params__ = None;
7506 while let Some(k) = map_.next_key()? {
7507 match k {
7508 GeneratedField::Params => {
7509 if params__.is_some() {
7510 return Err(serde::de::Error::duplicate_field("params"));
7511 }
7512 params__ = map_.next_value()?;
7513 }
7514 }
7515 }
7516 Ok(GetSystemParamsResponse {
7517 params: params__,
7518 })
7519 }
7520 }
7521 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
7522 }
7523}
7524impl serde::Serialize for GetTelemetryInfoRequest {
7525 #[allow(deprecated)]
7526 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7527 where
7528 S: serde::Serializer,
7529 {
7530 use serde::ser::SerializeStruct;
7531 let len = 0;
7532 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
7533 struct_ser.end()
7534 }
7535}
7536impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
7537 #[allow(deprecated)]
7538 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7539 where
7540 D: serde::Deserializer<'de>,
7541 {
7542 const FIELDS: &[&str] = &[
7543 ];
7544
7545 #[allow(clippy::enum_variant_names)]
7546 enum GeneratedField {
7547 }
7548 impl<'de> serde::Deserialize<'de> for GeneratedField {
7549 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7550 where
7551 D: serde::Deserializer<'de>,
7552 {
7553 struct GeneratedVisitor;
7554
7555 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7556 type Value = GeneratedField;
7557
7558 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7559 write!(formatter, "expected one of: {:?}", &FIELDS)
7560 }
7561
7562 #[allow(unused_variables)]
7563 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7564 where
7565 E: serde::de::Error,
7566 {
7567 Err(serde::de::Error::unknown_field(value, FIELDS))
7568 }
7569 }
7570 deserializer.deserialize_identifier(GeneratedVisitor)
7571 }
7572 }
7573 struct GeneratedVisitor;
7574 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7575 type Value = GetTelemetryInfoRequest;
7576
7577 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7578 formatter.write_str("struct meta.GetTelemetryInfoRequest")
7579 }
7580
7581 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
7582 where
7583 V: serde::de::MapAccess<'de>,
7584 {
7585 while map_.next_key::<GeneratedField>()?.is_some() {
7586 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7587 }
7588 Ok(GetTelemetryInfoRequest {
7589 })
7590 }
7591 }
7592 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
7593 }
7594}
7595impl serde::Serialize for HeartbeatRequest {
7596 #[allow(deprecated)]
7597 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7598 where
7599 S: serde::Serializer,
7600 {
7601 use serde::ser::SerializeStruct;
7602 let mut len = 0;
7603 if self.node_id != 0 {
7604 len += 1;
7605 }
7606 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
7607 if self.node_id != 0 {
7608 struct_ser.serialize_field("nodeId", &self.node_id)?;
7609 }
7610 struct_ser.end()
7611 }
7612}
7613impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
7614 #[allow(deprecated)]
7615 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7616 where
7617 D: serde::Deserializer<'de>,
7618 {
7619 const FIELDS: &[&str] = &[
7620 "node_id",
7621 "nodeId",
7622 ];
7623
7624 #[allow(clippy::enum_variant_names)]
7625 enum GeneratedField {
7626 NodeId,
7627 }
7628 impl<'de> serde::Deserialize<'de> for GeneratedField {
7629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7630 where
7631 D: serde::Deserializer<'de>,
7632 {
7633 struct GeneratedVisitor;
7634
7635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7636 type Value = GeneratedField;
7637
7638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7639 write!(formatter, "expected one of: {:?}", &FIELDS)
7640 }
7641
7642 #[allow(unused_variables)]
7643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7644 where
7645 E: serde::de::Error,
7646 {
7647 match value {
7648 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
7649 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7650 }
7651 }
7652 }
7653 deserializer.deserialize_identifier(GeneratedVisitor)
7654 }
7655 }
7656 struct GeneratedVisitor;
7657 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7658 type Value = HeartbeatRequest;
7659
7660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7661 formatter.write_str("struct meta.HeartbeatRequest")
7662 }
7663
7664 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
7665 where
7666 V: serde::de::MapAccess<'de>,
7667 {
7668 let mut node_id__ = None;
7669 while let Some(k) = map_.next_key()? {
7670 match k {
7671 GeneratedField::NodeId => {
7672 if node_id__.is_some() {
7673 return Err(serde::de::Error::duplicate_field("nodeId"));
7674 }
7675 node_id__ =
7676 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7677 ;
7678 }
7679 }
7680 }
7681 Ok(HeartbeatRequest {
7682 node_id: node_id__.unwrap_or_default(),
7683 })
7684 }
7685 }
7686 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
7687 }
7688}
7689impl serde::Serialize for HeartbeatResponse {
7690 #[allow(deprecated)]
7691 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7692 where
7693 S: serde::Serializer,
7694 {
7695 use serde::ser::SerializeStruct;
7696 let mut len = 0;
7697 if self.status.is_some() {
7698 len += 1;
7699 }
7700 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
7701 if let Some(v) = self.status.as_ref() {
7702 struct_ser.serialize_field("status", v)?;
7703 }
7704 struct_ser.end()
7705 }
7706}
7707impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
7708 #[allow(deprecated)]
7709 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7710 where
7711 D: serde::Deserializer<'de>,
7712 {
7713 const FIELDS: &[&str] = &[
7714 "status",
7715 ];
7716
7717 #[allow(clippy::enum_variant_names)]
7718 enum GeneratedField {
7719 Status,
7720 }
7721 impl<'de> serde::Deserialize<'de> for GeneratedField {
7722 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7723 where
7724 D: serde::Deserializer<'de>,
7725 {
7726 struct GeneratedVisitor;
7727
7728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7729 type Value = GeneratedField;
7730
7731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7732 write!(formatter, "expected one of: {:?}", &FIELDS)
7733 }
7734
7735 #[allow(unused_variables)]
7736 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7737 where
7738 E: serde::de::Error,
7739 {
7740 match value {
7741 "status" => Ok(GeneratedField::Status),
7742 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7743 }
7744 }
7745 }
7746 deserializer.deserialize_identifier(GeneratedVisitor)
7747 }
7748 }
7749 struct GeneratedVisitor;
7750 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7751 type Value = HeartbeatResponse;
7752
7753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7754 formatter.write_str("struct meta.HeartbeatResponse")
7755 }
7756
7757 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
7758 where
7759 V: serde::de::MapAccess<'de>,
7760 {
7761 let mut status__ = None;
7762 while let Some(k) = map_.next_key()? {
7763 match k {
7764 GeneratedField::Status => {
7765 if status__.is_some() {
7766 return Err(serde::de::Error::duplicate_field("status"));
7767 }
7768 status__ = map_.next_value()?;
7769 }
7770 }
7771 }
7772 Ok(HeartbeatResponse {
7773 status: status__,
7774 })
7775 }
7776 }
7777 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
7778 }
7779}
7780impl serde::Serialize for ListActorSplitsRequest {
7781 #[allow(deprecated)]
7782 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7783 where
7784 S: serde::Serializer,
7785 {
7786 use serde::ser::SerializeStruct;
7787 let len = 0;
7788 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
7789 struct_ser.end()
7790 }
7791}
7792impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
7793 #[allow(deprecated)]
7794 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7795 where
7796 D: serde::Deserializer<'de>,
7797 {
7798 const FIELDS: &[&str] = &[
7799 ];
7800
7801 #[allow(clippy::enum_variant_names)]
7802 enum GeneratedField {
7803 }
7804 impl<'de> serde::Deserialize<'de> for GeneratedField {
7805 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7806 where
7807 D: serde::Deserializer<'de>,
7808 {
7809 struct GeneratedVisitor;
7810
7811 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7812 type Value = GeneratedField;
7813
7814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7815 write!(formatter, "expected one of: {:?}", &FIELDS)
7816 }
7817
7818 #[allow(unused_variables)]
7819 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7820 where
7821 E: serde::de::Error,
7822 {
7823 Err(serde::de::Error::unknown_field(value, FIELDS))
7824 }
7825 }
7826 deserializer.deserialize_identifier(GeneratedVisitor)
7827 }
7828 }
7829 struct GeneratedVisitor;
7830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7831 type Value = ListActorSplitsRequest;
7832
7833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7834 formatter.write_str("struct meta.ListActorSplitsRequest")
7835 }
7836
7837 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
7838 where
7839 V: serde::de::MapAccess<'de>,
7840 {
7841 while map_.next_key::<GeneratedField>()?.is_some() {
7842 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7843 }
7844 Ok(ListActorSplitsRequest {
7845 })
7846 }
7847 }
7848 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
7849 }
7850}
7851impl serde::Serialize for ListActorSplitsResponse {
7852 #[allow(deprecated)]
7853 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7854 where
7855 S: serde::Serializer,
7856 {
7857 use serde::ser::SerializeStruct;
7858 let mut len = 0;
7859 if !self.actor_splits.is_empty() {
7860 len += 1;
7861 }
7862 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
7863 if !self.actor_splits.is_empty() {
7864 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
7865 }
7866 struct_ser.end()
7867 }
7868}
7869impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
7870 #[allow(deprecated)]
7871 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7872 where
7873 D: serde::Deserializer<'de>,
7874 {
7875 const FIELDS: &[&str] = &[
7876 "actor_splits",
7877 "actorSplits",
7878 ];
7879
7880 #[allow(clippy::enum_variant_names)]
7881 enum GeneratedField {
7882 ActorSplits,
7883 }
7884 impl<'de> serde::Deserialize<'de> for GeneratedField {
7885 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7886 where
7887 D: serde::Deserializer<'de>,
7888 {
7889 struct GeneratedVisitor;
7890
7891 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7892 type Value = GeneratedField;
7893
7894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7895 write!(formatter, "expected one of: {:?}", &FIELDS)
7896 }
7897
7898 #[allow(unused_variables)]
7899 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7900 where
7901 E: serde::de::Error,
7902 {
7903 match value {
7904 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
7905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7906 }
7907 }
7908 }
7909 deserializer.deserialize_identifier(GeneratedVisitor)
7910 }
7911 }
7912 struct GeneratedVisitor;
7913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7914 type Value = ListActorSplitsResponse;
7915
7916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7917 formatter.write_str("struct meta.ListActorSplitsResponse")
7918 }
7919
7920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
7921 where
7922 V: serde::de::MapAccess<'de>,
7923 {
7924 let mut actor_splits__ = None;
7925 while let Some(k) = map_.next_key()? {
7926 match k {
7927 GeneratedField::ActorSplits => {
7928 if actor_splits__.is_some() {
7929 return Err(serde::de::Error::duplicate_field("actorSplits"));
7930 }
7931 actor_splits__ = Some(map_.next_value()?);
7932 }
7933 }
7934 }
7935 Ok(ListActorSplitsResponse {
7936 actor_splits: actor_splits__.unwrap_or_default(),
7937 })
7938 }
7939 }
7940 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
7941 }
7942}
7943impl serde::Serialize for list_actor_splits_response::ActorSplit {
7944 #[allow(deprecated)]
7945 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7946 where
7947 S: serde::Serializer,
7948 {
7949 use serde::ser::SerializeStruct;
7950 let mut len = 0;
7951 if self.actor_id != 0 {
7952 len += 1;
7953 }
7954 if self.fragment_id != 0 {
7955 len += 1;
7956 }
7957 if self.source_id != 0 {
7958 len += 1;
7959 }
7960 if !self.split_id.is_empty() {
7961 len += 1;
7962 }
7963 if self.fragment_type != 0 {
7964 len += 1;
7965 }
7966 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
7967 if self.actor_id != 0 {
7968 struct_ser.serialize_field("actorId", &self.actor_id)?;
7969 }
7970 if self.fragment_id != 0 {
7971 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7972 }
7973 if self.source_id != 0 {
7974 struct_ser.serialize_field("sourceId", &self.source_id)?;
7975 }
7976 if !self.split_id.is_empty() {
7977 struct_ser.serialize_field("splitId", &self.split_id)?;
7978 }
7979 if self.fragment_type != 0 {
7980 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
7981 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
7982 struct_ser.serialize_field("fragmentType", &v)?;
7983 }
7984 struct_ser.end()
7985 }
7986}
7987impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
7988 #[allow(deprecated)]
7989 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7990 where
7991 D: serde::Deserializer<'de>,
7992 {
7993 const FIELDS: &[&str] = &[
7994 "actor_id",
7995 "actorId",
7996 "fragment_id",
7997 "fragmentId",
7998 "source_id",
7999 "sourceId",
8000 "split_id",
8001 "splitId",
8002 "fragment_type",
8003 "fragmentType",
8004 ];
8005
8006 #[allow(clippy::enum_variant_names)]
8007 enum GeneratedField {
8008 ActorId,
8009 FragmentId,
8010 SourceId,
8011 SplitId,
8012 FragmentType,
8013 }
8014 impl<'de> serde::Deserialize<'de> for GeneratedField {
8015 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8016 where
8017 D: serde::Deserializer<'de>,
8018 {
8019 struct GeneratedVisitor;
8020
8021 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8022 type Value = GeneratedField;
8023
8024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8025 write!(formatter, "expected one of: {:?}", &FIELDS)
8026 }
8027
8028 #[allow(unused_variables)]
8029 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8030 where
8031 E: serde::de::Error,
8032 {
8033 match value {
8034 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8035 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8036 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8037 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
8038 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
8039 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8040 }
8041 }
8042 }
8043 deserializer.deserialize_identifier(GeneratedVisitor)
8044 }
8045 }
8046 struct GeneratedVisitor;
8047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8048 type Value = list_actor_splits_response::ActorSplit;
8049
8050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8051 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
8052 }
8053
8054 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
8055 where
8056 V: serde::de::MapAccess<'de>,
8057 {
8058 let mut actor_id__ = None;
8059 let mut fragment_id__ = None;
8060 let mut source_id__ = None;
8061 let mut split_id__ = None;
8062 let mut fragment_type__ = None;
8063 while let Some(k) = map_.next_key()? {
8064 match k {
8065 GeneratedField::ActorId => {
8066 if actor_id__.is_some() {
8067 return Err(serde::de::Error::duplicate_field("actorId"));
8068 }
8069 actor_id__ =
8070 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8071 ;
8072 }
8073 GeneratedField::FragmentId => {
8074 if fragment_id__.is_some() {
8075 return Err(serde::de::Error::duplicate_field("fragmentId"));
8076 }
8077 fragment_id__ =
8078 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8079 ;
8080 }
8081 GeneratedField::SourceId => {
8082 if source_id__.is_some() {
8083 return Err(serde::de::Error::duplicate_field("sourceId"));
8084 }
8085 source_id__ =
8086 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8087 ;
8088 }
8089 GeneratedField::SplitId => {
8090 if split_id__.is_some() {
8091 return Err(serde::de::Error::duplicate_field("splitId"));
8092 }
8093 split_id__ = Some(map_.next_value()?);
8094 }
8095 GeneratedField::FragmentType => {
8096 if fragment_type__.is_some() {
8097 return Err(serde::de::Error::duplicate_field("fragmentType"));
8098 }
8099 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
8100 }
8101 }
8102 }
8103 Ok(list_actor_splits_response::ActorSplit {
8104 actor_id: actor_id__.unwrap_or_default(),
8105 fragment_id: fragment_id__.unwrap_or_default(),
8106 source_id: source_id__.unwrap_or_default(),
8107 split_id: split_id__.unwrap_or_default(),
8108 fragment_type: fragment_type__.unwrap_or_default(),
8109 })
8110 }
8111 }
8112 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
8113 }
8114}
8115impl serde::Serialize for list_actor_splits_response::FragmentType {
8116 #[allow(deprecated)]
8117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8118 where
8119 S: serde::Serializer,
8120 {
8121 let variant = match self {
8122 Self::Unspecified => "UNSPECIFIED",
8123 Self::NonSharedSource => "NON_SHARED_SOURCE",
8124 Self::SharedSource => "SHARED_SOURCE",
8125 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
8126 };
8127 serializer.serialize_str(variant)
8128 }
8129}
8130impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
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 "UNSPECIFIED",
8138 "NON_SHARED_SOURCE",
8139 "SHARED_SOURCE",
8140 "SHARED_SOURCE_BACKFILL",
8141 ];
8142
8143 struct GeneratedVisitor;
8144
8145 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8146 type Value = list_actor_splits_response::FragmentType;
8147
8148 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8149 write!(formatter, "expected one of: {:?}", &FIELDS)
8150 }
8151
8152 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8153 where
8154 E: serde::de::Error,
8155 {
8156 i32::try_from(v)
8157 .ok()
8158 .and_then(|x| x.try_into().ok())
8159 .ok_or_else(|| {
8160 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8161 })
8162 }
8163
8164 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8165 where
8166 E: serde::de::Error,
8167 {
8168 i32::try_from(v)
8169 .ok()
8170 .and_then(|x| x.try_into().ok())
8171 .ok_or_else(|| {
8172 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8173 })
8174 }
8175
8176 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8177 where
8178 E: serde::de::Error,
8179 {
8180 match value {
8181 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
8182 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
8183 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
8184 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
8185 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8186 }
8187 }
8188 }
8189 deserializer.deserialize_any(GeneratedVisitor)
8190 }
8191}
8192impl serde::Serialize for ListActorStatesRequest {
8193 #[allow(deprecated)]
8194 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8195 where
8196 S: serde::Serializer,
8197 {
8198 use serde::ser::SerializeStruct;
8199 let len = 0;
8200 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
8201 struct_ser.end()
8202 }
8203}
8204impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
8205 #[allow(deprecated)]
8206 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8207 where
8208 D: serde::Deserializer<'de>,
8209 {
8210 const FIELDS: &[&str] = &[
8211 ];
8212
8213 #[allow(clippy::enum_variant_names)]
8214 enum GeneratedField {
8215 }
8216 impl<'de> serde::Deserialize<'de> for GeneratedField {
8217 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8218 where
8219 D: serde::Deserializer<'de>,
8220 {
8221 struct GeneratedVisitor;
8222
8223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8224 type Value = GeneratedField;
8225
8226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8227 write!(formatter, "expected one of: {:?}", &FIELDS)
8228 }
8229
8230 #[allow(unused_variables)]
8231 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8232 where
8233 E: serde::de::Error,
8234 {
8235 Err(serde::de::Error::unknown_field(value, FIELDS))
8236 }
8237 }
8238 deserializer.deserialize_identifier(GeneratedVisitor)
8239 }
8240 }
8241 struct GeneratedVisitor;
8242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8243 type Value = ListActorStatesRequest;
8244
8245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8246 formatter.write_str("struct meta.ListActorStatesRequest")
8247 }
8248
8249 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
8250 where
8251 V: serde::de::MapAccess<'de>,
8252 {
8253 while map_.next_key::<GeneratedField>()?.is_some() {
8254 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8255 }
8256 Ok(ListActorStatesRequest {
8257 })
8258 }
8259 }
8260 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
8261 }
8262}
8263impl serde::Serialize for ListActorStatesResponse {
8264 #[allow(deprecated)]
8265 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8266 where
8267 S: serde::Serializer,
8268 {
8269 use serde::ser::SerializeStruct;
8270 let mut len = 0;
8271 if !self.states.is_empty() {
8272 len += 1;
8273 }
8274 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
8275 if !self.states.is_empty() {
8276 struct_ser.serialize_field("states", &self.states)?;
8277 }
8278 struct_ser.end()
8279 }
8280}
8281impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
8282 #[allow(deprecated)]
8283 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8284 where
8285 D: serde::Deserializer<'de>,
8286 {
8287 const FIELDS: &[&str] = &[
8288 "states",
8289 ];
8290
8291 #[allow(clippy::enum_variant_names)]
8292 enum GeneratedField {
8293 States,
8294 }
8295 impl<'de> serde::Deserialize<'de> for GeneratedField {
8296 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8297 where
8298 D: serde::Deserializer<'de>,
8299 {
8300 struct GeneratedVisitor;
8301
8302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8303 type Value = GeneratedField;
8304
8305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8306 write!(formatter, "expected one of: {:?}", &FIELDS)
8307 }
8308
8309 #[allow(unused_variables)]
8310 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8311 where
8312 E: serde::de::Error,
8313 {
8314 match value {
8315 "states" => Ok(GeneratedField::States),
8316 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8317 }
8318 }
8319 }
8320 deserializer.deserialize_identifier(GeneratedVisitor)
8321 }
8322 }
8323 struct GeneratedVisitor;
8324 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8325 type Value = ListActorStatesResponse;
8326
8327 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8328 formatter.write_str("struct meta.ListActorStatesResponse")
8329 }
8330
8331 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
8332 where
8333 V: serde::de::MapAccess<'de>,
8334 {
8335 let mut states__ = None;
8336 while let Some(k) = map_.next_key()? {
8337 match k {
8338 GeneratedField::States => {
8339 if states__.is_some() {
8340 return Err(serde::de::Error::duplicate_field("states"));
8341 }
8342 states__ = Some(map_.next_value()?);
8343 }
8344 }
8345 }
8346 Ok(ListActorStatesResponse {
8347 states: states__.unwrap_or_default(),
8348 })
8349 }
8350 }
8351 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
8352 }
8353}
8354impl serde::Serialize for list_actor_states_response::ActorState {
8355 #[allow(deprecated)]
8356 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8357 where
8358 S: serde::Serializer,
8359 {
8360 use serde::ser::SerializeStruct;
8361 let mut len = 0;
8362 if self.actor_id != 0 {
8363 len += 1;
8364 }
8365 if self.fragment_id != 0 {
8366 len += 1;
8367 }
8368 if self.state != 0 {
8369 len += 1;
8370 }
8371 if self.worker_id != 0 {
8372 len += 1;
8373 }
8374 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
8375 if self.actor_id != 0 {
8376 struct_ser.serialize_field("actorId", &self.actor_id)?;
8377 }
8378 if self.fragment_id != 0 {
8379 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8380 }
8381 if self.state != 0 {
8382 let v = table_fragments::actor_status::ActorState::try_from(self.state)
8383 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
8384 struct_ser.serialize_field("state", &v)?;
8385 }
8386 if self.worker_id != 0 {
8387 struct_ser.serialize_field("workerId", &self.worker_id)?;
8388 }
8389 struct_ser.end()
8390 }
8391}
8392impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
8393 #[allow(deprecated)]
8394 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8395 where
8396 D: serde::Deserializer<'de>,
8397 {
8398 const FIELDS: &[&str] = &[
8399 "actor_id",
8400 "actorId",
8401 "fragment_id",
8402 "fragmentId",
8403 "state",
8404 "worker_id",
8405 "workerId",
8406 ];
8407
8408 #[allow(clippy::enum_variant_names)]
8409 enum GeneratedField {
8410 ActorId,
8411 FragmentId,
8412 State,
8413 WorkerId,
8414 }
8415 impl<'de> serde::Deserialize<'de> for GeneratedField {
8416 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8417 where
8418 D: serde::Deserializer<'de>,
8419 {
8420 struct GeneratedVisitor;
8421
8422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8423 type Value = GeneratedField;
8424
8425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8426 write!(formatter, "expected one of: {:?}", &FIELDS)
8427 }
8428
8429 #[allow(unused_variables)]
8430 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8431 where
8432 E: serde::de::Error,
8433 {
8434 match value {
8435 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8436 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8437 "state" => Ok(GeneratedField::State),
8438 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
8439 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8440 }
8441 }
8442 }
8443 deserializer.deserialize_identifier(GeneratedVisitor)
8444 }
8445 }
8446 struct GeneratedVisitor;
8447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8448 type Value = list_actor_states_response::ActorState;
8449
8450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8451 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
8452 }
8453
8454 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
8455 where
8456 V: serde::de::MapAccess<'de>,
8457 {
8458 let mut actor_id__ = None;
8459 let mut fragment_id__ = None;
8460 let mut state__ = None;
8461 let mut worker_id__ = None;
8462 while let Some(k) = map_.next_key()? {
8463 match k {
8464 GeneratedField::ActorId => {
8465 if actor_id__.is_some() {
8466 return Err(serde::de::Error::duplicate_field("actorId"));
8467 }
8468 actor_id__ =
8469 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8470 ;
8471 }
8472 GeneratedField::FragmentId => {
8473 if fragment_id__.is_some() {
8474 return Err(serde::de::Error::duplicate_field("fragmentId"));
8475 }
8476 fragment_id__ =
8477 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8478 ;
8479 }
8480 GeneratedField::State => {
8481 if state__.is_some() {
8482 return Err(serde::de::Error::duplicate_field("state"));
8483 }
8484 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
8485 }
8486 GeneratedField::WorkerId => {
8487 if worker_id__.is_some() {
8488 return Err(serde::de::Error::duplicate_field("workerId"));
8489 }
8490 worker_id__ =
8491 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8492 ;
8493 }
8494 }
8495 }
8496 Ok(list_actor_states_response::ActorState {
8497 actor_id: actor_id__.unwrap_or_default(),
8498 fragment_id: fragment_id__.unwrap_or_default(),
8499 state: state__.unwrap_or_default(),
8500 worker_id: worker_id__.unwrap_or_default(),
8501 })
8502 }
8503 }
8504 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
8505 }
8506}
8507impl serde::Serialize for ListAllNodesRequest {
8508 #[allow(deprecated)]
8509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8510 where
8511 S: serde::Serializer,
8512 {
8513 use serde::ser::SerializeStruct;
8514 let mut len = 0;
8515 if self.worker_type.is_some() {
8516 len += 1;
8517 }
8518 if self.include_starting_nodes {
8519 len += 1;
8520 }
8521 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
8522 if let Some(v) = self.worker_type.as_ref() {
8523 let v = super::common::WorkerType::try_from(*v)
8524 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
8525 struct_ser.serialize_field("workerType", &v)?;
8526 }
8527 if self.include_starting_nodes {
8528 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
8529 }
8530 struct_ser.end()
8531 }
8532}
8533impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
8534 #[allow(deprecated)]
8535 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8536 where
8537 D: serde::Deserializer<'de>,
8538 {
8539 const FIELDS: &[&str] = &[
8540 "worker_type",
8541 "workerType",
8542 "include_starting_nodes",
8543 "includeStartingNodes",
8544 ];
8545
8546 #[allow(clippy::enum_variant_names)]
8547 enum GeneratedField {
8548 WorkerType,
8549 IncludeStartingNodes,
8550 }
8551 impl<'de> serde::Deserialize<'de> for GeneratedField {
8552 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8553 where
8554 D: serde::Deserializer<'de>,
8555 {
8556 struct GeneratedVisitor;
8557
8558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8559 type Value = GeneratedField;
8560
8561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8562 write!(formatter, "expected one of: {:?}", &FIELDS)
8563 }
8564
8565 #[allow(unused_variables)]
8566 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8567 where
8568 E: serde::de::Error,
8569 {
8570 match value {
8571 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
8572 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
8573 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8574 }
8575 }
8576 }
8577 deserializer.deserialize_identifier(GeneratedVisitor)
8578 }
8579 }
8580 struct GeneratedVisitor;
8581 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8582 type Value = ListAllNodesRequest;
8583
8584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8585 formatter.write_str("struct meta.ListAllNodesRequest")
8586 }
8587
8588 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
8589 where
8590 V: serde::de::MapAccess<'de>,
8591 {
8592 let mut worker_type__ = None;
8593 let mut include_starting_nodes__ = None;
8594 while let Some(k) = map_.next_key()? {
8595 match k {
8596 GeneratedField::WorkerType => {
8597 if worker_type__.is_some() {
8598 return Err(serde::de::Error::duplicate_field("workerType"));
8599 }
8600 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
8601 }
8602 GeneratedField::IncludeStartingNodes => {
8603 if include_starting_nodes__.is_some() {
8604 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
8605 }
8606 include_starting_nodes__ = Some(map_.next_value()?);
8607 }
8608 }
8609 }
8610 Ok(ListAllNodesRequest {
8611 worker_type: worker_type__,
8612 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
8613 })
8614 }
8615 }
8616 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
8617 }
8618}
8619impl serde::Serialize for ListAllNodesResponse {
8620 #[allow(deprecated)]
8621 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8622 where
8623 S: serde::Serializer,
8624 {
8625 use serde::ser::SerializeStruct;
8626 let mut len = 0;
8627 if self.status.is_some() {
8628 len += 1;
8629 }
8630 if !self.nodes.is_empty() {
8631 len += 1;
8632 }
8633 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
8634 if let Some(v) = self.status.as_ref() {
8635 struct_ser.serialize_field("status", v)?;
8636 }
8637 if !self.nodes.is_empty() {
8638 struct_ser.serialize_field("nodes", &self.nodes)?;
8639 }
8640 struct_ser.end()
8641 }
8642}
8643impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
8644 #[allow(deprecated)]
8645 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8646 where
8647 D: serde::Deserializer<'de>,
8648 {
8649 const FIELDS: &[&str] = &[
8650 "status",
8651 "nodes",
8652 ];
8653
8654 #[allow(clippy::enum_variant_names)]
8655 enum GeneratedField {
8656 Status,
8657 Nodes,
8658 }
8659 impl<'de> serde::Deserialize<'de> for GeneratedField {
8660 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8661 where
8662 D: serde::Deserializer<'de>,
8663 {
8664 struct GeneratedVisitor;
8665
8666 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8667 type Value = GeneratedField;
8668
8669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8670 write!(formatter, "expected one of: {:?}", &FIELDS)
8671 }
8672
8673 #[allow(unused_variables)]
8674 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8675 where
8676 E: serde::de::Error,
8677 {
8678 match value {
8679 "status" => Ok(GeneratedField::Status),
8680 "nodes" => Ok(GeneratedField::Nodes),
8681 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8682 }
8683 }
8684 }
8685 deserializer.deserialize_identifier(GeneratedVisitor)
8686 }
8687 }
8688 struct GeneratedVisitor;
8689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8690 type Value = ListAllNodesResponse;
8691
8692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8693 formatter.write_str("struct meta.ListAllNodesResponse")
8694 }
8695
8696 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
8697 where
8698 V: serde::de::MapAccess<'de>,
8699 {
8700 let mut status__ = None;
8701 let mut nodes__ = None;
8702 while let Some(k) = map_.next_key()? {
8703 match k {
8704 GeneratedField::Status => {
8705 if status__.is_some() {
8706 return Err(serde::de::Error::duplicate_field("status"));
8707 }
8708 status__ = map_.next_value()?;
8709 }
8710 GeneratedField::Nodes => {
8711 if nodes__.is_some() {
8712 return Err(serde::de::Error::duplicate_field("nodes"));
8713 }
8714 nodes__ = Some(map_.next_value()?);
8715 }
8716 }
8717 }
8718 Ok(ListAllNodesResponse {
8719 status: status__,
8720 nodes: nodes__.unwrap_or_default(),
8721 })
8722 }
8723 }
8724 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
8725 }
8726}
8727impl serde::Serialize for ListCdcProgressRequest {
8728 #[allow(deprecated)]
8729 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8730 where
8731 S: serde::Serializer,
8732 {
8733 use serde::ser::SerializeStruct;
8734 let len = 0;
8735 let struct_ser = serializer.serialize_struct("meta.ListCdcProgressRequest", len)?;
8736 struct_ser.end()
8737 }
8738}
8739impl<'de> serde::Deserialize<'de> for ListCdcProgressRequest {
8740 #[allow(deprecated)]
8741 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8742 where
8743 D: serde::Deserializer<'de>,
8744 {
8745 const FIELDS: &[&str] = &[
8746 ];
8747
8748 #[allow(clippy::enum_variant_names)]
8749 enum GeneratedField {
8750 }
8751 impl<'de> serde::Deserialize<'de> for GeneratedField {
8752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8753 where
8754 D: serde::Deserializer<'de>,
8755 {
8756 struct GeneratedVisitor;
8757
8758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8759 type Value = GeneratedField;
8760
8761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8762 write!(formatter, "expected one of: {:?}", &FIELDS)
8763 }
8764
8765 #[allow(unused_variables)]
8766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8767 where
8768 E: serde::de::Error,
8769 {
8770 Err(serde::de::Error::unknown_field(value, FIELDS))
8771 }
8772 }
8773 deserializer.deserialize_identifier(GeneratedVisitor)
8774 }
8775 }
8776 struct GeneratedVisitor;
8777 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8778 type Value = ListCdcProgressRequest;
8779
8780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8781 formatter.write_str("struct meta.ListCdcProgressRequest")
8782 }
8783
8784 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressRequest, V::Error>
8785 where
8786 V: serde::de::MapAccess<'de>,
8787 {
8788 while map_.next_key::<GeneratedField>()?.is_some() {
8789 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8790 }
8791 Ok(ListCdcProgressRequest {
8792 })
8793 }
8794 }
8795 deserializer.deserialize_struct("meta.ListCdcProgressRequest", FIELDS, GeneratedVisitor)
8796 }
8797}
8798impl serde::Serialize for ListCdcProgressResponse {
8799 #[allow(deprecated)]
8800 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8801 where
8802 S: serde::Serializer,
8803 {
8804 use serde::ser::SerializeStruct;
8805 let mut len = 0;
8806 if !self.cdc_progress.is_empty() {
8807 len += 1;
8808 }
8809 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse", len)?;
8810 if !self.cdc_progress.is_empty() {
8811 struct_ser.serialize_field("cdcProgress", &self.cdc_progress)?;
8812 }
8813 struct_ser.end()
8814 }
8815}
8816impl<'de> serde::Deserialize<'de> for ListCdcProgressResponse {
8817 #[allow(deprecated)]
8818 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8819 where
8820 D: serde::Deserializer<'de>,
8821 {
8822 const FIELDS: &[&str] = &[
8823 "cdc_progress",
8824 "cdcProgress",
8825 ];
8826
8827 #[allow(clippy::enum_variant_names)]
8828 enum GeneratedField {
8829 CdcProgress,
8830 }
8831 impl<'de> serde::Deserialize<'de> for GeneratedField {
8832 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8833 where
8834 D: serde::Deserializer<'de>,
8835 {
8836 struct GeneratedVisitor;
8837
8838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8839 type Value = GeneratedField;
8840
8841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8842 write!(formatter, "expected one of: {:?}", &FIELDS)
8843 }
8844
8845 #[allow(unused_variables)]
8846 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8847 where
8848 E: serde::de::Error,
8849 {
8850 match value {
8851 "cdcProgress" | "cdc_progress" => Ok(GeneratedField::CdcProgress),
8852 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8853 }
8854 }
8855 }
8856 deserializer.deserialize_identifier(GeneratedVisitor)
8857 }
8858 }
8859 struct GeneratedVisitor;
8860 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8861 type Value = ListCdcProgressResponse;
8862
8863 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8864 formatter.write_str("struct meta.ListCdcProgressResponse")
8865 }
8866
8867 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressResponse, V::Error>
8868 where
8869 V: serde::de::MapAccess<'de>,
8870 {
8871 let mut cdc_progress__ = None;
8872 while let Some(k) = map_.next_key()? {
8873 match k {
8874 GeneratedField::CdcProgress => {
8875 if cdc_progress__.is_some() {
8876 return Err(serde::de::Error::duplicate_field("cdcProgress"));
8877 }
8878 cdc_progress__ = Some(
8879 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8880 .into_iter().map(|(k,v)| (k.0, v)).collect()
8881 );
8882 }
8883 }
8884 }
8885 Ok(ListCdcProgressResponse {
8886 cdc_progress: cdc_progress__.unwrap_or_default(),
8887 })
8888 }
8889 }
8890 deserializer.deserialize_struct("meta.ListCdcProgressResponse", FIELDS, GeneratedVisitor)
8891 }
8892}
8893impl serde::Serialize for list_cdc_progress_response::CdcProgress {
8894 #[allow(deprecated)]
8895 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8896 where
8897 S: serde::Serializer,
8898 {
8899 use serde::ser::SerializeStruct;
8900 let mut len = 0;
8901 if self.split_total_count != 0 {
8902 len += 1;
8903 }
8904 if self.split_backfilled_count != 0 {
8905 len += 1;
8906 }
8907 if self.split_completed_count != 0 {
8908 len += 1;
8909 }
8910 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse.CdcProgress", len)?;
8911 if self.split_total_count != 0 {
8912 #[allow(clippy::needless_borrow)]
8913 #[allow(clippy::needless_borrows_for_generic_args)]
8914 struct_ser.serialize_field("splitTotalCount", ToString::to_string(&self.split_total_count).as_str())?;
8915 }
8916 if self.split_backfilled_count != 0 {
8917 #[allow(clippy::needless_borrow)]
8918 #[allow(clippy::needless_borrows_for_generic_args)]
8919 struct_ser.serialize_field("splitBackfilledCount", ToString::to_string(&self.split_backfilled_count).as_str())?;
8920 }
8921 if self.split_completed_count != 0 {
8922 #[allow(clippy::needless_borrow)]
8923 #[allow(clippy::needless_borrows_for_generic_args)]
8924 struct_ser.serialize_field("splitCompletedCount", ToString::to_string(&self.split_completed_count).as_str())?;
8925 }
8926 struct_ser.end()
8927 }
8928}
8929impl<'de> serde::Deserialize<'de> for list_cdc_progress_response::CdcProgress {
8930 #[allow(deprecated)]
8931 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8932 where
8933 D: serde::Deserializer<'de>,
8934 {
8935 const FIELDS: &[&str] = &[
8936 "split_total_count",
8937 "splitTotalCount",
8938 "split_backfilled_count",
8939 "splitBackfilledCount",
8940 "split_completed_count",
8941 "splitCompletedCount",
8942 ];
8943
8944 #[allow(clippy::enum_variant_names)]
8945 enum GeneratedField {
8946 SplitTotalCount,
8947 SplitBackfilledCount,
8948 SplitCompletedCount,
8949 }
8950 impl<'de> serde::Deserialize<'de> for GeneratedField {
8951 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8952 where
8953 D: serde::Deserializer<'de>,
8954 {
8955 struct GeneratedVisitor;
8956
8957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8958 type Value = GeneratedField;
8959
8960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8961 write!(formatter, "expected one of: {:?}", &FIELDS)
8962 }
8963
8964 #[allow(unused_variables)]
8965 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8966 where
8967 E: serde::de::Error,
8968 {
8969 match value {
8970 "splitTotalCount" | "split_total_count" => Ok(GeneratedField::SplitTotalCount),
8971 "splitBackfilledCount" | "split_backfilled_count" => Ok(GeneratedField::SplitBackfilledCount),
8972 "splitCompletedCount" | "split_completed_count" => Ok(GeneratedField::SplitCompletedCount),
8973 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8974 }
8975 }
8976 }
8977 deserializer.deserialize_identifier(GeneratedVisitor)
8978 }
8979 }
8980 struct GeneratedVisitor;
8981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8982 type Value = list_cdc_progress_response::CdcProgress;
8983
8984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8985 formatter.write_str("struct meta.ListCdcProgressResponse.CdcProgress")
8986 }
8987
8988 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_cdc_progress_response::CdcProgress, V::Error>
8989 where
8990 V: serde::de::MapAccess<'de>,
8991 {
8992 let mut split_total_count__ = None;
8993 let mut split_backfilled_count__ = None;
8994 let mut split_completed_count__ = None;
8995 while let Some(k) = map_.next_key()? {
8996 match k {
8997 GeneratedField::SplitTotalCount => {
8998 if split_total_count__.is_some() {
8999 return Err(serde::de::Error::duplicate_field("splitTotalCount"));
9000 }
9001 split_total_count__ =
9002 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9003 ;
9004 }
9005 GeneratedField::SplitBackfilledCount => {
9006 if split_backfilled_count__.is_some() {
9007 return Err(serde::de::Error::duplicate_field("splitBackfilledCount"));
9008 }
9009 split_backfilled_count__ =
9010 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9011 ;
9012 }
9013 GeneratedField::SplitCompletedCount => {
9014 if split_completed_count__.is_some() {
9015 return Err(serde::de::Error::duplicate_field("splitCompletedCount"));
9016 }
9017 split_completed_count__ =
9018 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9019 ;
9020 }
9021 }
9022 }
9023 Ok(list_cdc_progress_response::CdcProgress {
9024 split_total_count: split_total_count__.unwrap_or_default(),
9025 split_backfilled_count: split_backfilled_count__.unwrap_or_default(),
9026 split_completed_count: split_completed_count__.unwrap_or_default(),
9027 })
9028 }
9029 }
9030 deserializer.deserialize_struct("meta.ListCdcProgressResponse.CdcProgress", FIELDS, GeneratedVisitor)
9031 }
9032}
9033impl serde::Serialize for ListCreatingFragmentDistributionRequest {
9034 #[allow(deprecated)]
9035 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9036 where
9037 S: serde::Serializer,
9038 {
9039 use serde::ser::SerializeStruct;
9040 let len = 0;
9041 let struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
9042 struct_ser.end()
9043 }
9044}
9045impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
9046 #[allow(deprecated)]
9047 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9048 where
9049 D: serde::Deserializer<'de>,
9050 {
9051 const FIELDS: &[&str] = &[
9052 ];
9053
9054 #[allow(clippy::enum_variant_names)]
9055 enum GeneratedField {
9056 }
9057 impl<'de> serde::Deserialize<'de> for GeneratedField {
9058 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9059 where
9060 D: serde::Deserializer<'de>,
9061 {
9062 struct GeneratedVisitor;
9063
9064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9065 type Value = GeneratedField;
9066
9067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9068 write!(formatter, "expected one of: {:?}", &FIELDS)
9069 }
9070
9071 #[allow(unused_variables)]
9072 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9073 where
9074 E: serde::de::Error,
9075 {
9076 Err(serde::de::Error::unknown_field(value, FIELDS))
9077 }
9078 }
9079 deserializer.deserialize_identifier(GeneratedVisitor)
9080 }
9081 }
9082 struct GeneratedVisitor;
9083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9084 type Value = ListCreatingFragmentDistributionRequest;
9085
9086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9087 formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
9088 }
9089
9090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
9091 where
9092 V: serde::de::MapAccess<'de>,
9093 {
9094 while map_.next_key::<GeneratedField>()?.is_some() {
9095 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9096 }
9097 Ok(ListCreatingFragmentDistributionRequest {
9098 })
9099 }
9100 }
9101 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
9102 }
9103}
9104impl serde::Serialize for ListCreatingFragmentDistributionResponse {
9105 #[allow(deprecated)]
9106 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9107 where
9108 S: serde::Serializer,
9109 {
9110 use serde::ser::SerializeStruct;
9111 let mut len = 0;
9112 if !self.distributions.is_empty() {
9113 len += 1;
9114 }
9115 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
9116 if !self.distributions.is_empty() {
9117 struct_ser.serialize_field("distributions", &self.distributions)?;
9118 }
9119 struct_ser.end()
9120 }
9121}
9122impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
9123 #[allow(deprecated)]
9124 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9125 where
9126 D: serde::Deserializer<'de>,
9127 {
9128 const FIELDS: &[&str] = &[
9129 "distributions",
9130 ];
9131
9132 #[allow(clippy::enum_variant_names)]
9133 enum GeneratedField {
9134 Distributions,
9135 }
9136 impl<'de> serde::Deserialize<'de> for GeneratedField {
9137 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9138 where
9139 D: serde::Deserializer<'de>,
9140 {
9141 struct GeneratedVisitor;
9142
9143 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9144 type Value = GeneratedField;
9145
9146 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9147 write!(formatter, "expected one of: {:?}", &FIELDS)
9148 }
9149
9150 #[allow(unused_variables)]
9151 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9152 where
9153 E: serde::de::Error,
9154 {
9155 match value {
9156 "distributions" => Ok(GeneratedField::Distributions),
9157 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9158 }
9159 }
9160 }
9161 deserializer.deserialize_identifier(GeneratedVisitor)
9162 }
9163 }
9164 struct GeneratedVisitor;
9165 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9166 type Value = ListCreatingFragmentDistributionResponse;
9167
9168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9169 formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
9170 }
9171
9172 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
9173 where
9174 V: serde::de::MapAccess<'de>,
9175 {
9176 let mut distributions__ = None;
9177 while let Some(k) = map_.next_key()? {
9178 match k {
9179 GeneratedField::Distributions => {
9180 if distributions__.is_some() {
9181 return Err(serde::de::Error::duplicate_field("distributions"));
9182 }
9183 distributions__ = Some(map_.next_value()?);
9184 }
9185 }
9186 }
9187 Ok(ListCreatingFragmentDistributionResponse {
9188 distributions: distributions__.unwrap_or_default(),
9189 })
9190 }
9191 }
9192 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9193 }
9194}
9195impl serde::Serialize for ListEventLogRequest {
9196 #[allow(deprecated)]
9197 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9198 where
9199 S: serde::Serializer,
9200 {
9201 use serde::ser::SerializeStruct;
9202 let len = 0;
9203 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
9204 struct_ser.end()
9205 }
9206}
9207impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
9208 #[allow(deprecated)]
9209 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9210 where
9211 D: serde::Deserializer<'de>,
9212 {
9213 const FIELDS: &[&str] = &[
9214 ];
9215
9216 #[allow(clippy::enum_variant_names)]
9217 enum GeneratedField {
9218 }
9219 impl<'de> serde::Deserialize<'de> for GeneratedField {
9220 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9221 where
9222 D: serde::Deserializer<'de>,
9223 {
9224 struct GeneratedVisitor;
9225
9226 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9227 type Value = GeneratedField;
9228
9229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9230 write!(formatter, "expected one of: {:?}", &FIELDS)
9231 }
9232
9233 #[allow(unused_variables)]
9234 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9235 where
9236 E: serde::de::Error,
9237 {
9238 Err(serde::de::Error::unknown_field(value, FIELDS))
9239 }
9240 }
9241 deserializer.deserialize_identifier(GeneratedVisitor)
9242 }
9243 }
9244 struct GeneratedVisitor;
9245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9246 type Value = ListEventLogRequest;
9247
9248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9249 formatter.write_str("struct meta.ListEventLogRequest")
9250 }
9251
9252 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
9253 where
9254 V: serde::de::MapAccess<'de>,
9255 {
9256 while map_.next_key::<GeneratedField>()?.is_some() {
9257 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9258 }
9259 Ok(ListEventLogRequest {
9260 })
9261 }
9262 }
9263 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
9264 }
9265}
9266impl serde::Serialize for ListEventLogResponse {
9267 #[allow(deprecated)]
9268 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9269 where
9270 S: serde::Serializer,
9271 {
9272 use serde::ser::SerializeStruct;
9273 let mut len = 0;
9274 if !self.event_logs.is_empty() {
9275 len += 1;
9276 }
9277 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
9278 if !self.event_logs.is_empty() {
9279 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
9280 }
9281 struct_ser.end()
9282 }
9283}
9284impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
9285 #[allow(deprecated)]
9286 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9287 where
9288 D: serde::Deserializer<'de>,
9289 {
9290 const FIELDS: &[&str] = &[
9291 "event_logs",
9292 "eventLogs",
9293 ];
9294
9295 #[allow(clippy::enum_variant_names)]
9296 enum GeneratedField {
9297 EventLogs,
9298 }
9299 impl<'de> serde::Deserialize<'de> for GeneratedField {
9300 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9301 where
9302 D: serde::Deserializer<'de>,
9303 {
9304 struct GeneratedVisitor;
9305
9306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9307 type Value = GeneratedField;
9308
9309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9310 write!(formatter, "expected one of: {:?}", &FIELDS)
9311 }
9312
9313 #[allow(unused_variables)]
9314 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9315 where
9316 E: serde::de::Error,
9317 {
9318 match value {
9319 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
9320 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9321 }
9322 }
9323 }
9324 deserializer.deserialize_identifier(GeneratedVisitor)
9325 }
9326 }
9327 struct GeneratedVisitor;
9328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9329 type Value = ListEventLogResponse;
9330
9331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9332 formatter.write_str("struct meta.ListEventLogResponse")
9333 }
9334
9335 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
9336 where
9337 V: serde::de::MapAccess<'de>,
9338 {
9339 let mut event_logs__ = None;
9340 while let Some(k) = map_.next_key()? {
9341 match k {
9342 GeneratedField::EventLogs => {
9343 if event_logs__.is_some() {
9344 return Err(serde::de::Error::duplicate_field("eventLogs"));
9345 }
9346 event_logs__ = Some(map_.next_value()?);
9347 }
9348 }
9349 }
9350 Ok(ListEventLogResponse {
9351 event_logs: event_logs__.unwrap_or_default(),
9352 })
9353 }
9354 }
9355 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
9356 }
9357}
9358impl serde::Serialize for ListFragmentDistributionRequest {
9359 #[allow(deprecated)]
9360 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9361 where
9362 S: serde::Serializer,
9363 {
9364 use serde::ser::SerializeStruct;
9365 let len = 0;
9366 let struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
9367 struct_ser.end()
9368 }
9369}
9370impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
9371 #[allow(deprecated)]
9372 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9373 where
9374 D: serde::Deserializer<'de>,
9375 {
9376 const FIELDS: &[&str] = &[
9377 ];
9378
9379 #[allow(clippy::enum_variant_names)]
9380 enum GeneratedField {
9381 }
9382 impl<'de> serde::Deserialize<'de> for GeneratedField {
9383 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9384 where
9385 D: serde::Deserializer<'de>,
9386 {
9387 struct GeneratedVisitor;
9388
9389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9390 type Value = GeneratedField;
9391
9392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9393 write!(formatter, "expected one of: {:?}", &FIELDS)
9394 }
9395
9396 #[allow(unused_variables)]
9397 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9398 where
9399 E: serde::de::Error,
9400 {
9401 Err(serde::de::Error::unknown_field(value, FIELDS))
9402 }
9403 }
9404 deserializer.deserialize_identifier(GeneratedVisitor)
9405 }
9406 }
9407 struct GeneratedVisitor;
9408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9409 type Value = ListFragmentDistributionRequest;
9410
9411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9412 formatter.write_str("struct meta.ListFragmentDistributionRequest")
9413 }
9414
9415 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
9416 where
9417 V: serde::de::MapAccess<'de>,
9418 {
9419 while map_.next_key::<GeneratedField>()?.is_some() {
9420 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9421 }
9422 Ok(ListFragmentDistributionRequest {
9423 })
9424 }
9425 }
9426 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
9427 }
9428}
9429impl serde::Serialize for ListFragmentDistributionResponse {
9430 #[allow(deprecated)]
9431 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9432 where
9433 S: serde::Serializer,
9434 {
9435 use serde::ser::SerializeStruct;
9436 let mut len = 0;
9437 if !self.distributions.is_empty() {
9438 len += 1;
9439 }
9440 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
9441 if !self.distributions.is_empty() {
9442 struct_ser.serialize_field("distributions", &self.distributions)?;
9443 }
9444 struct_ser.end()
9445 }
9446}
9447impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
9448 #[allow(deprecated)]
9449 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9450 where
9451 D: serde::Deserializer<'de>,
9452 {
9453 const FIELDS: &[&str] = &[
9454 "distributions",
9455 ];
9456
9457 #[allow(clippy::enum_variant_names)]
9458 enum GeneratedField {
9459 Distributions,
9460 }
9461 impl<'de> serde::Deserialize<'de> for GeneratedField {
9462 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9463 where
9464 D: serde::Deserializer<'de>,
9465 {
9466 struct GeneratedVisitor;
9467
9468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9469 type Value = GeneratedField;
9470
9471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9472 write!(formatter, "expected one of: {:?}", &FIELDS)
9473 }
9474
9475 #[allow(unused_variables)]
9476 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9477 where
9478 E: serde::de::Error,
9479 {
9480 match value {
9481 "distributions" => Ok(GeneratedField::Distributions),
9482 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9483 }
9484 }
9485 }
9486 deserializer.deserialize_identifier(GeneratedVisitor)
9487 }
9488 }
9489 struct GeneratedVisitor;
9490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9491 type Value = ListFragmentDistributionResponse;
9492
9493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9494 formatter.write_str("struct meta.ListFragmentDistributionResponse")
9495 }
9496
9497 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
9498 where
9499 V: serde::de::MapAccess<'de>,
9500 {
9501 let mut distributions__ = None;
9502 while let Some(k) = map_.next_key()? {
9503 match k {
9504 GeneratedField::Distributions => {
9505 if distributions__.is_some() {
9506 return Err(serde::de::Error::duplicate_field("distributions"));
9507 }
9508 distributions__ = Some(map_.next_value()?);
9509 }
9510 }
9511 }
9512 Ok(ListFragmentDistributionResponse {
9513 distributions: distributions__.unwrap_or_default(),
9514 })
9515 }
9516 }
9517 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9518 }
9519}
9520impl serde::Serialize for ListIcebergTablesRequest {
9521 #[allow(deprecated)]
9522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9523 where
9524 S: serde::Serializer,
9525 {
9526 use serde::ser::SerializeStruct;
9527 let len = 0;
9528 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
9529 struct_ser.end()
9530 }
9531}
9532impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
9533 #[allow(deprecated)]
9534 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9535 where
9536 D: serde::Deserializer<'de>,
9537 {
9538 const FIELDS: &[&str] = &[
9539 ];
9540
9541 #[allow(clippy::enum_variant_names)]
9542 enum GeneratedField {
9543 }
9544 impl<'de> serde::Deserialize<'de> for GeneratedField {
9545 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9546 where
9547 D: serde::Deserializer<'de>,
9548 {
9549 struct GeneratedVisitor;
9550
9551 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9552 type Value = GeneratedField;
9553
9554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9555 write!(formatter, "expected one of: {:?}", &FIELDS)
9556 }
9557
9558 #[allow(unused_variables)]
9559 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9560 where
9561 E: serde::de::Error,
9562 {
9563 Err(serde::de::Error::unknown_field(value, FIELDS))
9564 }
9565 }
9566 deserializer.deserialize_identifier(GeneratedVisitor)
9567 }
9568 }
9569 struct GeneratedVisitor;
9570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9571 type Value = ListIcebergTablesRequest;
9572
9573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9574 formatter.write_str("struct meta.ListIcebergTablesRequest")
9575 }
9576
9577 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
9578 where
9579 V: serde::de::MapAccess<'de>,
9580 {
9581 while map_.next_key::<GeneratedField>()?.is_some() {
9582 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9583 }
9584 Ok(ListIcebergTablesRequest {
9585 })
9586 }
9587 }
9588 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
9589 }
9590}
9591impl serde::Serialize for ListIcebergTablesResponse {
9592 #[allow(deprecated)]
9593 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9594 where
9595 S: serde::Serializer,
9596 {
9597 use serde::ser::SerializeStruct;
9598 let mut len = 0;
9599 if !self.iceberg_tables.is_empty() {
9600 len += 1;
9601 }
9602 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
9603 if !self.iceberg_tables.is_empty() {
9604 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
9605 }
9606 struct_ser.end()
9607 }
9608}
9609impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
9610 #[allow(deprecated)]
9611 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9612 where
9613 D: serde::Deserializer<'de>,
9614 {
9615 const FIELDS: &[&str] = &[
9616 "iceberg_tables",
9617 "icebergTables",
9618 ];
9619
9620 #[allow(clippy::enum_variant_names)]
9621 enum GeneratedField {
9622 IcebergTables,
9623 }
9624 impl<'de> serde::Deserialize<'de> for GeneratedField {
9625 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9626 where
9627 D: serde::Deserializer<'de>,
9628 {
9629 struct GeneratedVisitor;
9630
9631 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9632 type Value = GeneratedField;
9633
9634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9635 write!(formatter, "expected one of: {:?}", &FIELDS)
9636 }
9637
9638 #[allow(unused_variables)]
9639 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9640 where
9641 E: serde::de::Error,
9642 {
9643 match value {
9644 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
9645 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9646 }
9647 }
9648 }
9649 deserializer.deserialize_identifier(GeneratedVisitor)
9650 }
9651 }
9652 struct GeneratedVisitor;
9653 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9654 type Value = ListIcebergTablesResponse;
9655
9656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9657 formatter.write_str("struct meta.ListIcebergTablesResponse")
9658 }
9659
9660 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
9661 where
9662 V: serde::de::MapAccess<'de>,
9663 {
9664 let mut iceberg_tables__ = None;
9665 while let Some(k) = map_.next_key()? {
9666 match k {
9667 GeneratedField::IcebergTables => {
9668 if iceberg_tables__.is_some() {
9669 return Err(serde::de::Error::duplicate_field("icebergTables"));
9670 }
9671 iceberg_tables__ = Some(map_.next_value()?);
9672 }
9673 }
9674 }
9675 Ok(ListIcebergTablesResponse {
9676 iceberg_tables: iceberg_tables__.unwrap_or_default(),
9677 })
9678 }
9679 }
9680 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
9681 }
9682}
9683impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
9684 #[allow(deprecated)]
9685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9686 where
9687 S: serde::Serializer,
9688 {
9689 use serde::ser::SerializeStruct;
9690 let mut len = 0;
9691 if !self.catalog_name.is_empty() {
9692 len += 1;
9693 }
9694 if !self.table_namespace.is_empty() {
9695 len += 1;
9696 }
9697 if !self.table_name.is_empty() {
9698 len += 1;
9699 }
9700 if self.metadata_location.is_some() {
9701 len += 1;
9702 }
9703 if self.previous_metadata_location.is_some() {
9704 len += 1;
9705 }
9706 if self.iceberg_type.is_some() {
9707 len += 1;
9708 }
9709 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
9710 if !self.catalog_name.is_empty() {
9711 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
9712 }
9713 if !self.table_namespace.is_empty() {
9714 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
9715 }
9716 if !self.table_name.is_empty() {
9717 struct_ser.serialize_field("tableName", &self.table_name)?;
9718 }
9719 if let Some(v) = self.metadata_location.as_ref() {
9720 struct_ser.serialize_field("metadataLocation", v)?;
9721 }
9722 if let Some(v) = self.previous_metadata_location.as_ref() {
9723 struct_ser.serialize_field("previousMetadataLocation", v)?;
9724 }
9725 if let Some(v) = self.iceberg_type.as_ref() {
9726 struct_ser.serialize_field("icebergType", v)?;
9727 }
9728 struct_ser.end()
9729 }
9730}
9731impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
9732 #[allow(deprecated)]
9733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9734 where
9735 D: serde::Deserializer<'de>,
9736 {
9737 const FIELDS: &[&str] = &[
9738 "catalog_name",
9739 "catalogName",
9740 "table_namespace",
9741 "tableNamespace",
9742 "table_name",
9743 "tableName",
9744 "metadata_location",
9745 "metadataLocation",
9746 "previous_metadata_location",
9747 "previousMetadataLocation",
9748 "iceberg_type",
9749 "icebergType",
9750 ];
9751
9752 #[allow(clippy::enum_variant_names)]
9753 enum GeneratedField {
9754 CatalogName,
9755 TableNamespace,
9756 TableName,
9757 MetadataLocation,
9758 PreviousMetadataLocation,
9759 IcebergType,
9760 }
9761 impl<'de> serde::Deserialize<'de> for GeneratedField {
9762 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9763 where
9764 D: serde::Deserializer<'de>,
9765 {
9766 struct GeneratedVisitor;
9767
9768 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9769 type Value = GeneratedField;
9770
9771 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9772 write!(formatter, "expected one of: {:?}", &FIELDS)
9773 }
9774
9775 #[allow(unused_variables)]
9776 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9777 where
9778 E: serde::de::Error,
9779 {
9780 match value {
9781 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
9782 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
9783 "tableName" | "table_name" => Ok(GeneratedField::TableName),
9784 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
9785 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
9786 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
9787 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9788 }
9789 }
9790 }
9791 deserializer.deserialize_identifier(GeneratedVisitor)
9792 }
9793 }
9794 struct GeneratedVisitor;
9795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9796 type Value = list_iceberg_tables_response::IcebergTable;
9797
9798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9799 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
9800 }
9801
9802 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
9803 where
9804 V: serde::de::MapAccess<'de>,
9805 {
9806 let mut catalog_name__ = None;
9807 let mut table_namespace__ = None;
9808 let mut table_name__ = None;
9809 let mut metadata_location__ = None;
9810 let mut previous_metadata_location__ = None;
9811 let mut iceberg_type__ = None;
9812 while let Some(k) = map_.next_key()? {
9813 match k {
9814 GeneratedField::CatalogName => {
9815 if catalog_name__.is_some() {
9816 return Err(serde::de::Error::duplicate_field("catalogName"));
9817 }
9818 catalog_name__ = Some(map_.next_value()?);
9819 }
9820 GeneratedField::TableNamespace => {
9821 if table_namespace__.is_some() {
9822 return Err(serde::de::Error::duplicate_field("tableNamespace"));
9823 }
9824 table_namespace__ = Some(map_.next_value()?);
9825 }
9826 GeneratedField::TableName => {
9827 if table_name__.is_some() {
9828 return Err(serde::de::Error::duplicate_field("tableName"));
9829 }
9830 table_name__ = Some(map_.next_value()?);
9831 }
9832 GeneratedField::MetadataLocation => {
9833 if metadata_location__.is_some() {
9834 return Err(serde::de::Error::duplicate_field("metadataLocation"));
9835 }
9836 metadata_location__ = map_.next_value()?;
9837 }
9838 GeneratedField::PreviousMetadataLocation => {
9839 if previous_metadata_location__.is_some() {
9840 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
9841 }
9842 previous_metadata_location__ = map_.next_value()?;
9843 }
9844 GeneratedField::IcebergType => {
9845 if iceberg_type__.is_some() {
9846 return Err(serde::de::Error::duplicate_field("icebergType"));
9847 }
9848 iceberg_type__ = map_.next_value()?;
9849 }
9850 }
9851 }
9852 Ok(list_iceberg_tables_response::IcebergTable {
9853 catalog_name: catalog_name__.unwrap_or_default(),
9854 table_namespace: table_namespace__.unwrap_or_default(),
9855 table_name: table_name__.unwrap_or_default(),
9856 metadata_location: metadata_location__,
9857 previous_metadata_location: previous_metadata_location__,
9858 iceberg_type: iceberg_type__,
9859 })
9860 }
9861 }
9862 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
9863 }
9864}
9865impl serde::Serialize for ListObjectDependenciesRequest {
9866 #[allow(deprecated)]
9867 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9868 where
9869 S: serde::Serializer,
9870 {
9871 use serde::ser::SerializeStruct;
9872 let len = 0;
9873 let struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesRequest", len)?;
9874 struct_ser.end()
9875 }
9876}
9877impl<'de> serde::Deserialize<'de> for ListObjectDependenciesRequest {
9878 #[allow(deprecated)]
9879 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9880 where
9881 D: serde::Deserializer<'de>,
9882 {
9883 const FIELDS: &[&str] = &[
9884 ];
9885
9886 #[allow(clippy::enum_variant_names)]
9887 enum GeneratedField {
9888 }
9889 impl<'de> serde::Deserialize<'de> for GeneratedField {
9890 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9891 where
9892 D: serde::Deserializer<'de>,
9893 {
9894 struct GeneratedVisitor;
9895
9896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9897 type Value = GeneratedField;
9898
9899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9900 write!(formatter, "expected one of: {:?}", &FIELDS)
9901 }
9902
9903 #[allow(unused_variables)]
9904 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9905 where
9906 E: serde::de::Error,
9907 {
9908 Err(serde::de::Error::unknown_field(value, FIELDS))
9909 }
9910 }
9911 deserializer.deserialize_identifier(GeneratedVisitor)
9912 }
9913 }
9914 struct GeneratedVisitor;
9915 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9916 type Value = ListObjectDependenciesRequest;
9917
9918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9919 formatter.write_str("struct meta.ListObjectDependenciesRequest")
9920 }
9921
9922 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesRequest, V::Error>
9923 where
9924 V: serde::de::MapAccess<'de>,
9925 {
9926 while map_.next_key::<GeneratedField>()?.is_some() {
9927 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9928 }
9929 Ok(ListObjectDependenciesRequest {
9930 })
9931 }
9932 }
9933 deserializer.deserialize_struct("meta.ListObjectDependenciesRequest", FIELDS, GeneratedVisitor)
9934 }
9935}
9936impl serde::Serialize for ListObjectDependenciesResponse {
9937 #[allow(deprecated)]
9938 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9939 where
9940 S: serde::Serializer,
9941 {
9942 use serde::ser::SerializeStruct;
9943 let mut len = 0;
9944 if !self.dependencies.is_empty() {
9945 len += 1;
9946 }
9947 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse", len)?;
9948 if !self.dependencies.is_empty() {
9949 struct_ser.serialize_field("dependencies", &self.dependencies)?;
9950 }
9951 struct_ser.end()
9952 }
9953}
9954impl<'de> serde::Deserialize<'de> for ListObjectDependenciesResponse {
9955 #[allow(deprecated)]
9956 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9957 where
9958 D: serde::Deserializer<'de>,
9959 {
9960 const FIELDS: &[&str] = &[
9961 "dependencies",
9962 ];
9963
9964 #[allow(clippy::enum_variant_names)]
9965 enum GeneratedField {
9966 Dependencies,
9967 }
9968 impl<'de> serde::Deserialize<'de> for GeneratedField {
9969 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9970 where
9971 D: serde::Deserializer<'de>,
9972 {
9973 struct GeneratedVisitor;
9974
9975 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9976 type Value = GeneratedField;
9977
9978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9979 write!(formatter, "expected one of: {:?}", &FIELDS)
9980 }
9981
9982 #[allow(unused_variables)]
9983 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9984 where
9985 E: serde::de::Error,
9986 {
9987 match value {
9988 "dependencies" => Ok(GeneratedField::Dependencies),
9989 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9990 }
9991 }
9992 }
9993 deserializer.deserialize_identifier(GeneratedVisitor)
9994 }
9995 }
9996 struct GeneratedVisitor;
9997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9998 type Value = ListObjectDependenciesResponse;
9999
10000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10001 formatter.write_str("struct meta.ListObjectDependenciesResponse")
10002 }
10003
10004 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesResponse, V::Error>
10005 where
10006 V: serde::de::MapAccess<'de>,
10007 {
10008 let mut dependencies__ = None;
10009 while let Some(k) = map_.next_key()? {
10010 match k {
10011 GeneratedField::Dependencies => {
10012 if dependencies__.is_some() {
10013 return Err(serde::de::Error::duplicate_field("dependencies"));
10014 }
10015 dependencies__ = Some(map_.next_value()?);
10016 }
10017 }
10018 }
10019 Ok(ListObjectDependenciesResponse {
10020 dependencies: dependencies__.unwrap_or_default(),
10021 })
10022 }
10023 }
10024 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse", FIELDS, GeneratedVisitor)
10025 }
10026}
10027impl serde::Serialize for list_object_dependencies_response::ObjectDependencies {
10028 #[allow(deprecated)]
10029 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10030 where
10031 S: serde::Serializer,
10032 {
10033 use serde::ser::SerializeStruct;
10034 let mut len = 0;
10035 if self.object_id != 0 {
10036 len += 1;
10037 }
10038 if self.referenced_object_id != 0 {
10039 len += 1;
10040 }
10041 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", len)?;
10042 if self.object_id != 0 {
10043 struct_ser.serialize_field("objectId", &self.object_id)?;
10044 }
10045 if self.referenced_object_id != 0 {
10046 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
10047 }
10048 struct_ser.end()
10049 }
10050}
10051impl<'de> serde::Deserialize<'de> for list_object_dependencies_response::ObjectDependencies {
10052 #[allow(deprecated)]
10053 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10054 where
10055 D: serde::Deserializer<'de>,
10056 {
10057 const FIELDS: &[&str] = &[
10058 "object_id",
10059 "objectId",
10060 "referenced_object_id",
10061 "referencedObjectId",
10062 ];
10063
10064 #[allow(clippy::enum_variant_names)]
10065 enum GeneratedField {
10066 ObjectId,
10067 ReferencedObjectId,
10068 }
10069 impl<'de> serde::Deserialize<'de> for GeneratedField {
10070 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10071 where
10072 D: serde::Deserializer<'de>,
10073 {
10074 struct GeneratedVisitor;
10075
10076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10077 type Value = GeneratedField;
10078
10079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10080 write!(formatter, "expected one of: {:?}", &FIELDS)
10081 }
10082
10083 #[allow(unused_variables)]
10084 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10085 where
10086 E: serde::de::Error,
10087 {
10088 match value {
10089 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
10090 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
10091 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10092 }
10093 }
10094 }
10095 deserializer.deserialize_identifier(GeneratedVisitor)
10096 }
10097 }
10098 struct GeneratedVisitor;
10099 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10100 type Value = list_object_dependencies_response::ObjectDependencies;
10101
10102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10103 formatter.write_str("struct meta.ListObjectDependenciesResponse.ObjectDependencies")
10104 }
10105
10106 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_object_dependencies_response::ObjectDependencies, V::Error>
10107 where
10108 V: serde::de::MapAccess<'de>,
10109 {
10110 let mut object_id__ = None;
10111 let mut referenced_object_id__ = None;
10112 while let Some(k) = map_.next_key()? {
10113 match k {
10114 GeneratedField::ObjectId => {
10115 if object_id__.is_some() {
10116 return Err(serde::de::Error::duplicate_field("objectId"));
10117 }
10118 object_id__ =
10119 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10120 ;
10121 }
10122 GeneratedField::ReferencedObjectId => {
10123 if referenced_object_id__.is_some() {
10124 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
10125 }
10126 referenced_object_id__ =
10127 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10128 ;
10129 }
10130 }
10131 }
10132 Ok(list_object_dependencies_response::ObjectDependencies {
10133 object_id: object_id__.unwrap_or_default(),
10134 referenced_object_id: referenced_object_id__.unwrap_or_default(),
10135 })
10136 }
10137 }
10138 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", FIELDS, GeneratedVisitor)
10139 }
10140}
10141impl serde::Serialize for ListRateLimitsRequest {
10142 #[allow(deprecated)]
10143 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10144 where
10145 S: serde::Serializer,
10146 {
10147 use serde::ser::SerializeStruct;
10148 let len = 0;
10149 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
10150 struct_ser.end()
10151 }
10152}
10153impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
10154 #[allow(deprecated)]
10155 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10156 where
10157 D: serde::Deserializer<'de>,
10158 {
10159 const FIELDS: &[&str] = &[
10160 ];
10161
10162 #[allow(clippy::enum_variant_names)]
10163 enum GeneratedField {
10164 }
10165 impl<'de> serde::Deserialize<'de> for GeneratedField {
10166 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10167 where
10168 D: serde::Deserializer<'de>,
10169 {
10170 struct GeneratedVisitor;
10171
10172 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10173 type Value = GeneratedField;
10174
10175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10176 write!(formatter, "expected one of: {:?}", &FIELDS)
10177 }
10178
10179 #[allow(unused_variables)]
10180 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10181 where
10182 E: serde::de::Error,
10183 {
10184 Err(serde::de::Error::unknown_field(value, FIELDS))
10185 }
10186 }
10187 deserializer.deserialize_identifier(GeneratedVisitor)
10188 }
10189 }
10190 struct GeneratedVisitor;
10191 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10192 type Value = ListRateLimitsRequest;
10193
10194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10195 formatter.write_str("struct meta.ListRateLimitsRequest")
10196 }
10197
10198 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
10199 where
10200 V: serde::de::MapAccess<'de>,
10201 {
10202 while map_.next_key::<GeneratedField>()?.is_some() {
10203 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10204 }
10205 Ok(ListRateLimitsRequest {
10206 })
10207 }
10208 }
10209 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
10210 }
10211}
10212impl serde::Serialize for ListRateLimitsResponse {
10213 #[allow(deprecated)]
10214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10215 where
10216 S: serde::Serializer,
10217 {
10218 use serde::ser::SerializeStruct;
10219 let mut len = 0;
10220 if !self.rate_limits.is_empty() {
10221 len += 1;
10222 }
10223 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
10224 if !self.rate_limits.is_empty() {
10225 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
10226 }
10227 struct_ser.end()
10228 }
10229}
10230impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
10231 #[allow(deprecated)]
10232 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10233 where
10234 D: serde::Deserializer<'de>,
10235 {
10236 const FIELDS: &[&str] = &[
10237 "rate_limits",
10238 "rateLimits",
10239 ];
10240
10241 #[allow(clippy::enum_variant_names)]
10242 enum GeneratedField {
10243 RateLimits,
10244 }
10245 impl<'de> serde::Deserialize<'de> for GeneratedField {
10246 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10247 where
10248 D: serde::Deserializer<'de>,
10249 {
10250 struct GeneratedVisitor;
10251
10252 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10253 type Value = GeneratedField;
10254
10255 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10256 write!(formatter, "expected one of: {:?}", &FIELDS)
10257 }
10258
10259 #[allow(unused_variables)]
10260 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10261 where
10262 E: serde::de::Error,
10263 {
10264 match value {
10265 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
10266 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10267 }
10268 }
10269 }
10270 deserializer.deserialize_identifier(GeneratedVisitor)
10271 }
10272 }
10273 struct GeneratedVisitor;
10274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10275 type Value = ListRateLimitsResponse;
10276
10277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10278 formatter.write_str("struct meta.ListRateLimitsResponse")
10279 }
10280
10281 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
10282 where
10283 V: serde::de::MapAccess<'de>,
10284 {
10285 let mut rate_limits__ = None;
10286 while let Some(k) = map_.next_key()? {
10287 match k {
10288 GeneratedField::RateLimits => {
10289 if rate_limits__.is_some() {
10290 return Err(serde::de::Error::duplicate_field("rateLimits"));
10291 }
10292 rate_limits__ = Some(map_.next_value()?);
10293 }
10294 }
10295 }
10296 Ok(ListRateLimitsResponse {
10297 rate_limits: rate_limits__.unwrap_or_default(),
10298 })
10299 }
10300 }
10301 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
10302 }
10303}
10304impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
10305 #[allow(deprecated)]
10306 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10307 where
10308 S: serde::Serializer,
10309 {
10310 use serde::ser::SerializeStruct;
10311 let mut len = 0;
10312 if self.fragment_id != 0 {
10313 len += 1;
10314 }
10315 if self.job_id != 0 {
10316 len += 1;
10317 }
10318 if self.fragment_type_mask != 0 {
10319 len += 1;
10320 }
10321 if self.rate_limit != 0 {
10322 len += 1;
10323 }
10324 if !self.node_name.is_empty() {
10325 len += 1;
10326 }
10327 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
10328 if self.fragment_id != 0 {
10329 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10330 }
10331 if self.job_id != 0 {
10332 struct_ser.serialize_field("jobId", &self.job_id)?;
10333 }
10334 if self.fragment_type_mask != 0 {
10335 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10336 }
10337 if self.rate_limit != 0 {
10338 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
10339 }
10340 if !self.node_name.is_empty() {
10341 struct_ser.serialize_field("nodeName", &self.node_name)?;
10342 }
10343 struct_ser.end()
10344 }
10345}
10346impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
10347 #[allow(deprecated)]
10348 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10349 where
10350 D: serde::Deserializer<'de>,
10351 {
10352 const FIELDS: &[&str] = &[
10353 "fragment_id",
10354 "fragmentId",
10355 "job_id",
10356 "jobId",
10357 "fragment_type_mask",
10358 "fragmentTypeMask",
10359 "rate_limit",
10360 "rateLimit",
10361 "node_name",
10362 "nodeName",
10363 ];
10364
10365 #[allow(clippy::enum_variant_names)]
10366 enum GeneratedField {
10367 FragmentId,
10368 JobId,
10369 FragmentTypeMask,
10370 RateLimit,
10371 NodeName,
10372 }
10373 impl<'de> serde::Deserialize<'de> for GeneratedField {
10374 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10375 where
10376 D: serde::Deserializer<'de>,
10377 {
10378 struct GeneratedVisitor;
10379
10380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10381 type Value = GeneratedField;
10382
10383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10384 write!(formatter, "expected one of: {:?}", &FIELDS)
10385 }
10386
10387 #[allow(unused_variables)]
10388 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10389 where
10390 E: serde::de::Error,
10391 {
10392 match value {
10393 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10394 "jobId" | "job_id" => Ok(GeneratedField::JobId),
10395 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
10396 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10397 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
10398 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10399 }
10400 }
10401 }
10402 deserializer.deserialize_identifier(GeneratedVisitor)
10403 }
10404 }
10405 struct GeneratedVisitor;
10406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10407 type Value = list_rate_limits_response::RateLimitInfo;
10408
10409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10410 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
10411 }
10412
10413 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
10414 where
10415 V: serde::de::MapAccess<'de>,
10416 {
10417 let mut fragment_id__ = None;
10418 let mut job_id__ = None;
10419 let mut fragment_type_mask__ = None;
10420 let mut rate_limit__ = None;
10421 let mut node_name__ = None;
10422 while let Some(k) = map_.next_key()? {
10423 match k {
10424 GeneratedField::FragmentId => {
10425 if fragment_id__.is_some() {
10426 return Err(serde::de::Error::duplicate_field("fragmentId"));
10427 }
10428 fragment_id__ =
10429 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10430 ;
10431 }
10432 GeneratedField::JobId => {
10433 if job_id__.is_some() {
10434 return Err(serde::de::Error::duplicate_field("jobId"));
10435 }
10436 job_id__ =
10437 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10438 ;
10439 }
10440 GeneratedField::FragmentTypeMask => {
10441 if fragment_type_mask__.is_some() {
10442 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
10443 }
10444 fragment_type_mask__ =
10445 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10446 ;
10447 }
10448 GeneratedField::RateLimit => {
10449 if rate_limit__.is_some() {
10450 return Err(serde::de::Error::duplicate_field("rateLimit"));
10451 }
10452 rate_limit__ =
10453 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10454 ;
10455 }
10456 GeneratedField::NodeName => {
10457 if node_name__.is_some() {
10458 return Err(serde::de::Error::duplicate_field("nodeName"));
10459 }
10460 node_name__ = Some(map_.next_value()?);
10461 }
10462 }
10463 }
10464 Ok(list_rate_limits_response::RateLimitInfo {
10465 fragment_id: fragment_id__.unwrap_or_default(),
10466 job_id: job_id__.unwrap_or_default(),
10467 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10468 rate_limit: rate_limit__.unwrap_or_default(),
10469 node_name: node_name__.unwrap_or_default(),
10470 })
10471 }
10472 }
10473 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
10474 }
10475}
10476impl serde::Serialize for ListStreamingJobStatesRequest {
10477 #[allow(deprecated)]
10478 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10479 where
10480 S: serde::Serializer,
10481 {
10482 use serde::ser::SerializeStruct;
10483 let len = 0;
10484 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
10485 struct_ser.end()
10486 }
10487}
10488impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
10489 #[allow(deprecated)]
10490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10491 where
10492 D: serde::Deserializer<'de>,
10493 {
10494 const FIELDS: &[&str] = &[
10495 ];
10496
10497 #[allow(clippy::enum_variant_names)]
10498 enum GeneratedField {
10499 }
10500 impl<'de> serde::Deserialize<'de> for GeneratedField {
10501 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10502 where
10503 D: serde::Deserializer<'de>,
10504 {
10505 struct GeneratedVisitor;
10506
10507 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10508 type Value = GeneratedField;
10509
10510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10511 write!(formatter, "expected one of: {:?}", &FIELDS)
10512 }
10513
10514 #[allow(unused_variables)]
10515 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10516 where
10517 E: serde::de::Error,
10518 {
10519 Err(serde::de::Error::unknown_field(value, FIELDS))
10520 }
10521 }
10522 deserializer.deserialize_identifier(GeneratedVisitor)
10523 }
10524 }
10525 struct GeneratedVisitor;
10526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10527 type Value = ListStreamingJobStatesRequest;
10528
10529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10530 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
10531 }
10532
10533 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
10534 where
10535 V: serde::de::MapAccess<'de>,
10536 {
10537 while map_.next_key::<GeneratedField>()?.is_some() {
10538 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10539 }
10540 Ok(ListStreamingJobStatesRequest {
10541 })
10542 }
10543 }
10544 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
10545 }
10546}
10547impl serde::Serialize for ListStreamingJobStatesResponse {
10548 #[allow(deprecated)]
10549 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10550 where
10551 S: serde::Serializer,
10552 {
10553 use serde::ser::SerializeStruct;
10554 let mut len = 0;
10555 if !self.states.is_empty() {
10556 len += 1;
10557 }
10558 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
10559 if !self.states.is_empty() {
10560 struct_ser.serialize_field("states", &self.states)?;
10561 }
10562 struct_ser.end()
10563 }
10564}
10565impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
10566 #[allow(deprecated)]
10567 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10568 where
10569 D: serde::Deserializer<'de>,
10570 {
10571 const FIELDS: &[&str] = &[
10572 "states",
10573 ];
10574
10575 #[allow(clippy::enum_variant_names)]
10576 enum GeneratedField {
10577 States,
10578 }
10579 impl<'de> serde::Deserialize<'de> for GeneratedField {
10580 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10581 where
10582 D: serde::Deserializer<'de>,
10583 {
10584 struct GeneratedVisitor;
10585
10586 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10587 type Value = GeneratedField;
10588
10589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10590 write!(formatter, "expected one of: {:?}", &FIELDS)
10591 }
10592
10593 #[allow(unused_variables)]
10594 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10595 where
10596 E: serde::de::Error,
10597 {
10598 match value {
10599 "states" => Ok(GeneratedField::States),
10600 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10601 }
10602 }
10603 }
10604 deserializer.deserialize_identifier(GeneratedVisitor)
10605 }
10606 }
10607 struct GeneratedVisitor;
10608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10609 type Value = ListStreamingJobStatesResponse;
10610
10611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10612 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
10613 }
10614
10615 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
10616 where
10617 V: serde::de::MapAccess<'de>,
10618 {
10619 let mut states__ = None;
10620 while let Some(k) = map_.next_key()? {
10621 match k {
10622 GeneratedField::States => {
10623 if states__.is_some() {
10624 return Err(serde::de::Error::duplicate_field("states"));
10625 }
10626 states__ = Some(map_.next_value()?);
10627 }
10628 }
10629 }
10630 Ok(ListStreamingJobStatesResponse {
10631 states: states__.unwrap_or_default(),
10632 })
10633 }
10634 }
10635 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
10636 }
10637}
10638impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
10639 #[allow(deprecated)]
10640 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10641 where
10642 S: serde::Serializer,
10643 {
10644 use serde::ser::SerializeStruct;
10645 let mut len = 0;
10646 if self.table_id != 0 {
10647 len += 1;
10648 }
10649 if self.state != 0 {
10650 len += 1;
10651 }
10652 if self.parallelism.is_some() {
10653 len += 1;
10654 }
10655 if self.max_parallelism != 0 {
10656 len += 1;
10657 }
10658 if !self.name.is_empty() {
10659 len += 1;
10660 }
10661 if !self.resource_group.is_empty() {
10662 len += 1;
10663 }
10664 if self.database_id != 0 {
10665 len += 1;
10666 }
10667 if self.schema_id != 0 {
10668 len += 1;
10669 }
10670 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
10671 if self.table_id != 0 {
10672 struct_ser.serialize_field("tableId", &self.table_id)?;
10673 }
10674 if self.state != 0 {
10675 let v = table_fragments::State::try_from(self.state)
10676 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
10677 struct_ser.serialize_field("state", &v)?;
10678 }
10679 if let Some(v) = self.parallelism.as_ref() {
10680 struct_ser.serialize_field("parallelism", v)?;
10681 }
10682 if self.max_parallelism != 0 {
10683 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10684 }
10685 if !self.name.is_empty() {
10686 struct_ser.serialize_field("name", &self.name)?;
10687 }
10688 if !self.resource_group.is_empty() {
10689 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
10690 }
10691 if self.database_id != 0 {
10692 struct_ser.serialize_field("databaseId", &self.database_id)?;
10693 }
10694 if self.schema_id != 0 {
10695 struct_ser.serialize_field("schemaId", &self.schema_id)?;
10696 }
10697 struct_ser.end()
10698 }
10699}
10700impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
10701 #[allow(deprecated)]
10702 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10703 where
10704 D: serde::Deserializer<'de>,
10705 {
10706 const FIELDS: &[&str] = &[
10707 "table_id",
10708 "tableId",
10709 "state",
10710 "parallelism",
10711 "max_parallelism",
10712 "maxParallelism",
10713 "name",
10714 "resource_group",
10715 "resourceGroup",
10716 "database_id",
10717 "databaseId",
10718 "schema_id",
10719 "schemaId",
10720 ];
10721
10722 #[allow(clippy::enum_variant_names)]
10723 enum GeneratedField {
10724 TableId,
10725 State,
10726 Parallelism,
10727 MaxParallelism,
10728 Name,
10729 ResourceGroup,
10730 DatabaseId,
10731 SchemaId,
10732 }
10733 impl<'de> serde::Deserialize<'de> for GeneratedField {
10734 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10735 where
10736 D: serde::Deserializer<'de>,
10737 {
10738 struct GeneratedVisitor;
10739
10740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10741 type Value = GeneratedField;
10742
10743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10744 write!(formatter, "expected one of: {:?}", &FIELDS)
10745 }
10746
10747 #[allow(unused_variables)]
10748 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10749 where
10750 E: serde::de::Error,
10751 {
10752 match value {
10753 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10754 "state" => Ok(GeneratedField::State),
10755 "parallelism" => Ok(GeneratedField::Parallelism),
10756 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10757 "name" => Ok(GeneratedField::Name),
10758 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
10759 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
10760 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
10761 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10762 }
10763 }
10764 }
10765 deserializer.deserialize_identifier(GeneratedVisitor)
10766 }
10767 }
10768 struct GeneratedVisitor;
10769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10770 type Value = list_streaming_job_states_response::StreamingJobState;
10771
10772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10773 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
10774 }
10775
10776 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
10777 where
10778 V: serde::de::MapAccess<'de>,
10779 {
10780 let mut table_id__ = None;
10781 let mut state__ = None;
10782 let mut parallelism__ = None;
10783 let mut max_parallelism__ = None;
10784 let mut name__ = None;
10785 let mut resource_group__ = None;
10786 let mut database_id__ = None;
10787 let mut schema_id__ = None;
10788 while let Some(k) = map_.next_key()? {
10789 match k {
10790 GeneratedField::TableId => {
10791 if table_id__.is_some() {
10792 return Err(serde::de::Error::duplicate_field("tableId"));
10793 }
10794 table_id__ =
10795 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10796 ;
10797 }
10798 GeneratedField::State => {
10799 if state__.is_some() {
10800 return Err(serde::de::Error::duplicate_field("state"));
10801 }
10802 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
10803 }
10804 GeneratedField::Parallelism => {
10805 if parallelism__.is_some() {
10806 return Err(serde::de::Error::duplicate_field("parallelism"));
10807 }
10808 parallelism__ = map_.next_value()?;
10809 }
10810 GeneratedField::MaxParallelism => {
10811 if max_parallelism__.is_some() {
10812 return Err(serde::de::Error::duplicate_field("maxParallelism"));
10813 }
10814 max_parallelism__ =
10815 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10816 ;
10817 }
10818 GeneratedField::Name => {
10819 if name__.is_some() {
10820 return Err(serde::de::Error::duplicate_field("name"));
10821 }
10822 name__ = Some(map_.next_value()?);
10823 }
10824 GeneratedField::ResourceGroup => {
10825 if resource_group__.is_some() {
10826 return Err(serde::de::Error::duplicate_field("resourceGroup"));
10827 }
10828 resource_group__ = Some(map_.next_value()?);
10829 }
10830 GeneratedField::DatabaseId => {
10831 if database_id__.is_some() {
10832 return Err(serde::de::Error::duplicate_field("databaseId"));
10833 }
10834 database_id__ =
10835 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10836 ;
10837 }
10838 GeneratedField::SchemaId => {
10839 if schema_id__.is_some() {
10840 return Err(serde::de::Error::duplicate_field("schemaId"));
10841 }
10842 schema_id__ =
10843 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10844 ;
10845 }
10846 }
10847 }
10848 Ok(list_streaming_job_states_response::StreamingJobState {
10849 table_id: table_id__.unwrap_or_default(),
10850 state: state__.unwrap_or_default(),
10851 parallelism: parallelism__,
10852 max_parallelism: max_parallelism__.unwrap_or_default(),
10853 name: name__.unwrap_or_default(),
10854 resource_group: resource_group__.unwrap_or_default(),
10855 database_id: database_id__.unwrap_or_default(),
10856 schema_id: schema_id__.unwrap_or_default(),
10857 })
10858 }
10859 }
10860 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
10861 }
10862}
10863impl serde::Serialize for ListTableFragmentsRequest {
10864 #[allow(deprecated)]
10865 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10866 where
10867 S: serde::Serializer,
10868 {
10869 use serde::ser::SerializeStruct;
10870 let mut len = 0;
10871 if !self.table_ids.is_empty() {
10872 len += 1;
10873 }
10874 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
10875 if !self.table_ids.is_empty() {
10876 struct_ser.serialize_field("tableIds", &self.table_ids)?;
10877 }
10878 struct_ser.end()
10879 }
10880}
10881impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
10882 #[allow(deprecated)]
10883 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10884 where
10885 D: serde::Deserializer<'de>,
10886 {
10887 const FIELDS: &[&str] = &[
10888 "table_ids",
10889 "tableIds",
10890 ];
10891
10892 #[allow(clippy::enum_variant_names)]
10893 enum GeneratedField {
10894 TableIds,
10895 }
10896 impl<'de> serde::Deserialize<'de> for GeneratedField {
10897 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10898 where
10899 D: serde::Deserializer<'de>,
10900 {
10901 struct GeneratedVisitor;
10902
10903 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10904 type Value = GeneratedField;
10905
10906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10907 write!(formatter, "expected one of: {:?}", &FIELDS)
10908 }
10909
10910 #[allow(unused_variables)]
10911 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10912 where
10913 E: serde::de::Error,
10914 {
10915 match value {
10916 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10917 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10918 }
10919 }
10920 }
10921 deserializer.deserialize_identifier(GeneratedVisitor)
10922 }
10923 }
10924 struct GeneratedVisitor;
10925 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10926 type Value = ListTableFragmentsRequest;
10927
10928 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10929 formatter.write_str("struct meta.ListTableFragmentsRequest")
10930 }
10931
10932 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
10933 where
10934 V: serde::de::MapAccess<'de>,
10935 {
10936 let mut table_ids__ = None;
10937 while let Some(k) = map_.next_key()? {
10938 match k {
10939 GeneratedField::TableIds => {
10940 if table_ids__.is_some() {
10941 return Err(serde::de::Error::duplicate_field("tableIds"));
10942 }
10943 table_ids__ =
10944 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10945 .into_iter().map(|x| x.0).collect())
10946 ;
10947 }
10948 }
10949 }
10950 Ok(ListTableFragmentsRequest {
10951 table_ids: table_ids__.unwrap_or_default(),
10952 })
10953 }
10954 }
10955 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
10956 }
10957}
10958impl serde::Serialize for ListTableFragmentsResponse {
10959 #[allow(deprecated)]
10960 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10961 where
10962 S: serde::Serializer,
10963 {
10964 use serde::ser::SerializeStruct;
10965 let mut len = 0;
10966 if !self.table_fragments.is_empty() {
10967 len += 1;
10968 }
10969 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
10970 if !self.table_fragments.is_empty() {
10971 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
10972 }
10973 struct_ser.end()
10974 }
10975}
10976impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
10977 #[allow(deprecated)]
10978 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10979 where
10980 D: serde::Deserializer<'de>,
10981 {
10982 const FIELDS: &[&str] = &[
10983 "table_fragments",
10984 "tableFragments",
10985 ];
10986
10987 #[allow(clippy::enum_variant_names)]
10988 enum GeneratedField {
10989 TableFragments,
10990 }
10991 impl<'de> serde::Deserialize<'de> for GeneratedField {
10992 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10993 where
10994 D: serde::Deserializer<'de>,
10995 {
10996 struct GeneratedVisitor;
10997
10998 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10999 type Value = GeneratedField;
11000
11001 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11002 write!(formatter, "expected one of: {:?}", &FIELDS)
11003 }
11004
11005 #[allow(unused_variables)]
11006 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11007 where
11008 E: serde::de::Error,
11009 {
11010 match value {
11011 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
11012 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11013 }
11014 }
11015 }
11016 deserializer.deserialize_identifier(GeneratedVisitor)
11017 }
11018 }
11019 struct GeneratedVisitor;
11020 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11021 type Value = ListTableFragmentsResponse;
11022
11023 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11024 formatter.write_str("struct meta.ListTableFragmentsResponse")
11025 }
11026
11027 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
11028 where
11029 V: serde::de::MapAccess<'de>,
11030 {
11031 let mut table_fragments__ = None;
11032 while let Some(k) = map_.next_key()? {
11033 match k {
11034 GeneratedField::TableFragments => {
11035 if table_fragments__.is_some() {
11036 return Err(serde::de::Error::duplicate_field("tableFragments"));
11037 }
11038 table_fragments__ = Some(
11039 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11040 .into_iter().map(|(k,v)| (k.0, v)).collect()
11041 );
11042 }
11043 }
11044 }
11045 Ok(ListTableFragmentsResponse {
11046 table_fragments: table_fragments__.unwrap_or_default(),
11047 })
11048 }
11049 }
11050 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
11051 }
11052}
11053impl serde::Serialize for list_table_fragments_response::ActorInfo {
11054 #[allow(deprecated)]
11055 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11056 where
11057 S: serde::Serializer,
11058 {
11059 use serde::ser::SerializeStruct;
11060 let mut len = 0;
11061 if self.id != 0 {
11062 len += 1;
11063 }
11064 if self.node.is_some() {
11065 len += 1;
11066 }
11067 if !self.dispatcher.is_empty() {
11068 len += 1;
11069 }
11070 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
11071 if self.id != 0 {
11072 struct_ser.serialize_field("id", &self.id)?;
11073 }
11074 if let Some(v) = self.node.as_ref() {
11075 struct_ser.serialize_field("node", v)?;
11076 }
11077 if !self.dispatcher.is_empty() {
11078 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
11079 }
11080 struct_ser.end()
11081 }
11082}
11083impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
11084 #[allow(deprecated)]
11085 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11086 where
11087 D: serde::Deserializer<'de>,
11088 {
11089 const FIELDS: &[&str] = &[
11090 "id",
11091 "node",
11092 "dispatcher",
11093 ];
11094
11095 #[allow(clippy::enum_variant_names)]
11096 enum GeneratedField {
11097 Id,
11098 Node,
11099 Dispatcher,
11100 }
11101 impl<'de> serde::Deserialize<'de> for GeneratedField {
11102 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11103 where
11104 D: serde::Deserializer<'de>,
11105 {
11106 struct GeneratedVisitor;
11107
11108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11109 type Value = GeneratedField;
11110
11111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11112 write!(formatter, "expected one of: {:?}", &FIELDS)
11113 }
11114
11115 #[allow(unused_variables)]
11116 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11117 where
11118 E: serde::de::Error,
11119 {
11120 match value {
11121 "id" => Ok(GeneratedField::Id),
11122 "node" => Ok(GeneratedField::Node),
11123 "dispatcher" => Ok(GeneratedField::Dispatcher),
11124 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11125 }
11126 }
11127 }
11128 deserializer.deserialize_identifier(GeneratedVisitor)
11129 }
11130 }
11131 struct GeneratedVisitor;
11132 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11133 type Value = list_table_fragments_response::ActorInfo;
11134
11135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11136 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
11137 }
11138
11139 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
11140 where
11141 V: serde::de::MapAccess<'de>,
11142 {
11143 let mut id__ = None;
11144 let mut node__ = None;
11145 let mut dispatcher__ = None;
11146 while let Some(k) = map_.next_key()? {
11147 match k {
11148 GeneratedField::Id => {
11149 if id__.is_some() {
11150 return Err(serde::de::Error::duplicate_field("id"));
11151 }
11152 id__ =
11153 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11154 ;
11155 }
11156 GeneratedField::Node => {
11157 if node__.is_some() {
11158 return Err(serde::de::Error::duplicate_field("node"));
11159 }
11160 node__ = map_.next_value()?;
11161 }
11162 GeneratedField::Dispatcher => {
11163 if dispatcher__.is_some() {
11164 return Err(serde::de::Error::duplicate_field("dispatcher"));
11165 }
11166 dispatcher__ = Some(map_.next_value()?);
11167 }
11168 }
11169 }
11170 Ok(list_table_fragments_response::ActorInfo {
11171 id: id__.unwrap_or_default(),
11172 node: node__,
11173 dispatcher: dispatcher__.unwrap_or_default(),
11174 })
11175 }
11176 }
11177 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
11178 }
11179}
11180impl serde::Serialize for list_table_fragments_response::FragmentInfo {
11181 #[allow(deprecated)]
11182 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11183 where
11184 S: serde::Serializer,
11185 {
11186 use serde::ser::SerializeStruct;
11187 let mut len = 0;
11188 if self.id != 0 {
11189 len += 1;
11190 }
11191 if !self.actors.is_empty() {
11192 len += 1;
11193 }
11194 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
11195 if self.id != 0 {
11196 struct_ser.serialize_field("id", &self.id)?;
11197 }
11198 if !self.actors.is_empty() {
11199 struct_ser.serialize_field("actors", &self.actors)?;
11200 }
11201 struct_ser.end()
11202 }
11203}
11204impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
11205 #[allow(deprecated)]
11206 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11207 where
11208 D: serde::Deserializer<'de>,
11209 {
11210 const FIELDS: &[&str] = &[
11211 "id",
11212 "actors",
11213 ];
11214
11215 #[allow(clippy::enum_variant_names)]
11216 enum GeneratedField {
11217 Id,
11218 Actors,
11219 }
11220 impl<'de> serde::Deserialize<'de> for GeneratedField {
11221 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11222 where
11223 D: serde::Deserializer<'de>,
11224 {
11225 struct GeneratedVisitor;
11226
11227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11228 type Value = GeneratedField;
11229
11230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11231 write!(formatter, "expected one of: {:?}", &FIELDS)
11232 }
11233
11234 #[allow(unused_variables)]
11235 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11236 where
11237 E: serde::de::Error,
11238 {
11239 match value {
11240 "id" => Ok(GeneratedField::Id),
11241 "actors" => Ok(GeneratedField::Actors),
11242 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11243 }
11244 }
11245 }
11246 deserializer.deserialize_identifier(GeneratedVisitor)
11247 }
11248 }
11249 struct GeneratedVisitor;
11250 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11251 type Value = list_table_fragments_response::FragmentInfo;
11252
11253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11254 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
11255 }
11256
11257 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
11258 where
11259 V: serde::de::MapAccess<'de>,
11260 {
11261 let mut id__ = None;
11262 let mut actors__ = None;
11263 while let Some(k) = map_.next_key()? {
11264 match k {
11265 GeneratedField::Id => {
11266 if id__.is_some() {
11267 return Err(serde::de::Error::duplicate_field("id"));
11268 }
11269 id__ =
11270 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11271 ;
11272 }
11273 GeneratedField::Actors => {
11274 if actors__.is_some() {
11275 return Err(serde::de::Error::duplicate_field("actors"));
11276 }
11277 actors__ = Some(map_.next_value()?);
11278 }
11279 }
11280 }
11281 Ok(list_table_fragments_response::FragmentInfo {
11282 id: id__.unwrap_or_default(),
11283 actors: actors__.unwrap_or_default(),
11284 })
11285 }
11286 }
11287 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
11288 }
11289}
11290impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
11291 #[allow(deprecated)]
11292 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11293 where
11294 S: serde::Serializer,
11295 {
11296 use serde::ser::SerializeStruct;
11297 let mut len = 0;
11298 if !self.fragments.is_empty() {
11299 len += 1;
11300 }
11301 if self.ctx.is_some() {
11302 len += 1;
11303 }
11304 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
11305 if !self.fragments.is_empty() {
11306 struct_ser.serialize_field("fragments", &self.fragments)?;
11307 }
11308 if let Some(v) = self.ctx.as_ref() {
11309 struct_ser.serialize_field("ctx", v)?;
11310 }
11311 struct_ser.end()
11312 }
11313}
11314impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
11315 #[allow(deprecated)]
11316 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11317 where
11318 D: serde::Deserializer<'de>,
11319 {
11320 const FIELDS: &[&str] = &[
11321 "fragments",
11322 "ctx",
11323 ];
11324
11325 #[allow(clippy::enum_variant_names)]
11326 enum GeneratedField {
11327 Fragments,
11328 Ctx,
11329 }
11330 impl<'de> serde::Deserialize<'de> for GeneratedField {
11331 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11332 where
11333 D: serde::Deserializer<'de>,
11334 {
11335 struct GeneratedVisitor;
11336
11337 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11338 type Value = GeneratedField;
11339
11340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11341 write!(formatter, "expected one of: {:?}", &FIELDS)
11342 }
11343
11344 #[allow(unused_variables)]
11345 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11346 where
11347 E: serde::de::Error,
11348 {
11349 match value {
11350 "fragments" => Ok(GeneratedField::Fragments),
11351 "ctx" => Ok(GeneratedField::Ctx),
11352 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11353 }
11354 }
11355 }
11356 deserializer.deserialize_identifier(GeneratedVisitor)
11357 }
11358 }
11359 struct GeneratedVisitor;
11360 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11361 type Value = list_table_fragments_response::TableFragmentInfo;
11362
11363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11364 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
11365 }
11366
11367 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
11368 where
11369 V: serde::de::MapAccess<'de>,
11370 {
11371 let mut fragments__ = None;
11372 let mut ctx__ = None;
11373 while let Some(k) = map_.next_key()? {
11374 match k {
11375 GeneratedField::Fragments => {
11376 if fragments__.is_some() {
11377 return Err(serde::de::Error::duplicate_field("fragments"));
11378 }
11379 fragments__ = Some(map_.next_value()?);
11380 }
11381 GeneratedField::Ctx => {
11382 if ctx__.is_some() {
11383 return Err(serde::de::Error::duplicate_field("ctx"));
11384 }
11385 ctx__ = map_.next_value()?;
11386 }
11387 }
11388 }
11389 Ok(list_table_fragments_response::TableFragmentInfo {
11390 fragments: fragments__.unwrap_or_default(),
11391 ctx: ctx__,
11392 })
11393 }
11394 }
11395 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
11396 }
11397}
11398impl serde::Serialize for MembersRequest {
11399 #[allow(deprecated)]
11400 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11401 where
11402 S: serde::Serializer,
11403 {
11404 use serde::ser::SerializeStruct;
11405 let len = 0;
11406 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
11407 struct_ser.end()
11408 }
11409}
11410impl<'de> serde::Deserialize<'de> for MembersRequest {
11411 #[allow(deprecated)]
11412 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11413 where
11414 D: serde::Deserializer<'de>,
11415 {
11416 const FIELDS: &[&str] = &[
11417 ];
11418
11419 #[allow(clippy::enum_variant_names)]
11420 enum GeneratedField {
11421 }
11422 impl<'de> serde::Deserialize<'de> for GeneratedField {
11423 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11424 where
11425 D: serde::Deserializer<'de>,
11426 {
11427 struct GeneratedVisitor;
11428
11429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11430 type Value = GeneratedField;
11431
11432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11433 write!(formatter, "expected one of: {:?}", &FIELDS)
11434 }
11435
11436 #[allow(unused_variables)]
11437 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11438 where
11439 E: serde::de::Error,
11440 {
11441 Err(serde::de::Error::unknown_field(value, FIELDS))
11442 }
11443 }
11444 deserializer.deserialize_identifier(GeneratedVisitor)
11445 }
11446 }
11447 struct GeneratedVisitor;
11448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11449 type Value = MembersRequest;
11450
11451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11452 formatter.write_str("struct meta.MembersRequest")
11453 }
11454
11455 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
11456 where
11457 V: serde::de::MapAccess<'de>,
11458 {
11459 while map_.next_key::<GeneratedField>()?.is_some() {
11460 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11461 }
11462 Ok(MembersRequest {
11463 })
11464 }
11465 }
11466 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
11467 }
11468}
11469impl serde::Serialize for MembersResponse {
11470 #[allow(deprecated)]
11471 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11472 where
11473 S: serde::Serializer,
11474 {
11475 use serde::ser::SerializeStruct;
11476 let mut len = 0;
11477 if !self.members.is_empty() {
11478 len += 1;
11479 }
11480 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
11481 if !self.members.is_empty() {
11482 struct_ser.serialize_field("members", &self.members)?;
11483 }
11484 struct_ser.end()
11485 }
11486}
11487impl<'de> serde::Deserialize<'de> for MembersResponse {
11488 #[allow(deprecated)]
11489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11490 where
11491 D: serde::Deserializer<'de>,
11492 {
11493 const FIELDS: &[&str] = &[
11494 "members",
11495 ];
11496
11497 #[allow(clippy::enum_variant_names)]
11498 enum GeneratedField {
11499 Members,
11500 }
11501 impl<'de> serde::Deserialize<'de> for GeneratedField {
11502 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11503 where
11504 D: serde::Deserializer<'de>,
11505 {
11506 struct GeneratedVisitor;
11507
11508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11509 type Value = GeneratedField;
11510
11511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11512 write!(formatter, "expected one of: {:?}", &FIELDS)
11513 }
11514
11515 #[allow(unused_variables)]
11516 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11517 where
11518 E: serde::de::Error,
11519 {
11520 match value {
11521 "members" => Ok(GeneratedField::Members),
11522 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11523 }
11524 }
11525 }
11526 deserializer.deserialize_identifier(GeneratedVisitor)
11527 }
11528 }
11529 struct GeneratedVisitor;
11530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11531 type Value = MembersResponse;
11532
11533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11534 formatter.write_str("struct meta.MembersResponse")
11535 }
11536
11537 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
11538 where
11539 V: serde::de::MapAccess<'de>,
11540 {
11541 let mut members__ = None;
11542 while let Some(k) = map_.next_key()? {
11543 match k {
11544 GeneratedField::Members => {
11545 if members__.is_some() {
11546 return Err(serde::de::Error::duplicate_field("members"));
11547 }
11548 members__ = Some(map_.next_value()?);
11549 }
11550 }
11551 }
11552 Ok(MembersResponse {
11553 members: members__.unwrap_or_default(),
11554 })
11555 }
11556 }
11557 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
11558 }
11559}
11560impl serde::Serialize for MetaMember {
11561 #[allow(deprecated)]
11562 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11563 where
11564 S: serde::Serializer,
11565 {
11566 use serde::ser::SerializeStruct;
11567 let mut len = 0;
11568 if self.address.is_some() {
11569 len += 1;
11570 }
11571 if self.is_leader {
11572 len += 1;
11573 }
11574 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
11575 if let Some(v) = self.address.as_ref() {
11576 struct_ser.serialize_field("address", v)?;
11577 }
11578 if self.is_leader {
11579 struct_ser.serialize_field("isLeader", &self.is_leader)?;
11580 }
11581 struct_ser.end()
11582 }
11583}
11584impl<'de> serde::Deserialize<'de> for MetaMember {
11585 #[allow(deprecated)]
11586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11587 where
11588 D: serde::Deserializer<'de>,
11589 {
11590 const FIELDS: &[&str] = &[
11591 "address",
11592 "is_leader",
11593 "isLeader",
11594 ];
11595
11596 #[allow(clippy::enum_variant_names)]
11597 enum GeneratedField {
11598 Address,
11599 IsLeader,
11600 }
11601 impl<'de> serde::Deserialize<'de> for GeneratedField {
11602 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11603 where
11604 D: serde::Deserializer<'de>,
11605 {
11606 struct GeneratedVisitor;
11607
11608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11609 type Value = GeneratedField;
11610
11611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11612 write!(formatter, "expected one of: {:?}", &FIELDS)
11613 }
11614
11615 #[allow(unused_variables)]
11616 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11617 where
11618 E: serde::de::Error,
11619 {
11620 match value {
11621 "address" => Ok(GeneratedField::Address),
11622 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
11623 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11624 }
11625 }
11626 }
11627 deserializer.deserialize_identifier(GeneratedVisitor)
11628 }
11629 }
11630 struct GeneratedVisitor;
11631 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11632 type Value = MetaMember;
11633
11634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11635 formatter.write_str("struct meta.MetaMember")
11636 }
11637
11638 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
11639 where
11640 V: serde::de::MapAccess<'de>,
11641 {
11642 let mut address__ = None;
11643 let mut is_leader__ = None;
11644 while let Some(k) = map_.next_key()? {
11645 match k {
11646 GeneratedField::Address => {
11647 if address__.is_some() {
11648 return Err(serde::de::Error::duplicate_field("address"));
11649 }
11650 address__ = map_.next_value()?;
11651 }
11652 GeneratedField::IsLeader => {
11653 if is_leader__.is_some() {
11654 return Err(serde::de::Error::duplicate_field("isLeader"));
11655 }
11656 is_leader__ = Some(map_.next_value()?);
11657 }
11658 }
11659 }
11660 Ok(MetaMember {
11661 address: address__,
11662 is_leader: is_leader__.unwrap_or_default(),
11663 })
11664 }
11665 }
11666 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
11667 }
11668}
11669impl serde::Serialize for MetaSnapshot {
11670 #[allow(deprecated)]
11671 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11672 where
11673 S: serde::Serializer,
11674 {
11675 use serde::ser::SerializeStruct;
11676 let mut len = 0;
11677 if !self.databases.is_empty() {
11678 len += 1;
11679 }
11680 if !self.schemas.is_empty() {
11681 len += 1;
11682 }
11683 if !self.sources.is_empty() {
11684 len += 1;
11685 }
11686 if !self.sinks.is_empty() {
11687 len += 1;
11688 }
11689 if !self.tables.is_empty() {
11690 len += 1;
11691 }
11692 if !self.indexes.is_empty() {
11693 len += 1;
11694 }
11695 if !self.views.is_empty() {
11696 len += 1;
11697 }
11698 if !self.functions.is_empty() {
11699 len += 1;
11700 }
11701 if !self.connections.is_empty() {
11702 len += 1;
11703 }
11704 if !self.subscriptions.is_empty() {
11705 len += 1;
11706 }
11707 if !self.users.is_empty() {
11708 len += 1;
11709 }
11710 if self.session_params.is_some() {
11711 len += 1;
11712 }
11713 if !self.secrets.is_empty() {
11714 len += 1;
11715 }
11716 if self.compute_node_total_cpu_count != 0 {
11717 len += 1;
11718 }
11719 if !self.nodes.is_empty() {
11720 len += 1;
11721 }
11722 if self.hummock_version.is_some() {
11723 len += 1;
11724 }
11725 if self.meta_backup_manifest_id.is_some() {
11726 len += 1;
11727 }
11728 if self.hummock_write_limits.is_some() {
11729 len += 1;
11730 }
11731 if !self.streaming_worker_slot_mappings.is_empty() {
11732 len += 1;
11733 }
11734 if !self.serving_worker_slot_mappings.is_empty() {
11735 len += 1;
11736 }
11737 if self.version.is_some() {
11738 len += 1;
11739 }
11740 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
11741 if !self.databases.is_empty() {
11742 struct_ser.serialize_field("databases", &self.databases)?;
11743 }
11744 if !self.schemas.is_empty() {
11745 struct_ser.serialize_field("schemas", &self.schemas)?;
11746 }
11747 if !self.sources.is_empty() {
11748 struct_ser.serialize_field("sources", &self.sources)?;
11749 }
11750 if !self.sinks.is_empty() {
11751 struct_ser.serialize_field("sinks", &self.sinks)?;
11752 }
11753 if !self.tables.is_empty() {
11754 struct_ser.serialize_field("tables", &self.tables)?;
11755 }
11756 if !self.indexes.is_empty() {
11757 struct_ser.serialize_field("indexes", &self.indexes)?;
11758 }
11759 if !self.views.is_empty() {
11760 struct_ser.serialize_field("views", &self.views)?;
11761 }
11762 if !self.functions.is_empty() {
11763 struct_ser.serialize_field("functions", &self.functions)?;
11764 }
11765 if !self.connections.is_empty() {
11766 struct_ser.serialize_field("connections", &self.connections)?;
11767 }
11768 if !self.subscriptions.is_empty() {
11769 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
11770 }
11771 if !self.users.is_empty() {
11772 struct_ser.serialize_field("users", &self.users)?;
11773 }
11774 if let Some(v) = self.session_params.as_ref() {
11775 struct_ser.serialize_field("sessionParams", v)?;
11776 }
11777 if !self.secrets.is_empty() {
11778 struct_ser.serialize_field("secrets", &self.secrets)?;
11779 }
11780 if self.compute_node_total_cpu_count != 0 {
11781 #[allow(clippy::needless_borrow)]
11782 #[allow(clippy::needless_borrows_for_generic_args)]
11783 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&self.compute_node_total_cpu_count).as_str())?;
11784 }
11785 if !self.nodes.is_empty() {
11786 struct_ser.serialize_field("nodes", &self.nodes)?;
11787 }
11788 if let Some(v) = self.hummock_version.as_ref() {
11789 struct_ser.serialize_field("hummockVersion", v)?;
11790 }
11791 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
11792 struct_ser.serialize_field("metaBackupManifestId", v)?;
11793 }
11794 if let Some(v) = self.hummock_write_limits.as_ref() {
11795 struct_ser.serialize_field("hummockWriteLimits", v)?;
11796 }
11797 if !self.streaming_worker_slot_mappings.is_empty() {
11798 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
11799 }
11800 if !self.serving_worker_slot_mappings.is_empty() {
11801 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
11802 }
11803 if let Some(v) = self.version.as_ref() {
11804 struct_ser.serialize_field("version", v)?;
11805 }
11806 struct_ser.end()
11807 }
11808}
11809impl<'de> serde::Deserialize<'de> for MetaSnapshot {
11810 #[allow(deprecated)]
11811 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11812 where
11813 D: serde::Deserializer<'de>,
11814 {
11815 const FIELDS: &[&str] = &[
11816 "databases",
11817 "schemas",
11818 "sources",
11819 "sinks",
11820 "tables",
11821 "indexes",
11822 "views",
11823 "functions",
11824 "connections",
11825 "subscriptions",
11826 "users",
11827 "session_params",
11828 "sessionParams",
11829 "secrets",
11830 "compute_node_total_cpu_count",
11831 "computeNodeTotalCpuCount",
11832 "nodes",
11833 "hummock_version",
11834 "hummockVersion",
11835 "meta_backup_manifest_id",
11836 "metaBackupManifestId",
11837 "hummock_write_limits",
11838 "hummockWriteLimits",
11839 "streaming_worker_slot_mappings",
11840 "streamingWorkerSlotMappings",
11841 "serving_worker_slot_mappings",
11842 "servingWorkerSlotMappings",
11843 "version",
11844 ];
11845
11846 #[allow(clippy::enum_variant_names)]
11847 enum GeneratedField {
11848 Databases,
11849 Schemas,
11850 Sources,
11851 Sinks,
11852 Tables,
11853 Indexes,
11854 Views,
11855 Functions,
11856 Connections,
11857 Subscriptions,
11858 Users,
11859 SessionParams,
11860 Secrets,
11861 ComputeNodeTotalCpuCount,
11862 Nodes,
11863 HummockVersion,
11864 MetaBackupManifestId,
11865 HummockWriteLimits,
11866 StreamingWorkerSlotMappings,
11867 ServingWorkerSlotMappings,
11868 Version,
11869 }
11870 impl<'de> serde::Deserialize<'de> for GeneratedField {
11871 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11872 where
11873 D: serde::Deserializer<'de>,
11874 {
11875 struct GeneratedVisitor;
11876
11877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11878 type Value = GeneratedField;
11879
11880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11881 write!(formatter, "expected one of: {:?}", &FIELDS)
11882 }
11883
11884 #[allow(unused_variables)]
11885 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11886 where
11887 E: serde::de::Error,
11888 {
11889 match value {
11890 "databases" => Ok(GeneratedField::Databases),
11891 "schemas" => Ok(GeneratedField::Schemas),
11892 "sources" => Ok(GeneratedField::Sources),
11893 "sinks" => Ok(GeneratedField::Sinks),
11894 "tables" => Ok(GeneratedField::Tables),
11895 "indexes" => Ok(GeneratedField::Indexes),
11896 "views" => Ok(GeneratedField::Views),
11897 "functions" => Ok(GeneratedField::Functions),
11898 "connections" => Ok(GeneratedField::Connections),
11899 "subscriptions" => Ok(GeneratedField::Subscriptions),
11900 "users" => Ok(GeneratedField::Users),
11901 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
11902 "secrets" => Ok(GeneratedField::Secrets),
11903 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
11904 "nodes" => Ok(GeneratedField::Nodes),
11905 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
11906 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
11907 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
11908 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
11909 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
11910 "version" => Ok(GeneratedField::Version),
11911 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11912 }
11913 }
11914 }
11915 deserializer.deserialize_identifier(GeneratedVisitor)
11916 }
11917 }
11918 struct GeneratedVisitor;
11919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11920 type Value = MetaSnapshot;
11921
11922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11923 formatter.write_str("struct meta.MetaSnapshot")
11924 }
11925
11926 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
11927 where
11928 V: serde::de::MapAccess<'de>,
11929 {
11930 let mut databases__ = None;
11931 let mut schemas__ = None;
11932 let mut sources__ = None;
11933 let mut sinks__ = None;
11934 let mut tables__ = None;
11935 let mut indexes__ = None;
11936 let mut views__ = None;
11937 let mut functions__ = None;
11938 let mut connections__ = None;
11939 let mut subscriptions__ = None;
11940 let mut users__ = None;
11941 let mut session_params__ = None;
11942 let mut secrets__ = None;
11943 let mut compute_node_total_cpu_count__ = None;
11944 let mut nodes__ = None;
11945 let mut hummock_version__ = None;
11946 let mut meta_backup_manifest_id__ = None;
11947 let mut hummock_write_limits__ = None;
11948 let mut streaming_worker_slot_mappings__ = None;
11949 let mut serving_worker_slot_mappings__ = None;
11950 let mut version__ = None;
11951 while let Some(k) = map_.next_key()? {
11952 match k {
11953 GeneratedField::Databases => {
11954 if databases__.is_some() {
11955 return Err(serde::de::Error::duplicate_field("databases"));
11956 }
11957 databases__ = Some(map_.next_value()?);
11958 }
11959 GeneratedField::Schemas => {
11960 if schemas__.is_some() {
11961 return Err(serde::de::Error::duplicate_field("schemas"));
11962 }
11963 schemas__ = Some(map_.next_value()?);
11964 }
11965 GeneratedField::Sources => {
11966 if sources__.is_some() {
11967 return Err(serde::de::Error::duplicate_field("sources"));
11968 }
11969 sources__ = Some(map_.next_value()?);
11970 }
11971 GeneratedField::Sinks => {
11972 if sinks__.is_some() {
11973 return Err(serde::de::Error::duplicate_field("sinks"));
11974 }
11975 sinks__ = Some(map_.next_value()?);
11976 }
11977 GeneratedField::Tables => {
11978 if tables__.is_some() {
11979 return Err(serde::de::Error::duplicate_field("tables"));
11980 }
11981 tables__ = Some(map_.next_value()?);
11982 }
11983 GeneratedField::Indexes => {
11984 if indexes__.is_some() {
11985 return Err(serde::de::Error::duplicate_field("indexes"));
11986 }
11987 indexes__ = Some(map_.next_value()?);
11988 }
11989 GeneratedField::Views => {
11990 if views__.is_some() {
11991 return Err(serde::de::Error::duplicate_field("views"));
11992 }
11993 views__ = Some(map_.next_value()?);
11994 }
11995 GeneratedField::Functions => {
11996 if functions__.is_some() {
11997 return Err(serde::de::Error::duplicate_field("functions"));
11998 }
11999 functions__ = Some(map_.next_value()?);
12000 }
12001 GeneratedField::Connections => {
12002 if connections__.is_some() {
12003 return Err(serde::de::Error::duplicate_field("connections"));
12004 }
12005 connections__ = Some(map_.next_value()?);
12006 }
12007 GeneratedField::Subscriptions => {
12008 if subscriptions__.is_some() {
12009 return Err(serde::de::Error::duplicate_field("subscriptions"));
12010 }
12011 subscriptions__ = Some(map_.next_value()?);
12012 }
12013 GeneratedField::Users => {
12014 if users__.is_some() {
12015 return Err(serde::de::Error::duplicate_field("users"));
12016 }
12017 users__ = Some(map_.next_value()?);
12018 }
12019 GeneratedField::SessionParams => {
12020 if session_params__.is_some() {
12021 return Err(serde::de::Error::duplicate_field("sessionParams"));
12022 }
12023 session_params__ = map_.next_value()?;
12024 }
12025 GeneratedField::Secrets => {
12026 if secrets__.is_some() {
12027 return Err(serde::de::Error::duplicate_field("secrets"));
12028 }
12029 secrets__ = Some(map_.next_value()?);
12030 }
12031 GeneratedField::ComputeNodeTotalCpuCount => {
12032 if compute_node_total_cpu_count__.is_some() {
12033 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
12034 }
12035 compute_node_total_cpu_count__ =
12036 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12037 ;
12038 }
12039 GeneratedField::Nodes => {
12040 if nodes__.is_some() {
12041 return Err(serde::de::Error::duplicate_field("nodes"));
12042 }
12043 nodes__ = Some(map_.next_value()?);
12044 }
12045 GeneratedField::HummockVersion => {
12046 if hummock_version__.is_some() {
12047 return Err(serde::de::Error::duplicate_field("hummockVersion"));
12048 }
12049 hummock_version__ = map_.next_value()?;
12050 }
12051 GeneratedField::MetaBackupManifestId => {
12052 if meta_backup_manifest_id__.is_some() {
12053 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
12054 }
12055 meta_backup_manifest_id__ = map_.next_value()?;
12056 }
12057 GeneratedField::HummockWriteLimits => {
12058 if hummock_write_limits__.is_some() {
12059 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
12060 }
12061 hummock_write_limits__ = map_.next_value()?;
12062 }
12063 GeneratedField::StreamingWorkerSlotMappings => {
12064 if streaming_worker_slot_mappings__.is_some() {
12065 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
12066 }
12067 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
12068 }
12069 GeneratedField::ServingWorkerSlotMappings => {
12070 if serving_worker_slot_mappings__.is_some() {
12071 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
12072 }
12073 serving_worker_slot_mappings__ = Some(map_.next_value()?);
12074 }
12075 GeneratedField::Version => {
12076 if version__.is_some() {
12077 return Err(serde::de::Error::duplicate_field("version"));
12078 }
12079 version__ = map_.next_value()?;
12080 }
12081 }
12082 }
12083 Ok(MetaSnapshot {
12084 databases: databases__.unwrap_or_default(),
12085 schemas: schemas__.unwrap_or_default(),
12086 sources: sources__.unwrap_or_default(),
12087 sinks: sinks__.unwrap_or_default(),
12088 tables: tables__.unwrap_or_default(),
12089 indexes: indexes__.unwrap_or_default(),
12090 views: views__.unwrap_or_default(),
12091 functions: functions__.unwrap_or_default(),
12092 connections: connections__.unwrap_or_default(),
12093 subscriptions: subscriptions__.unwrap_or_default(),
12094 users: users__.unwrap_or_default(),
12095 session_params: session_params__,
12096 secrets: secrets__.unwrap_or_default(),
12097 compute_node_total_cpu_count: compute_node_total_cpu_count__.unwrap_or_default(),
12098 nodes: nodes__.unwrap_or_default(),
12099 hummock_version: hummock_version__,
12100 meta_backup_manifest_id: meta_backup_manifest_id__,
12101 hummock_write_limits: hummock_write_limits__,
12102 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
12103 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
12104 version: version__,
12105 })
12106 }
12107 }
12108 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
12109 }
12110}
12111impl serde::Serialize for meta_snapshot::SnapshotVersion {
12112 #[allow(deprecated)]
12113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12114 where
12115 S: serde::Serializer,
12116 {
12117 use serde::ser::SerializeStruct;
12118 let mut len = 0;
12119 if self.catalog_version != 0 {
12120 len += 1;
12121 }
12122 if self.worker_node_version != 0 {
12123 len += 1;
12124 }
12125 if self.streaming_worker_slot_mapping_version != 0 {
12126 len += 1;
12127 }
12128 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
12129 if self.catalog_version != 0 {
12130 #[allow(clippy::needless_borrow)]
12131 #[allow(clippy::needless_borrows_for_generic_args)]
12132 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
12133 }
12134 if self.worker_node_version != 0 {
12135 #[allow(clippy::needless_borrow)]
12136 #[allow(clippy::needless_borrows_for_generic_args)]
12137 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
12138 }
12139 if self.streaming_worker_slot_mapping_version != 0 {
12140 #[allow(clippy::needless_borrow)]
12141 #[allow(clippy::needless_borrows_for_generic_args)]
12142 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
12143 }
12144 struct_ser.end()
12145 }
12146}
12147impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
12148 #[allow(deprecated)]
12149 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12150 where
12151 D: serde::Deserializer<'de>,
12152 {
12153 const FIELDS: &[&str] = &[
12154 "catalog_version",
12155 "catalogVersion",
12156 "worker_node_version",
12157 "workerNodeVersion",
12158 "streaming_worker_slot_mapping_version",
12159 "streamingWorkerSlotMappingVersion",
12160 ];
12161
12162 #[allow(clippy::enum_variant_names)]
12163 enum GeneratedField {
12164 CatalogVersion,
12165 WorkerNodeVersion,
12166 StreamingWorkerSlotMappingVersion,
12167 }
12168 impl<'de> serde::Deserialize<'de> for GeneratedField {
12169 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12170 where
12171 D: serde::Deserializer<'de>,
12172 {
12173 struct GeneratedVisitor;
12174
12175 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12176 type Value = GeneratedField;
12177
12178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12179 write!(formatter, "expected one of: {:?}", &FIELDS)
12180 }
12181
12182 #[allow(unused_variables)]
12183 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12184 where
12185 E: serde::de::Error,
12186 {
12187 match value {
12188 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
12189 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
12190 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
12191 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12192 }
12193 }
12194 }
12195 deserializer.deserialize_identifier(GeneratedVisitor)
12196 }
12197 }
12198 struct GeneratedVisitor;
12199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12200 type Value = meta_snapshot::SnapshotVersion;
12201
12202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12203 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
12204 }
12205
12206 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
12207 where
12208 V: serde::de::MapAccess<'de>,
12209 {
12210 let mut catalog_version__ = None;
12211 let mut worker_node_version__ = None;
12212 let mut streaming_worker_slot_mapping_version__ = None;
12213 while let Some(k) = map_.next_key()? {
12214 match k {
12215 GeneratedField::CatalogVersion => {
12216 if catalog_version__.is_some() {
12217 return Err(serde::de::Error::duplicate_field("catalogVersion"));
12218 }
12219 catalog_version__ =
12220 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12221 ;
12222 }
12223 GeneratedField::WorkerNodeVersion => {
12224 if worker_node_version__.is_some() {
12225 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
12226 }
12227 worker_node_version__ =
12228 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12229 ;
12230 }
12231 GeneratedField::StreamingWorkerSlotMappingVersion => {
12232 if streaming_worker_slot_mapping_version__.is_some() {
12233 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
12234 }
12235 streaming_worker_slot_mapping_version__ =
12236 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12237 ;
12238 }
12239 }
12240 }
12241 Ok(meta_snapshot::SnapshotVersion {
12242 catalog_version: catalog_version__.unwrap_or_default(),
12243 worker_node_version: worker_node_version__.unwrap_or_default(),
12244 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
12245 })
12246 }
12247 }
12248 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
12249 }
12250}
12251impl serde::Serialize for MigrationPlan {
12252 #[allow(deprecated)]
12253 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12254 where
12255 S: serde::Serializer,
12256 {
12257 use serde::ser::SerializeStruct;
12258 let mut len = 0;
12259 if !self.worker_slot_migration_plan.is_empty() {
12260 len += 1;
12261 }
12262 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
12263 if !self.worker_slot_migration_plan.is_empty() {
12264 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
12265 .map(|(k, v)| (k, v.to_string())).collect();
12266 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
12267 }
12268 struct_ser.end()
12269 }
12270}
12271impl<'de> serde::Deserialize<'de> for MigrationPlan {
12272 #[allow(deprecated)]
12273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12274 where
12275 D: serde::Deserializer<'de>,
12276 {
12277 const FIELDS: &[&str] = &[
12278 "worker_slot_migration_plan",
12279 "workerSlotMigrationPlan",
12280 ];
12281
12282 #[allow(clippy::enum_variant_names)]
12283 enum GeneratedField {
12284 WorkerSlotMigrationPlan,
12285 }
12286 impl<'de> serde::Deserialize<'de> for GeneratedField {
12287 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12288 where
12289 D: serde::Deserializer<'de>,
12290 {
12291 struct GeneratedVisitor;
12292
12293 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12294 type Value = GeneratedField;
12295
12296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12297 write!(formatter, "expected one of: {:?}", &FIELDS)
12298 }
12299
12300 #[allow(unused_variables)]
12301 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12302 where
12303 E: serde::de::Error,
12304 {
12305 match value {
12306 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
12307 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12308 }
12309 }
12310 }
12311 deserializer.deserialize_identifier(GeneratedVisitor)
12312 }
12313 }
12314 struct GeneratedVisitor;
12315 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12316 type Value = MigrationPlan;
12317
12318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12319 formatter.write_str("struct meta.MigrationPlan")
12320 }
12321
12322 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
12323 where
12324 V: serde::de::MapAccess<'de>,
12325 {
12326 let mut worker_slot_migration_plan__ = None;
12327 while let Some(k) = map_.next_key()? {
12328 match k {
12329 GeneratedField::WorkerSlotMigrationPlan => {
12330 if worker_slot_migration_plan__.is_some() {
12331 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
12332 }
12333 worker_slot_migration_plan__ = Some(
12334 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
12335 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
12336 );
12337 }
12338 }
12339 }
12340 Ok(MigrationPlan {
12341 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
12342 })
12343 }
12344 }
12345 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
12346 }
12347}
12348impl serde::Serialize for Object {
12349 #[allow(deprecated)]
12350 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12351 where
12352 S: serde::Serializer,
12353 {
12354 use serde::ser::SerializeStruct;
12355 let mut len = 0;
12356 if self.object_info.is_some() {
12357 len += 1;
12358 }
12359 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
12360 if let Some(v) = self.object_info.as_ref() {
12361 match v {
12362 object::ObjectInfo::Database(v) => {
12363 struct_ser.serialize_field("database", v)?;
12364 }
12365 object::ObjectInfo::Schema(v) => {
12366 struct_ser.serialize_field("schema", v)?;
12367 }
12368 object::ObjectInfo::Table(v) => {
12369 struct_ser.serialize_field("table", v)?;
12370 }
12371 object::ObjectInfo::Index(v) => {
12372 struct_ser.serialize_field("index", v)?;
12373 }
12374 object::ObjectInfo::Source(v) => {
12375 struct_ser.serialize_field("source", v)?;
12376 }
12377 object::ObjectInfo::Sink(v) => {
12378 struct_ser.serialize_field("sink", v)?;
12379 }
12380 object::ObjectInfo::View(v) => {
12381 struct_ser.serialize_field("view", v)?;
12382 }
12383 object::ObjectInfo::Function(v) => {
12384 struct_ser.serialize_field("function", v)?;
12385 }
12386 object::ObjectInfo::Connection(v) => {
12387 struct_ser.serialize_field("connection", v)?;
12388 }
12389 object::ObjectInfo::Subscription(v) => {
12390 struct_ser.serialize_field("subscription", v)?;
12391 }
12392 object::ObjectInfo::Secret(v) => {
12393 struct_ser.serialize_field("secret", v)?;
12394 }
12395 }
12396 }
12397 struct_ser.end()
12398 }
12399}
12400impl<'de> serde::Deserialize<'de> for Object {
12401 #[allow(deprecated)]
12402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12403 where
12404 D: serde::Deserializer<'de>,
12405 {
12406 const FIELDS: &[&str] = &[
12407 "database",
12408 "schema",
12409 "table",
12410 "index",
12411 "source",
12412 "sink",
12413 "view",
12414 "function",
12415 "connection",
12416 "subscription",
12417 "secret",
12418 ];
12419
12420 #[allow(clippy::enum_variant_names)]
12421 enum GeneratedField {
12422 Database,
12423 Schema,
12424 Table,
12425 Index,
12426 Source,
12427 Sink,
12428 View,
12429 Function,
12430 Connection,
12431 Subscription,
12432 Secret,
12433 }
12434 impl<'de> serde::Deserialize<'de> for GeneratedField {
12435 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12436 where
12437 D: serde::Deserializer<'de>,
12438 {
12439 struct GeneratedVisitor;
12440
12441 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12442 type Value = GeneratedField;
12443
12444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12445 write!(formatter, "expected one of: {:?}", &FIELDS)
12446 }
12447
12448 #[allow(unused_variables)]
12449 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12450 where
12451 E: serde::de::Error,
12452 {
12453 match value {
12454 "database" => Ok(GeneratedField::Database),
12455 "schema" => Ok(GeneratedField::Schema),
12456 "table" => Ok(GeneratedField::Table),
12457 "index" => Ok(GeneratedField::Index),
12458 "source" => Ok(GeneratedField::Source),
12459 "sink" => Ok(GeneratedField::Sink),
12460 "view" => Ok(GeneratedField::View),
12461 "function" => Ok(GeneratedField::Function),
12462 "connection" => Ok(GeneratedField::Connection),
12463 "subscription" => Ok(GeneratedField::Subscription),
12464 "secret" => Ok(GeneratedField::Secret),
12465 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12466 }
12467 }
12468 }
12469 deserializer.deserialize_identifier(GeneratedVisitor)
12470 }
12471 }
12472 struct GeneratedVisitor;
12473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12474 type Value = Object;
12475
12476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12477 formatter.write_str("struct meta.Object")
12478 }
12479
12480 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
12481 where
12482 V: serde::de::MapAccess<'de>,
12483 {
12484 let mut object_info__ = None;
12485 while let Some(k) = map_.next_key()? {
12486 match k {
12487 GeneratedField::Database => {
12488 if object_info__.is_some() {
12489 return Err(serde::de::Error::duplicate_field("database"));
12490 }
12491 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
12492;
12493 }
12494 GeneratedField::Schema => {
12495 if object_info__.is_some() {
12496 return Err(serde::de::Error::duplicate_field("schema"));
12497 }
12498 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
12499;
12500 }
12501 GeneratedField::Table => {
12502 if object_info__.is_some() {
12503 return Err(serde::de::Error::duplicate_field("table"));
12504 }
12505 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
12506;
12507 }
12508 GeneratedField::Index => {
12509 if object_info__.is_some() {
12510 return Err(serde::de::Error::duplicate_field("index"));
12511 }
12512 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
12513;
12514 }
12515 GeneratedField::Source => {
12516 if object_info__.is_some() {
12517 return Err(serde::de::Error::duplicate_field("source"));
12518 }
12519 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
12520;
12521 }
12522 GeneratedField::Sink => {
12523 if object_info__.is_some() {
12524 return Err(serde::de::Error::duplicate_field("sink"));
12525 }
12526 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
12527;
12528 }
12529 GeneratedField::View => {
12530 if object_info__.is_some() {
12531 return Err(serde::de::Error::duplicate_field("view"));
12532 }
12533 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
12534;
12535 }
12536 GeneratedField::Function => {
12537 if object_info__.is_some() {
12538 return Err(serde::de::Error::duplicate_field("function"));
12539 }
12540 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
12541;
12542 }
12543 GeneratedField::Connection => {
12544 if object_info__.is_some() {
12545 return Err(serde::de::Error::duplicate_field("connection"));
12546 }
12547 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
12548;
12549 }
12550 GeneratedField::Subscription => {
12551 if object_info__.is_some() {
12552 return Err(serde::de::Error::duplicate_field("subscription"));
12553 }
12554 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
12555;
12556 }
12557 GeneratedField::Secret => {
12558 if object_info__.is_some() {
12559 return Err(serde::de::Error::duplicate_field("secret"));
12560 }
12561 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
12562;
12563 }
12564 }
12565 }
12566 Ok(Object {
12567 object_info: object_info__,
12568 })
12569 }
12570 }
12571 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
12572 }
12573}
12574impl serde::Serialize for ObjectGroup {
12575 #[allow(deprecated)]
12576 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12577 where
12578 S: serde::Serializer,
12579 {
12580 use serde::ser::SerializeStruct;
12581 let mut len = 0;
12582 if !self.objects.is_empty() {
12583 len += 1;
12584 }
12585 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
12586 if !self.objects.is_empty() {
12587 struct_ser.serialize_field("objects", &self.objects)?;
12588 }
12589 struct_ser.end()
12590 }
12591}
12592impl<'de> serde::Deserialize<'de> for ObjectGroup {
12593 #[allow(deprecated)]
12594 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12595 where
12596 D: serde::Deserializer<'de>,
12597 {
12598 const FIELDS: &[&str] = &[
12599 "objects",
12600 ];
12601
12602 #[allow(clippy::enum_variant_names)]
12603 enum GeneratedField {
12604 Objects,
12605 }
12606 impl<'de> serde::Deserialize<'de> for GeneratedField {
12607 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12608 where
12609 D: serde::Deserializer<'de>,
12610 {
12611 struct GeneratedVisitor;
12612
12613 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12614 type Value = GeneratedField;
12615
12616 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12617 write!(formatter, "expected one of: {:?}", &FIELDS)
12618 }
12619
12620 #[allow(unused_variables)]
12621 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12622 where
12623 E: serde::de::Error,
12624 {
12625 match value {
12626 "objects" => Ok(GeneratedField::Objects),
12627 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12628 }
12629 }
12630 }
12631 deserializer.deserialize_identifier(GeneratedVisitor)
12632 }
12633 }
12634 struct GeneratedVisitor;
12635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12636 type Value = ObjectGroup;
12637
12638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12639 formatter.write_str("struct meta.ObjectGroup")
12640 }
12641
12642 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
12643 where
12644 V: serde::de::MapAccess<'de>,
12645 {
12646 let mut objects__ = None;
12647 while let Some(k) = map_.next_key()? {
12648 match k {
12649 GeneratedField::Objects => {
12650 if objects__.is_some() {
12651 return Err(serde::de::Error::duplicate_field("objects"));
12652 }
12653 objects__ = Some(map_.next_value()?);
12654 }
12655 }
12656 }
12657 Ok(ObjectGroup {
12658 objects: objects__.unwrap_or_default(),
12659 })
12660 }
12661 }
12662 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
12663 }
12664}
12665impl serde::Serialize for PauseRequest {
12666 #[allow(deprecated)]
12667 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12668 where
12669 S: serde::Serializer,
12670 {
12671 use serde::ser::SerializeStruct;
12672 let len = 0;
12673 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
12674 struct_ser.end()
12675 }
12676}
12677impl<'de> serde::Deserialize<'de> for PauseRequest {
12678 #[allow(deprecated)]
12679 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12680 where
12681 D: serde::Deserializer<'de>,
12682 {
12683 const FIELDS: &[&str] = &[
12684 ];
12685
12686 #[allow(clippy::enum_variant_names)]
12687 enum GeneratedField {
12688 }
12689 impl<'de> serde::Deserialize<'de> for GeneratedField {
12690 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12691 where
12692 D: serde::Deserializer<'de>,
12693 {
12694 struct GeneratedVisitor;
12695
12696 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12697 type Value = GeneratedField;
12698
12699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12700 write!(formatter, "expected one of: {:?}", &FIELDS)
12701 }
12702
12703 #[allow(unused_variables)]
12704 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12705 where
12706 E: serde::de::Error,
12707 {
12708 Err(serde::de::Error::unknown_field(value, FIELDS))
12709 }
12710 }
12711 deserializer.deserialize_identifier(GeneratedVisitor)
12712 }
12713 }
12714 struct GeneratedVisitor;
12715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12716 type Value = PauseRequest;
12717
12718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12719 formatter.write_str("struct meta.PauseRequest")
12720 }
12721
12722 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
12723 where
12724 V: serde::de::MapAccess<'de>,
12725 {
12726 while map_.next_key::<GeneratedField>()?.is_some() {
12727 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12728 }
12729 Ok(PauseRequest {
12730 })
12731 }
12732 }
12733 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
12734 }
12735}
12736impl serde::Serialize for PauseResponse {
12737 #[allow(deprecated)]
12738 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12739 where
12740 S: serde::Serializer,
12741 {
12742 use serde::ser::SerializeStruct;
12743 let len = 0;
12744 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
12745 struct_ser.end()
12746 }
12747}
12748impl<'de> serde::Deserialize<'de> for PauseResponse {
12749 #[allow(deprecated)]
12750 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12751 where
12752 D: serde::Deserializer<'de>,
12753 {
12754 const FIELDS: &[&str] = &[
12755 ];
12756
12757 #[allow(clippy::enum_variant_names)]
12758 enum GeneratedField {
12759 }
12760 impl<'de> serde::Deserialize<'de> for GeneratedField {
12761 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12762 where
12763 D: serde::Deserializer<'de>,
12764 {
12765 struct GeneratedVisitor;
12766
12767 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12768 type Value = GeneratedField;
12769
12770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12771 write!(formatter, "expected one of: {:?}", &FIELDS)
12772 }
12773
12774 #[allow(unused_variables)]
12775 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12776 where
12777 E: serde::de::Error,
12778 {
12779 Err(serde::de::Error::unknown_field(value, FIELDS))
12780 }
12781 }
12782 deserializer.deserialize_identifier(GeneratedVisitor)
12783 }
12784 }
12785 struct GeneratedVisitor;
12786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12787 type Value = PauseResponse;
12788
12789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12790 formatter.write_str("struct meta.PauseResponse")
12791 }
12792
12793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
12794 where
12795 V: serde::de::MapAccess<'de>,
12796 {
12797 while map_.next_key::<GeneratedField>()?.is_some() {
12798 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12799 }
12800 Ok(PauseResponse {
12801 })
12802 }
12803 }
12804 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
12805 }
12806}
12807impl serde::Serialize for RecoverRequest {
12808 #[allow(deprecated)]
12809 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12810 where
12811 S: serde::Serializer,
12812 {
12813 use serde::ser::SerializeStruct;
12814 let len = 0;
12815 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
12816 struct_ser.end()
12817 }
12818}
12819impl<'de> serde::Deserialize<'de> for RecoverRequest {
12820 #[allow(deprecated)]
12821 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12822 where
12823 D: serde::Deserializer<'de>,
12824 {
12825 const FIELDS: &[&str] = &[
12826 ];
12827
12828 #[allow(clippy::enum_variant_names)]
12829 enum GeneratedField {
12830 }
12831 impl<'de> serde::Deserialize<'de> for GeneratedField {
12832 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12833 where
12834 D: serde::Deserializer<'de>,
12835 {
12836 struct GeneratedVisitor;
12837
12838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12839 type Value = GeneratedField;
12840
12841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12842 write!(formatter, "expected one of: {:?}", &FIELDS)
12843 }
12844
12845 #[allow(unused_variables)]
12846 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12847 where
12848 E: serde::de::Error,
12849 {
12850 Err(serde::de::Error::unknown_field(value, FIELDS))
12851 }
12852 }
12853 deserializer.deserialize_identifier(GeneratedVisitor)
12854 }
12855 }
12856 struct GeneratedVisitor;
12857 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12858 type Value = RecoverRequest;
12859
12860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12861 formatter.write_str("struct meta.RecoverRequest")
12862 }
12863
12864 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
12865 where
12866 V: serde::de::MapAccess<'de>,
12867 {
12868 while map_.next_key::<GeneratedField>()?.is_some() {
12869 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12870 }
12871 Ok(RecoverRequest {
12872 })
12873 }
12874 }
12875 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
12876 }
12877}
12878impl serde::Serialize for RecoverResponse {
12879 #[allow(deprecated)]
12880 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12881 where
12882 S: serde::Serializer,
12883 {
12884 use serde::ser::SerializeStruct;
12885 let len = 0;
12886 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
12887 struct_ser.end()
12888 }
12889}
12890impl<'de> serde::Deserialize<'de> for RecoverResponse {
12891 #[allow(deprecated)]
12892 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12893 where
12894 D: serde::Deserializer<'de>,
12895 {
12896 const FIELDS: &[&str] = &[
12897 ];
12898
12899 #[allow(clippy::enum_variant_names)]
12900 enum GeneratedField {
12901 }
12902 impl<'de> serde::Deserialize<'de> for GeneratedField {
12903 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12904 where
12905 D: serde::Deserializer<'de>,
12906 {
12907 struct GeneratedVisitor;
12908
12909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12910 type Value = GeneratedField;
12911
12912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12913 write!(formatter, "expected one of: {:?}", &FIELDS)
12914 }
12915
12916 #[allow(unused_variables)]
12917 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12918 where
12919 E: serde::de::Error,
12920 {
12921 Err(serde::de::Error::unknown_field(value, FIELDS))
12922 }
12923 }
12924 deserializer.deserialize_identifier(GeneratedVisitor)
12925 }
12926 }
12927 struct GeneratedVisitor;
12928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12929 type Value = RecoverResponse;
12930
12931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12932 formatter.write_str("struct meta.RecoverResponse")
12933 }
12934
12935 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
12936 where
12937 V: serde::de::MapAccess<'de>,
12938 {
12939 while map_.next_key::<GeneratedField>()?.is_some() {
12940 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12941 }
12942 Ok(RecoverResponse {
12943 })
12944 }
12945 }
12946 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
12947 }
12948}
12949impl serde::Serialize for Recovery {
12950 #[allow(deprecated)]
12951 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12952 where
12953 S: serde::Serializer,
12954 {
12955 use serde::ser::SerializeStruct;
12956 let len = 0;
12957 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
12958 struct_ser.end()
12959 }
12960}
12961impl<'de> serde::Deserialize<'de> for Recovery {
12962 #[allow(deprecated)]
12963 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12964 where
12965 D: serde::Deserializer<'de>,
12966 {
12967 const FIELDS: &[&str] = &[
12968 ];
12969
12970 #[allow(clippy::enum_variant_names)]
12971 enum GeneratedField {
12972 }
12973 impl<'de> serde::Deserialize<'de> for GeneratedField {
12974 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12975 where
12976 D: serde::Deserializer<'de>,
12977 {
12978 struct GeneratedVisitor;
12979
12980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12981 type Value = GeneratedField;
12982
12983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12984 write!(formatter, "expected one of: {:?}", &FIELDS)
12985 }
12986
12987 #[allow(unused_variables)]
12988 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12989 where
12990 E: serde::de::Error,
12991 {
12992 Err(serde::de::Error::unknown_field(value, FIELDS))
12993 }
12994 }
12995 deserializer.deserialize_identifier(GeneratedVisitor)
12996 }
12997 }
12998 struct GeneratedVisitor;
12999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13000 type Value = Recovery;
13001
13002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13003 formatter.write_str("struct meta.Recovery")
13004 }
13005
13006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
13007 where
13008 V: serde::de::MapAccess<'de>,
13009 {
13010 while map_.next_key::<GeneratedField>()?.is_some() {
13011 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13012 }
13013 Ok(Recovery {
13014 })
13015 }
13016 }
13017 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
13018 }
13019}
13020impl serde::Serialize for RecoveryStatus {
13021 #[allow(deprecated)]
13022 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13023 where
13024 S: serde::Serializer,
13025 {
13026 let variant = match self {
13027 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
13028 Self::StatusStarting => "STATUS_STARTING",
13029 Self::StatusRecovering => "STATUS_RECOVERING",
13030 Self::StatusRunning => "STATUS_RUNNING",
13031 };
13032 serializer.serialize_str(variant)
13033 }
13034}
13035impl<'de> serde::Deserialize<'de> for RecoveryStatus {
13036 #[allow(deprecated)]
13037 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13038 where
13039 D: serde::Deserializer<'de>,
13040 {
13041 const FIELDS: &[&str] = &[
13042 "STATUS_UNSPECIFIED",
13043 "STATUS_STARTING",
13044 "STATUS_RECOVERING",
13045 "STATUS_RUNNING",
13046 ];
13047
13048 struct GeneratedVisitor;
13049
13050 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13051 type Value = RecoveryStatus;
13052
13053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13054 write!(formatter, "expected one of: {:?}", &FIELDS)
13055 }
13056
13057 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13058 where
13059 E: serde::de::Error,
13060 {
13061 i32::try_from(v)
13062 .ok()
13063 .and_then(|x| x.try_into().ok())
13064 .ok_or_else(|| {
13065 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13066 })
13067 }
13068
13069 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13070 where
13071 E: serde::de::Error,
13072 {
13073 i32::try_from(v)
13074 .ok()
13075 .and_then(|x| x.try_into().ok())
13076 .ok_or_else(|| {
13077 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13078 })
13079 }
13080
13081 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13082 where
13083 E: serde::de::Error,
13084 {
13085 match value {
13086 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
13087 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
13088 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
13089 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
13090 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13091 }
13092 }
13093 }
13094 deserializer.deserialize_any(GeneratedVisitor)
13095 }
13096}
13097impl serde::Serialize for RefreshRequest {
13098 #[allow(deprecated)]
13099 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13100 where
13101 S: serde::Serializer,
13102 {
13103 use serde::ser::SerializeStruct;
13104 let mut len = 0;
13105 if self.table_id != 0 {
13106 len += 1;
13107 }
13108 if self.associated_source_id != 0 {
13109 len += 1;
13110 }
13111 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
13112 if self.table_id != 0 {
13113 struct_ser.serialize_field("tableId", &self.table_id)?;
13114 }
13115 if self.associated_source_id != 0 {
13116 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
13117 }
13118 struct_ser.end()
13119 }
13120}
13121impl<'de> serde::Deserialize<'de> for RefreshRequest {
13122 #[allow(deprecated)]
13123 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13124 where
13125 D: serde::Deserializer<'de>,
13126 {
13127 const FIELDS: &[&str] = &[
13128 "table_id",
13129 "tableId",
13130 "associated_source_id",
13131 "associatedSourceId",
13132 ];
13133
13134 #[allow(clippy::enum_variant_names)]
13135 enum GeneratedField {
13136 TableId,
13137 AssociatedSourceId,
13138 }
13139 impl<'de> serde::Deserialize<'de> for GeneratedField {
13140 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13141 where
13142 D: serde::Deserializer<'de>,
13143 {
13144 struct GeneratedVisitor;
13145
13146 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13147 type Value = GeneratedField;
13148
13149 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13150 write!(formatter, "expected one of: {:?}", &FIELDS)
13151 }
13152
13153 #[allow(unused_variables)]
13154 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13155 where
13156 E: serde::de::Error,
13157 {
13158 match value {
13159 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13160 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
13161 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13162 }
13163 }
13164 }
13165 deserializer.deserialize_identifier(GeneratedVisitor)
13166 }
13167 }
13168 struct GeneratedVisitor;
13169 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13170 type Value = RefreshRequest;
13171
13172 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13173 formatter.write_str("struct meta.RefreshRequest")
13174 }
13175
13176 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
13177 where
13178 V: serde::de::MapAccess<'de>,
13179 {
13180 let mut table_id__ = None;
13181 let mut associated_source_id__ = None;
13182 while let Some(k) = map_.next_key()? {
13183 match k {
13184 GeneratedField::TableId => {
13185 if table_id__.is_some() {
13186 return Err(serde::de::Error::duplicate_field("tableId"));
13187 }
13188 table_id__ =
13189 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13190 ;
13191 }
13192 GeneratedField::AssociatedSourceId => {
13193 if associated_source_id__.is_some() {
13194 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
13195 }
13196 associated_source_id__ =
13197 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13198 ;
13199 }
13200 }
13201 }
13202 Ok(RefreshRequest {
13203 table_id: table_id__.unwrap_or_default(),
13204 associated_source_id: associated_source_id__.unwrap_or_default(),
13205 })
13206 }
13207 }
13208 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
13209 }
13210}
13211impl serde::Serialize for RefreshResponse {
13212 #[allow(deprecated)]
13213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13214 where
13215 S: serde::Serializer,
13216 {
13217 use serde::ser::SerializeStruct;
13218 let mut len = 0;
13219 if self.status.is_some() {
13220 len += 1;
13221 }
13222 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
13223 if let Some(v) = self.status.as_ref() {
13224 struct_ser.serialize_field("status", v)?;
13225 }
13226 struct_ser.end()
13227 }
13228}
13229impl<'de> serde::Deserialize<'de> for RefreshResponse {
13230 #[allow(deprecated)]
13231 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13232 where
13233 D: serde::Deserializer<'de>,
13234 {
13235 const FIELDS: &[&str] = &[
13236 "status",
13237 ];
13238
13239 #[allow(clippy::enum_variant_names)]
13240 enum GeneratedField {
13241 Status,
13242 }
13243 impl<'de> serde::Deserialize<'de> for GeneratedField {
13244 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13245 where
13246 D: serde::Deserializer<'de>,
13247 {
13248 struct GeneratedVisitor;
13249
13250 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13251 type Value = GeneratedField;
13252
13253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13254 write!(formatter, "expected one of: {:?}", &FIELDS)
13255 }
13256
13257 #[allow(unused_variables)]
13258 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13259 where
13260 E: serde::de::Error,
13261 {
13262 match value {
13263 "status" => Ok(GeneratedField::Status),
13264 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13265 }
13266 }
13267 }
13268 deserializer.deserialize_identifier(GeneratedVisitor)
13269 }
13270 }
13271 struct GeneratedVisitor;
13272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13273 type Value = RefreshResponse;
13274
13275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13276 formatter.write_str("struct meta.RefreshResponse")
13277 }
13278
13279 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
13280 where
13281 V: serde::de::MapAccess<'de>,
13282 {
13283 let mut status__ = None;
13284 while let Some(k) = map_.next_key()? {
13285 match k {
13286 GeneratedField::Status => {
13287 if status__.is_some() {
13288 return Err(serde::de::Error::duplicate_field("status"));
13289 }
13290 status__ = map_.next_value()?;
13291 }
13292 }
13293 }
13294 Ok(RefreshResponse {
13295 status: status__,
13296 })
13297 }
13298 }
13299 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
13300 }
13301}
13302impl serde::Serialize for RelationIdInfos {
13303 #[allow(deprecated)]
13304 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13305 where
13306 S: serde::Serializer,
13307 {
13308 use serde::ser::SerializeStruct;
13309 let mut len = 0;
13310 if !self.map.is_empty() {
13311 len += 1;
13312 }
13313 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
13314 if !self.map.is_empty() {
13315 struct_ser.serialize_field("map", &self.map)?;
13316 }
13317 struct_ser.end()
13318 }
13319}
13320impl<'de> serde::Deserialize<'de> for RelationIdInfos {
13321 #[allow(deprecated)]
13322 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13323 where
13324 D: serde::Deserializer<'de>,
13325 {
13326 const FIELDS: &[&str] = &[
13327 "map",
13328 ];
13329
13330 #[allow(clippy::enum_variant_names)]
13331 enum GeneratedField {
13332 Map,
13333 }
13334 impl<'de> serde::Deserialize<'de> for GeneratedField {
13335 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13336 where
13337 D: serde::Deserializer<'de>,
13338 {
13339 struct GeneratedVisitor;
13340
13341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13342 type Value = GeneratedField;
13343
13344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13345 write!(formatter, "expected one of: {:?}", &FIELDS)
13346 }
13347
13348 #[allow(unused_variables)]
13349 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13350 where
13351 E: serde::de::Error,
13352 {
13353 match value {
13354 "map" => Ok(GeneratedField::Map),
13355 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13356 }
13357 }
13358 }
13359 deserializer.deserialize_identifier(GeneratedVisitor)
13360 }
13361 }
13362 struct GeneratedVisitor;
13363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13364 type Value = RelationIdInfos;
13365
13366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13367 formatter.write_str("struct meta.RelationIdInfos")
13368 }
13369
13370 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
13371 where
13372 V: serde::de::MapAccess<'de>,
13373 {
13374 let mut map__ = None;
13375 while let Some(k) = map_.next_key()? {
13376 match k {
13377 GeneratedField::Map => {
13378 if map__.is_some() {
13379 return Err(serde::de::Error::duplicate_field("map"));
13380 }
13381 map__ = Some(
13382 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13383 .into_iter().map(|(k,v)| (k.0, v)).collect()
13384 );
13385 }
13386 }
13387 }
13388 Ok(RelationIdInfos {
13389 map: map__.unwrap_or_default(),
13390 })
13391 }
13392 }
13393 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
13394 }
13395}
13396impl serde::Serialize for RescheduleRequest {
13397 #[allow(deprecated)]
13398 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13399 where
13400 S: serde::Serializer,
13401 {
13402 use serde::ser::SerializeStruct;
13403 let mut len = 0;
13404 if self.revision != 0 {
13405 len += 1;
13406 }
13407 if self.resolve_no_shuffle_upstream {
13408 len += 1;
13409 }
13410 if !self.worker_reschedules.is_empty() {
13411 len += 1;
13412 }
13413 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
13414 if self.revision != 0 {
13415 #[allow(clippy::needless_borrow)]
13416 #[allow(clippy::needless_borrows_for_generic_args)]
13417 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13418 }
13419 if self.resolve_no_shuffle_upstream {
13420 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
13421 }
13422 if !self.worker_reschedules.is_empty() {
13423 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
13424 }
13425 struct_ser.end()
13426 }
13427}
13428impl<'de> serde::Deserialize<'de> for RescheduleRequest {
13429 #[allow(deprecated)]
13430 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13431 where
13432 D: serde::Deserializer<'de>,
13433 {
13434 const FIELDS: &[&str] = &[
13435 "revision",
13436 "resolve_no_shuffle_upstream",
13437 "resolveNoShuffleUpstream",
13438 "worker_reschedules",
13439 "workerReschedules",
13440 ];
13441
13442 #[allow(clippy::enum_variant_names)]
13443 enum GeneratedField {
13444 Revision,
13445 ResolveNoShuffleUpstream,
13446 WorkerReschedules,
13447 }
13448 impl<'de> serde::Deserialize<'de> for GeneratedField {
13449 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13450 where
13451 D: serde::Deserializer<'de>,
13452 {
13453 struct GeneratedVisitor;
13454
13455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13456 type Value = GeneratedField;
13457
13458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13459 write!(formatter, "expected one of: {:?}", &FIELDS)
13460 }
13461
13462 #[allow(unused_variables)]
13463 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13464 where
13465 E: serde::de::Error,
13466 {
13467 match value {
13468 "revision" => Ok(GeneratedField::Revision),
13469 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
13470 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
13471 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13472 }
13473 }
13474 }
13475 deserializer.deserialize_identifier(GeneratedVisitor)
13476 }
13477 }
13478 struct GeneratedVisitor;
13479 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13480 type Value = RescheduleRequest;
13481
13482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13483 formatter.write_str("struct meta.RescheduleRequest")
13484 }
13485
13486 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
13487 where
13488 V: serde::de::MapAccess<'de>,
13489 {
13490 let mut revision__ = None;
13491 let mut resolve_no_shuffle_upstream__ = None;
13492 let mut worker_reschedules__ = None;
13493 while let Some(k) = map_.next_key()? {
13494 match k {
13495 GeneratedField::Revision => {
13496 if revision__.is_some() {
13497 return Err(serde::de::Error::duplicate_field("revision"));
13498 }
13499 revision__ =
13500 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13501 ;
13502 }
13503 GeneratedField::ResolveNoShuffleUpstream => {
13504 if resolve_no_shuffle_upstream__.is_some() {
13505 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
13506 }
13507 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
13508 }
13509 GeneratedField::WorkerReschedules => {
13510 if worker_reschedules__.is_some() {
13511 return Err(serde::de::Error::duplicate_field("workerReschedules"));
13512 }
13513 worker_reschedules__ = Some(
13514 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13515 .into_iter().map(|(k,v)| (k.0, v)).collect()
13516 );
13517 }
13518 }
13519 }
13520 Ok(RescheduleRequest {
13521 revision: revision__.unwrap_or_default(),
13522 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
13523 worker_reschedules: worker_reschedules__.unwrap_or_default(),
13524 })
13525 }
13526 }
13527 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
13528 }
13529}
13530impl serde::Serialize for RescheduleResponse {
13531 #[allow(deprecated)]
13532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13533 where
13534 S: serde::Serializer,
13535 {
13536 use serde::ser::SerializeStruct;
13537 let mut len = 0;
13538 if self.success {
13539 len += 1;
13540 }
13541 if self.revision != 0 {
13542 len += 1;
13543 }
13544 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
13545 if self.success {
13546 struct_ser.serialize_field("success", &self.success)?;
13547 }
13548 if self.revision != 0 {
13549 #[allow(clippy::needless_borrow)]
13550 #[allow(clippy::needless_borrows_for_generic_args)]
13551 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13552 }
13553 struct_ser.end()
13554 }
13555}
13556impl<'de> serde::Deserialize<'de> for RescheduleResponse {
13557 #[allow(deprecated)]
13558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13559 where
13560 D: serde::Deserializer<'de>,
13561 {
13562 const FIELDS: &[&str] = &[
13563 "success",
13564 "revision",
13565 ];
13566
13567 #[allow(clippy::enum_variant_names)]
13568 enum GeneratedField {
13569 Success,
13570 Revision,
13571 }
13572 impl<'de> serde::Deserialize<'de> for GeneratedField {
13573 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13574 where
13575 D: serde::Deserializer<'de>,
13576 {
13577 struct GeneratedVisitor;
13578
13579 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13580 type Value = GeneratedField;
13581
13582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13583 write!(formatter, "expected one of: {:?}", &FIELDS)
13584 }
13585
13586 #[allow(unused_variables)]
13587 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13588 where
13589 E: serde::de::Error,
13590 {
13591 match value {
13592 "success" => Ok(GeneratedField::Success),
13593 "revision" => Ok(GeneratedField::Revision),
13594 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13595 }
13596 }
13597 }
13598 deserializer.deserialize_identifier(GeneratedVisitor)
13599 }
13600 }
13601 struct GeneratedVisitor;
13602 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13603 type Value = RescheduleResponse;
13604
13605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13606 formatter.write_str("struct meta.RescheduleResponse")
13607 }
13608
13609 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
13610 where
13611 V: serde::de::MapAccess<'de>,
13612 {
13613 let mut success__ = None;
13614 let mut revision__ = None;
13615 while let Some(k) = map_.next_key()? {
13616 match k {
13617 GeneratedField::Success => {
13618 if success__.is_some() {
13619 return Err(serde::de::Error::duplicate_field("success"));
13620 }
13621 success__ = Some(map_.next_value()?);
13622 }
13623 GeneratedField::Revision => {
13624 if revision__.is_some() {
13625 return Err(serde::de::Error::duplicate_field("revision"));
13626 }
13627 revision__ =
13628 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13629 ;
13630 }
13631 }
13632 }
13633 Ok(RescheduleResponse {
13634 success: success__.unwrap_or_default(),
13635 revision: revision__.unwrap_or_default(),
13636 })
13637 }
13638 }
13639 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
13640 }
13641}
13642impl serde::Serialize for ResumeRequest {
13643 #[allow(deprecated)]
13644 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13645 where
13646 S: serde::Serializer,
13647 {
13648 use serde::ser::SerializeStruct;
13649 let len = 0;
13650 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
13651 struct_ser.end()
13652 }
13653}
13654impl<'de> serde::Deserialize<'de> for ResumeRequest {
13655 #[allow(deprecated)]
13656 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13657 where
13658 D: serde::Deserializer<'de>,
13659 {
13660 const FIELDS: &[&str] = &[
13661 ];
13662
13663 #[allow(clippy::enum_variant_names)]
13664 enum GeneratedField {
13665 }
13666 impl<'de> serde::Deserialize<'de> for GeneratedField {
13667 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13668 where
13669 D: serde::Deserializer<'de>,
13670 {
13671 struct GeneratedVisitor;
13672
13673 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13674 type Value = GeneratedField;
13675
13676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13677 write!(formatter, "expected one of: {:?}", &FIELDS)
13678 }
13679
13680 #[allow(unused_variables)]
13681 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13682 where
13683 E: serde::de::Error,
13684 {
13685 Err(serde::de::Error::unknown_field(value, FIELDS))
13686 }
13687 }
13688 deserializer.deserialize_identifier(GeneratedVisitor)
13689 }
13690 }
13691 struct GeneratedVisitor;
13692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13693 type Value = ResumeRequest;
13694
13695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13696 formatter.write_str("struct meta.ResumeRequest")
13697 }
13698
13699 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
13700 where
13701 V: serde::de::MapAccess<'de>,
13702 {
13703 while map_.next_key::<GeneratedField>()?.is_some() {
13704 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13705 }
13706 Ok(ResumeRequest {
13707 })
13708 }
13709 }
13710 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
13711 }
13712}
13713impl serde::Serialize for ResumeResponse {
13714 #[allow(deprecated)]
13715 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13716 where
13717 S: serde::Serializer,
13718 {
13719 use serde::ser::SerializeStruct;
13720 let len = 0;
13721 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
13722 struct_ser.end()
13723 }
13724}
13725impl<'de> serde::Deserialize<'de> for ResumeResponse {
13726 #[allow(deprecated)]
13727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13728 where
13729 D: serde::Deserializer<'de>,
13730 {
13731 const FIELDS: &[&str] = &[
13732 ];
13733
13734 #[allow(clippy::enum_variant_names)]
13735 enum GeneratedField {
13736 }
13737 impl<'de> serde::Deserialize<'de> for GeneratedField {
13738 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13739 where
13740 D: serde::Deserializer<'de>,
13741 {
13742 struct GeneratedVisitor;
13743
13744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13745 type Value = GeneratedField;
13746
13747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13748 write!(formatter, "expected one of: {:?}", &FIELDS)
13749 }
13750
13751 #[allow(unused_variables)]
13752 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13753 where
13754 E: serde::de::Error,
13755 {
13756 Err(serde::de::Error::unknown_field(value, FIELDS))
13757 }
13758 }
13759 deserializer.deserialize_identifier(GeneratedVisitor)
13760 }
13761 }
13762 struct GeneratedVisitor;
13763 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13764 type Value = ResumeResponse;
13765
13766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13767 formatter.write_str("struct meta.ResumeResponse")
13768 }
13769
13770 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
13771 where
13772 V: serde::de::MapAccess<'de>,
13773 {
13774 while map_.next_key::<GeneratedField>()?.is_some() {
13775 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13776 }
13777 Ok(ResumeResponse {
13778 })
13779 }
13780 }
13781 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
13782 }
13783}
13784impl serde::Serialize for SetSessionParamRequest {
13785 #[allow(deprecated)]
13786 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13787 where
13788 S: serde::Serializer,
13789 {
13790 use serde::ser::SerializeStruct;
13791 let mut len = 0;
13792 if !self.param.is_empty() {
13793 len += 1;
13794 }
13795 if self.value.is_some() {
13796 len += 1;
13797 }
13798 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
13799 if !self.param.is_empty() {
13800 struct_ser.serialize_field("param", &self.param)?;
13801 }
13802 if let Some(v) = self.value.as_ref() {
13803 struct_ser.serialize_field("value", v)?;
13804 }
13805 struct_ser.end()
13806 }
13807}
13808impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
13809 #[allow(deprecated)]
13810 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13811 where
13812 D: serde::Deserializer<'de>,
13813 {
13814 const FIELDS: &[&str] = &[
13815 "param",
13816 "value",
13817 ];
13818
13819 #[allow(clippy::enum_variant_names)]
13820 enum GeneratedField {
13821 Param,
13822 Value,
13823 }
13824 impl<'de> serde::Deserialize<'de> for GeneratedField {
13825 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13826 where
13827 D: serde::Deserializer<'de>,
13828 {
13829 struct GeneratedVisitor;
13830
13831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13832 type Value = GeneratedField;
13833
13834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13835 write!(formatter, "expected one of: {:?}", &FIELDS)
13836 }
13837
13838 #[allow(unused_variables)]
13839 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13840 where
13841 E: serde::de::Error,
13842 {
13843 match value {
13844 "param" => Ok(GeneratedField::Param),
13845 "value" => Ok(GeneratedField::Value),
13846 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13847 }
13848 }
13849 }
13850 deserializer.deserialize_identifier(GeneratedVisitor)
13851 }
13852 }
13853 struct GeneratedVisitor;
13854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13855 type Value = SetSessionParamRequest;
13856
13857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13858 formatter.write_str("struct meta.SetSessionParamRequest")
13859 }
13860
13861 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
13862 where
13863 V: serde::de::MapAccess<'de>,
13864 {
13865 let mut param__ = None;
13866 let mut value__ = None;
13867 while let Some(k) = map_.next_key()? {
13868 match k {
13869 GeneratedField::Param => {
13870 if param__.is_some() {
13871 return Err(serde::de::Error::duplicate_field("param"));
13872 }
13873 param__ = Some(map_.next_value()?);
13874 }
13875 GeneratedField::Value => {
13876 if value__.is_some() {
13877 return Err(serde::de::Error::duplicate_field("value"));
13878 }
13879 value__ = map_.next_value()?;
13880 }
13881 }
13882 }
13883 Ok(SetSessionParamRequest {
13884 param: param__.unwrap_or_default(),
13885 value: value__,
13886 })
13887 }
13888 }
13889 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
13890 }
13891}
13892impl serde::Serialize for SetSessionParamResponse {
13893 #[allow(deprecated)]
13894 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13895 where
13896 S: serde::Serializer,
13897 {
13898 use serde::ser::SerializeStruct;
13899 let mut len = 0;
13900 if !self.param.is_empty() {
13901 len += 1;
13902 }
13903 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
13904 if !self.param.is_empty() {
13905 struct_ser.serialize_field("param", &self.param)?;
13906 }
13907 struct_ser.end()
13908 }
13909}
13910impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
13911 #[allow(deprecated)]
13912 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13913 where
13914 D: serde::Deserializer<'de>,
13915 {
13916 const FIELDS: &[&str] = &[
13917 "param",
13918 ];
13919
13920 #[allow(clippy::enum_variant_names)]
13921 enum GeneratedField {
13922 Param,
13923 }
13924 impl<'de> serde::Deserialize<'de> for GeneratedField {
13925 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13926 where
13927 D: serde::Deserializer<'de>,
13928 {
13929 struct GeneratedVisitor;
13930
13931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13932 type Value = GeneratedField;
13933
13934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13935 write!(formatter, "expected one of: {:?}", &FIELDS)
13936 }
13937
13938 #[allow(unused_variables)]
13939 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13940 where
13941 E: serde::de::Error,
13942 {
13943 match value {
13944 "param" => Ok(GeneratedField::Param),
13945 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13946 }
13947 }
13948 }
13949 deserializer.deserialize_identifier(GeneratedVisitor)
13950 }
13951 }
13952 struct GeneratedVisitor;
13953 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13954 type Value = SetSessionParamResponse;
13955
13956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13957 formatter.write_str("struct meta.SetSessionParamResponse")
13958 }
13959
13960 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
13961 where
13962 V: serde::de::MapAccess<'de>,
13963 {
13964 let mut param__ = None;
13965 while let Some(k) = map_.next_key()? {
13966 match k {
13967 GeneratedField::Param => {
13968 if param__.is_some() {
13969 return Err(serde::de::Error::duplicate_field("param"));
13970 }
13971 param__ = Some(map_.next_value()?);
13972 }
13973 }
13974 }
13975 Ok(SetSessionParamResponse {
13976 param: param__.unwrap_or_default(),
13977 })
13978 }
13979 }
13980 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
13981 }
13982}
13983impl serde::Serialize for SetSyncLogStoreAlignedRequest {
13984 #[allow(deprecated)]
13985 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13986 where
13987 S: serde::Serializer,
13988 {
13989 use serde::ser::SerializeStruct;
13990 let mut len = 0;
13991 if self.job_id != 0 {
13992 len += 1;
13993 }
13994 if self.aligned {
13995 len += 1;
13996 }
13997 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
13998 if self.job_id != 0 {
13999 struct_ser.serialize_field("jobId", &self.job_id)?;
14000 }
14001 if self.aligned {
14002 struct_ser.serialize_field("aligned", &self.aligned)?;
14003 }
14004 struct_ser.end()
14005 }
14006}
14007impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
14008 #[allow(deprecated)]
14009 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14010 where
14011 D: serde::Deserializer<'de>,
14012 {
14013 const FIELDS: &[&str] = &[
14014 "job_id",
14015 "jobId",
14016 "aligned",
14017 ];
14018
14019 #[allow(clippy::enum_variant_names)]
14020 enum GeneratedField {
14021 JobId,
14022 Aligned,
14023 }
14024 impl<'de> serde::Deserialize<'de> for GeneratedField {
14025 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14026 where
14027 D: serde::Deserializer<'de>,
14028 {
14029 struct GeneratedVisitor;
14030
14031 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14032 type Value = GeneratedField;
14033
14034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14035 write!(formatter, "expected one of: {:?}", &FIELDS)
14036 }
14037
14038 #[allow(unused_variables)]
14039 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14040 where
14041 E: serde::de::Error,
14042 {
14043 match value {
14044 "jobId" | "job_id" => Ok(GeneratedField::JobId),
14045 "aligned" => Ok(GeneratedField::Aligned),
14046 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14047 }
14048 }
14049 }
14050 deserializer.deserialize_identifier(GeneratedVisitor)
14051 }
14052 }
14053 struct GeneratedVisitor;
14054 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14055 type Value = SetSyncLogStoreAlignedRequest;
14056
14057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14058 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
14059 }
14060
14061 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
14062 where
14063 V: serde::de::MapAccess<'de>,
14064 {
14065 let mut job_id__ = None;
14066 let mut aligned__ = None;
14067 while let Some(k) = map_.next_key()? {
14068 match k {
14069 GeneratedField::JobId => {
14070 if job_id__.is_some() {
14071 return Err(serde::de::Error::duplicate_field("jobId"));
14072 }
14073 job_id__ =
14074 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14075 ;
14076 }
14077 GeneratedField::Aligned => {
14078 if aligned__.is_some() {
14079 return Err(serde::de::Error::duplicate_field("aligned"));
14080 }
14081 aligned__ = Some(map_.next_value()?);
14082 }
14083 }
14084 }
14085 Ok(SetSyncLogStoreAlignedRequest {
14086 job_id: job_id__.unwrap_or_default(),
14087 aligned: aligned__.unwrap_or_default(),
14088 })
14089 }
14090 }
14091 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
14092 }
14093}
14094impl serde::Serialize for SetSyncLogStoreAlignedResponse {
14095 #[allow(deprecated)]
14096 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14097 where
14098 S: serde::Serializer,
14099 {
14100 use serde::ser::SerializeStruct;
14101 let len = 0;
14102 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
14103 struct_ser.end()
14104 }
14105}
14106impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
14107 #[allow(deprecated)]
14108 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14109 where
14110 D: serde::Deserializer<'de>,
14111 {
14112 const FIELDS: &[&str] = &[
14113 ];
14114
14115 #[allow(clippy::enum_variant_names)]
14116 enum GeneratedField {
14117 }
14118 impl<'de> serde::Deserialize<'de> for GeneratedField {
14119 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14120 where
14121 D: serde::Deserializer<'de>,
14122 {
14123 struct GeneratedVisitor;
14124
14125 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14126 type Value = GeneratedField;
14127
14128 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14129 write!(formatter, "expected one of: {:?}", &FIELDS)
14130 }
14131
14132 #[allow(unused_variables)]
14133 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14134 where
14135 E: serde::de::Error,
14136 {
14137 Err(serde::de::Error::unknown_field(value, FIELDS))
14138 }
14139 }
14140 deserializer.deserialize_identifier(GeneratedVisitor)
14141 }
14142 }
14143 struct GeneratedVisitor;
14144 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14145 type Value = SetSyncLogStoreAlignedResponse;
14146
14147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14148 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
14149 }
14150
14151 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
14152 where
14153 V: serde::de::MapAccess<'de>,
14154 {
14155 while map_.next_key::<GeneratedField>()?.is_some() {
14156 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14157 }
14158 Ok(SetSyncLogStoreAlignedResponse {
14159 })
14160 }
14161 }
14162 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
14163 }
14164}
14165impl serde::Serialize for SetSystemParamRequest {
14166 #[allow(deprecated)]
14167 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14168 where
14169 S: serde::Serializer,
14170 {
14171 use serde::ser::SerializeStruct;
14172 let mut len = 0;
14173 if !self.param.is_empty() {
14174 len += 1;
14175 }
14176 if self.value.is_some() {
14177 len += 1;
14178 }
14179 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
14180 if !self.param.is_empty() {
14181 struct_ser.serialize_field("param", &self.param)?;
14182 }
14183 if let Some(v) = self.value.as_ref() {
14184 struct_ser.serialize_field("value", v)?;
14185 }
14186 struct_ser.end()
14187 }
14188}
14189impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
14190 #[allow(deprecated)]
14191 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14192 where
14193 D: serde::Deserializer<'de>,
14194 {
14195 const FIELDS: &[&str] = &[
14196 "param",
14197 "value",
14198 ];
14199
14200 #[allow(clippy::enum_variant_names)]
14201 enum GeneratedField {
14202 Param,
14203 Value,
14204 }
14205 impl<'de> serde::Deserialize<'de> for GeneratedField {
14206 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14207 where
14208 D: serde::Deserializer<'de>,
14209 {
14210 struct GeneratedVisitor;
14211
14212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14213 type Value = GeneratedField;
14214
14215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14216 write!(formatter, "expected one of: {:?}", &FIELDS)
14217 }
14218
14219 #[allow(unused_variables)]
14220 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14221 where
14222 E: serde::de::Error,
14223 {
14224 match value {
14225 "param" => Ok(GeneratedField::Param),
14226 "value" => Ok(GeneratedField::Value),
14227 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14228 }
14229 }
14230 }
14231 deserializer.deserialize_identifier(GeneratedVisitor)
14232 }
14233 }
14234 struct GeneratedVisitor;
14235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14236 type Value = SetSystemParamRequest;
14237
14238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14239 formatter.write_str("struct meta.SetSystemParamRequest")
14240 }
14241
14242 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
14243 where
14244 V: serde::de::MapAccess<'de>,
14245 {
14246 let mut param__ = None;
14247 let mut value__ = None;
14248 while let Some(k) = map_.next_key()? {
14249 match k {
14250 GeneratedField::Param => {
14251 if param__.is_some() {
14252 return Err(serde::de::Error::duplicate_field("param"));
14253 }
14254 param__ = Some(map_.next_value()?);
14255 }
14256 GeneratedField::Value => {
14257 if value__.is_some() {
14258 return Err(serde::de::Error::duplicate_field("value"));
14259 }
14260 value__ = map_.next_value()?;
14261 }
14262 }
14263 }
14264 Ok(SetSystemParamRequest {
14265 param: param__.unwrap_or_default(),
14266 value: value__,
14267 })
14268 }
14269 }
14270 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
14271 }
14272}
14273impl serde::Serialize for SetSystemParamResponse {
14274 #[allow(deprecated)]
14275 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14276 where
14277 S: serde::Serializer,
14278 {
14279 use serde::ser::SerializeStruct;
14280 let mut len = 0;
14281 if self.params.is_some() {
14282 len += 1;
14283 }
14284 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
14285 if let Some(v) = self.params.as_ref() {
14286 struct_ser.serialize_field("params", v)?;
14287 }
14288 struct_ser.end()
14289 }
14290}
14291impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
14292 #[allow(deprecated)]
14293 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14294 where
14295 D: serde::Deserializer<'de>,
14296 {
14297 const FIELDS: &[&str] = &[
14298 "params",
14299 ];
14300
14301 #[allow(clippy::enum_variant_names)]
14302 enum GeneratedField {
14303 Params,
14304 }
14305 impl<'de> serde::Deserialize<'de> for GeneratedField {
14306 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14307 where
14308 D: serde::Deserializer<'de>,
14309 {
14310 struct GeneratedVisitor;
14311
14312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14313 type Value = GeneratedField;
14314
14315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14316 write!(formatter, "expected one of: {:?}", &FIELDS)
14317 }
14318
14319 #[allow(unused_variables)]
14320 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14321 where
14322 E: serde::de::Error,
14323 {
14324 match value {
14325 "params" => Ok(GeneratedField::Params),
14326 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14327 }
14328 }
14329 }
14330 deserializer.deserialize_identifier(GeneratedVisitor)
14331 }
14332 }
14333 struct GeneratedVisitor;
14334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14335 type Value = SetSystemParamResponse;
14336
14337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14338 formatter.write_str("struct meta.SetSystemParamResponse")
14339 }
14340
14341 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
14342 where
14343 V: serde::de::MapAccess<'de>,
14344 {
14345 let mut params__ = None;
14346 while let Some(k) = map_.next_key()? {
14347 match k {
14348 GeneratedField::Params => {
14349 if params__.is_some() {
14350 return Err(serde::de::Error::duplicate_field("params"));
14351 }
14352 params__ = map_.next_value()?;
14353 }
14354 }
14355 }
14356 Ok(SetSystemParamResponse {
14357 params: params__,
14358 })
14359 }
14360 }
14361 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
14362 }
14363}
14364impl serde::Serialize for SubscribeRequest {
14365 #[allow(deprecated)]
14366 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14367 where
14368 S: serde::Serializer,
14369 {
14370 use serde::ser::SerializeStruct;
14371 let mut len = 0;
14372 if self.subscribe_type != 0 {
14373 len += 1;
14374 }
14375 if self.host.is_some() {
14376 len += 1;
14377 }
14378 if self.worker_id != 0 {
14379 len += 1;
14380 }
14381 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
14382 if self.subscribe_type != 0 {
14383 let v = SubscribeType::try_from(self.subscribe_type)
14384 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
14385 struct_ser.serialize_field("subscribeType", &v)?;
14386 }
14387 if let Some(v) = self.host.as_ref() {
14388 struct_ser.serialize_field("host", v)?;
14389 }
14390 if self.worker_id != 0 {
14391 struct_ser.serialize_field("workerId", &self.worker_id)?;
14392 }
14393 struct_ser.end()
14394 }
14395}
14396impl<'de> serde::Deserialize<'de> for SubscribeRequest {
14397 #[allow(deprecated)]
14398 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14399 where
14400 D: serde::Deserializer<'de>,
14401 {
14402 const FIELDS: &[&str] = &[
14403 "subscribe_type",
14404 "subscribeType",
14405 "host",
14406 "worker_id",
14407 "workerId",
14408 ];
14409
14410 #[allow(clippy::enum_variant_names)]
14411 enum GeneratedField {
14412 SubscribeType,
14413 Host,
14414 WorkerId,
14415 }
14416 impl<'de> serde::Deserialize<'de> for GeneratedField {
14417 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14418 where
14419 D: serde::Deserializer<'de>,
14420 {
14421 struct GeneratedVisitor;
14422
14423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14424 type Value = GeneratedField;
14425
14426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14427 write!(formatter, "expected one of: {:?}", &FIELDS)
14428 }
14429
14430 #[allow(unused_variables)]
14431 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14432 where
14433 E: serde::de::Error,
14434 {
14435 match value {
14436 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
14437 "host" => Ok(GeneratedField::Host),
14438 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
14439 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14440 }
14441 }
14442 }
14443 deserializer.deserialize_identifier(GeneratedVisitor)
14444 }
14445 }
14446 struct GeneratedVisitor;
14447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14448 type Value = SubscribeRequest;
14449
14450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14451 formatter.write_str("struct meta.SubscribeRequest")
14452 }
14453
14454 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
14455 where
14456 V: serde::de::MapAccess<'de>,
14457 {
14458 let mut subscribe_type__ = None;
14459 let mut host__ = None;
14460 let mut worker_id__ = None;
14461 while let Some(k) = map_.next_key()? {
14462 match k {
14463 GeneratedField::SubscribeType => {
14464 if subscribe_type__.is_some() {
14465 return Err(serde::de::Error::duplicate_field("subscribeType"));
14466 }
14467 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
14468 }
14469 GeneratedField::Host => {
14470 if host__.is_some() {
14471 return Err(serde::de::Error::duplicate_field("host"));
14472 }
14473 host__ = map_.next_value()?;
14474 }
14475 GeneratedField::WorkerId => {
14476 if worker_id__.is_some() {
14477 return Err(serde::de::Error::duplicate_field("workerId"));
14478 }
14479 worker_id__ =
14480 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14481 ;
14482 }
14483 }
14484 }
14485 Ok(SubscribeRequest {
14486 subscribe_type: subscribe_type__.unwrap_or_default(),
14487 host: host__,
14488 worker_id: worker_id__.unwrap_or_default(),
14489 })
14490 }
14491 }
14492 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
14493 }
14494}
14495impl serde::Serialize for SubscribeResponse {
14496 #[allow(deprecated)]
14497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14498 where
14499 S: serde::Serializer,
14500 {
14501 use serde::ser::SerializeStruct;
14502 let mut len = 0;
14503 if self.status.is_some() {
14504 len += 1;
14505 }
14506 if self.operation != 0 {
14507 len += 1;
14508 }
14509 if self.version != 0 {
14510 len += 1;
14511 }
14512 if self.info.is_some() {
14513 len += 1;
14514 }
14515 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
14516 if let Some(v) = self.status.as_ref() {
14517 struct_ser.serialize_field("status", v)?;
14518 }
14519 if self.operation != 0 {
14520 let v = subscribe_response::Operation::try_from(self.operation)
14521 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
14522 struct_ser.serialize_field("operation", &v)?;
14523 }
14524 if self.version != 0 {
14525 #[allow(clippy::needless_borrow)]
14526 #[allow(clippy::needless_borrows_for_generic_args)]
14527 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
14528 }
14529 if let Some(v) = self.info.as_ref() {
14530 match v {
14531 subscribe_response::Info::Database(v) => {
14532 struct_ser.serialize_field("database", v)?;
14533 }
14534 subscribe_response::Info::Schema(v) => {
14535 struct_ser.serialize_field("schema", v)?;
14536 }
14537 subscribe_response::Info::Function(v) => {
14538 struct_ser.serialize_field("function", v)?;
14539 }
14540 subscribe_response::Info::User(v) => {
14541 struct_ser.serialize_field("user", v)?;
14542 }
14543 subscribe_response::Info::SessionParam(v) => {
14544 struct_ser.serialize_field("sessionParam", v)?;
14545 }
14546 subscribe_response::Info::Node(v) => {
14547 struct_ser.serialize_field("node", v)?;
14548 }
14549 subscribe_response::Info::HummockVersionDeltas(v) => {
14550 struct_ser.serialize_field("hummockVersionDeltas", v)?;
14551 }
14552 subscribe_response::Info::Snapshot(v) => {
14553 struct_ser.serialize_field("snapshot", v)?;
14554 }
14555 subscribe_response::Info::MetaBackupManifestId(v) => {
14556 struct_ser.serialize_field("metaBackupManifestId", v)?;
14557 }
14558 subscribe_response::Info::SystemParams(v) => {
14559 struct_ser.serialize_field("systemParams", v)?;
14560 }
14561 subscribe_response::Info::HummockWriteLimits(v) => {
14562 struct_ser.serialize_field("hummockWriteLimits", v)?;
14563 }
14564 subscribe_response::Info::ObjectGroup(v) => {
14565 struct_ser.serialize_field("objectGroup", v)?;
14566 }
14567 subscribe_response::Info::Connection(v) => {
14568 struct_ser.serialize_field("connection", v)?;
14569 }
14570 subscribe_response::Info::HummockStats(v) => {
14571 struct_ser.serialize_field("hummockStats", v)?;
14572 }
14573 subscribe_response::Info::Recovery(v) => {
14574 struct_ser.serialize_field("recovery", v)?;
14575 }
14576 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
14577 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
14578 }
14579 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
14580 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
14581 }
14582 subscribe_response::Info::Secret(v) => {
14583 struct_ser.serialize_field("secret", v)?;
14584 }
14585 subscribe_response::Info::ComputeNodeTotalCpuCount(v) => {
14586 #[allow(clippy::needless_borrow)]
14587 #[allow(clippy::needless_borrows_for_generic_args)]
14588 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&v).as_str())?;
14589 }
14590 }
14591 }
14592 struct_ser.end()
14593 }
14594}
14595impl<'de> serde::Deserialize<'de> for SubscribeResponse {
14596 #[allow(deprecated)]
14597 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14598 where
14599 D: serde::Deserializer<'de>,
14600 {
14601 const FIELDS: &[&str] = &[
14602 "status",
14603 "operation",
14604 "version",
14605 "database",
14606 "schema",
14607 "function",
14608 "user",
14609 "session_param",
14610 "sessionParam",
14611 "node",
14612 "hummock_version_deltas",
14613 "hummockVersionDeltas",
14614 "snapshot",
14615 "meta_backup_manifest_id",
14616 "metaBackupManifestId",
14617 "system_params",
14618 "systemParams",
14619 "hummock_write_limits",
14620 "hummockWriteLimits",
14621 "object_group",
14622 "objectGroup",
14623 "connection",
14624 "hummock_stats",
14625 "hummockStats",
14626 "recovery",
14627 "streaming_worker_slot_mapping",
14628 "streamingWorkerSlotMapping",
14629 "serving_worker_slot_mappings",
14630 "servingWorkerSlotMappings",
14631 "secret",
14632 "compute_node_total_cpu_count",
14633 "computeNodeTotalCpuCount",
14634 ];
14635
14636 #[allow(clippy::enum_variant_names)]
14637 enum GeneratedField {
14638 Status,
14639 Operation,
14640 Version,
14641 Database,
14642 Schema,
14643 Function,
14644 User,
14645 SessionParam,
14646 Node,
14647 HummockVersionDeltas,
14648 Snapshot,
14649 MetaBackupManifestId,
14650 SystemParams,
14651 HummockWriteLimits,
14652 ObjectGroup,
14653 Connection,
14654 HummockStats,
14655 Recovery,
14656 StreamingWorkerSlotMapping,
14657 ServingWorkerSlotMappings,
14658 Secret,
14659 ComputeNodeTotalCpuCount,
14660 }
14661 impl<'de> serde::Deserialize<'de> for GeneratedField {
14662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14663 where
14664 D: serde::Deserializer<'de>,
14665 {
14666 struct GeneratedVisitor;
14667
14668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14669 type Value = GeneratedField;
14670
14671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14672 write!(formatter, "expected one of: {:?}", &FIELDS)
14673 }
14674
14675 #[allow(unused_variables)]
14676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14677 where
14678 E: serde::de::Error,
14679 {
14680 match value {
14681 "status" => Ok(GeneratedField::Status),
14682 "operation" => Ok(GeneratedField::Operation),
14683 "version" => Ok(GeneratedField::Version),
14684 "database" => Ok(GeneratedField::Database),
14685 "schema" => Ok(GeneratedField::Schema),
14686 "function" => Ok(GeneratedField::Function),
14687 "user" => Ok(GeneratedField::User),
14688 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
14689 "node" => Ok(GeneratedField::Node),
14690 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
14691 "snapshot" => Ok(GeneratedField::Snapshot),
14692 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
14693 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
14694 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
14695 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
14696 "connection" => Ok(GeneratedField::Connection),
14697 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
14698 "recovery" => Ok(GeneratedField::Recovery),
14699 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
14700 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
14701 "secret" => Ok(GeneratedField::Secret),
14702 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
14703 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14704 }
14705 }
14706 }
14707 deserializer.deserialize_identifier(GeneratedVisitor)
14708 }
14709 }
14710 struct GeneratedVisitor;
14711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14712 type Value = SubscribeResponse;
14713
14714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14715 formatter.write_str("struct meta.SubscribeResponse")
14716 }
14717
14718 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
14719 where
14720 V: serde::de::MapAccess<'de>,
14721 {
14722 let mut status__ = None;
14723 let mut operation__ = None;
14724 let mut version__ = None;
14725 let mut info__ = None;
14726 while let Some(k) = map_.next_key()? {
14727 match k {
14728 GeneratedField::Status => {
14729 if status__.is_some() {
14730 return Err(serde::de::Error::duplicate_field("status"));
14731 }
14732 status__ = map_.next_value()?;
14733 }
14734 GeneratedField::Operation => {
14735 if operation__.is_some() {
14736 return Err(serde::de::Error::duplicate_field("operation"));
14737 }
14738 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
14739 }
14740 GeneratedField::Version => {
14741 if version__.is_some() {
14742 return Err(serde::de::Error::duplicate_field("version"));
14743 }
14744 version__ =
14745 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14746 ;
14747 }
14748 GeneratedField::Database => {
14749 if info__.is_some() {
14750 return Err(serde::de::Error::duplicate_field("database"));
14751 }
14752 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
14753;
14754 }
14755 GeneratedField::Schema => {
14756 if info__.is_some() {
14757 return Err(serde::de::Error::duplicate_field("schema"));
14758 }
14759 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
14760;
14761 }
14762 GeneratedField::Function => {
14763 if info__.is_some() {
14764 return Err(serde::de::Error::duplicate_field("function"));
14765 }
14766 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
14767;
14768 }
14769 GeneratedField::User => {
14770 if info__.is_some() {
14771 return Err(serde::de::Error::duplicate_field("user"));
14772 }
14773 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
14774;
14775 }
14776 GeneratedField::SessionParam => {
14777 if info__.is_some() {
14778 return Err(serde::de::Error::duplicate_field("sessionParam"));
14779 }
14780 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
14781;
14782 }
14783 GeneratedField::Node => {
14784 if info__.is_some() {
14785 return Err(serde::de::Error::duplicate_field("node"));
14786 }
14787 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
14788;
14789 }
14790 GeneratedField::HummockVersionDeltas => {
14791 if info__.is_some() {
14792 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
14793 }
14794 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
14795;
14796 }
14797 GeneratedField::Snapshot => {
14798 if info__.is_some() {
14799 return Err(serde::de::Error::duplicate_field("snapshot"));
14800 }
14801 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
14802;
14803 }
14804 GeneratedField::MetaBackupManifestId => {
14805 if info__.is_some() {
14806 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14807 }
14808 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
14809;
14810 }
14811 GeneratedField::SystemParams => {
14812 if info__.is_some() {
14813 return Err(serde::de::Error::duplicate_field("systemParams"));
14814 }
14815 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
14816;
14817 }
14818 GeneratedField::HummockWriteLimits => {
14819 if info__.is_some() {
14820 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14821 }
14822 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
14823;
14824 }
14825 GeneratedField::ObjectGroup => {
14826 if info__.is_some() {
14827 return Err(serde::de::Error::duplicate_field("objectGroup"));
14828 }
14829 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
14830;
14831 }
14832 GeneratedField::Connection => {
14833 if info__.is_some() {
14834 return Err(serde::de::Error::duplicate_field("connection"));
14835 }
14836 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
14837;
14838 }
14839 GeneratedField::HummockStats => {
14840 if info__.is_some() {
14841 return Err(serde::de::Error::duplicate_field("hummockStats"));
14842 }
14843 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
14844;
14845 }
14846 GeneratedField::Recovery => {
14847 if info__.is_some() {
14848 return Err(serde::de::Error::duplicate_field("recovery"));
14849 }
14850 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
14851;
14852 }
14853 GeneratedField::StreamingWorkerSlotMapping => {
14854 if info__.is_some() {
14855 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
14856 }
14857 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
14858;
14859 }
14860 GeneratedField::ServingWorkerSlotMappings => {
14861 if info__.is_some() {
14862 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14863 }
14864 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
14865;
14866 }
14867 GeneratedField::Secret => {
14868 if info__.is_some() {
14869 return Err(serde::de::Error::duplicate_field("secret"));
14870 }
14871 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
14872;
14873 }
14874 GeneratedField::ComputeNodeTotalCpuCount => {
14875 if info__.is_some() {
14876 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
14877 }
14878 info__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| subscribe_response::Info::ComputeNodeTotalCpuCount(x.0));
14879 }
14880 }
14881 }
14882 Ok(SubscribeResponse {
14883 status: status__,
14884 operation: operation__.unwrap_or_default(),
14885 version: version__.unwrap_or_default(),
14886 info: info__,
14887 })
14888 }
14889 }
14890 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
14891 }
14892}
14893impl serde::Serialize for subscribe_response::Operation {
14894 #[allow(deprecated)]
14895 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14896 where
14897 S: serde::Serializer,
14898 {
14899 let variant = match self {
14900 Self::Unspecified => "UNSPECIFIED",
14901 Self::Add => "ADD",
14902 Self::Delete => "DELETE",
14903 Self::Update => "UPDATE",
14904 Self::Snapshot => "SNAPSHOT",
14905 };
14906 serializer.serialize_str(variant)
14907 }
14908}
14909impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
14910 #[allow(deprecated)]
14911 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14912 where
14913 D: serde::Deserializer<'de>,
14914 {
14915 const FIELDS: &[&str] = &[
14916 "UNSPECIFIED",
14917 "ADD",
14918 "DELETE",
14919 "UPDATE",
14920 "SNAPSHOT",
14921 ];
14922
14923 struct GeneratedVisitor;
14924
14925 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14926 type Value = subscribe_response::Operation;
14927
14928 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14929 write!(formatter, "expected one of: {:?}", &FIELDS)
14930 }
14931
14932 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14933 where
14934 E: serde::de::Error,
14935 {
14936 i32::try_from(v)
14937 .ok()
14938 .and_then(|x| x.try_into().ok())
14939 .ok_or_else(|| {
14940 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14941 })
14942 }
14943
14944 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14945 where
14946 E: serde::de::Error,
14947 {
14948 i32::try_from(v)
14949 .ok()
14950 .and_then(|x| x.try_into().ok())
14951 .ok_or_else(|| {
14952 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14953 })
14954 }
14955
14956 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14957 where
14958 E: serde::de::Error,
14959 {
14960 match value {
14961 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
14962 "ADD" => Ok(subscribe_response::Operation::Add),
14963 "DELETE" => Ok(subscribe_response::Operation::Delete),
14964 "UPDATE" => Ok(subscribe_response::Operation::Update),
14965 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
14966 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14967 }
14968 }
14969 }
14970 deserializer.deserialize_any(GeneratedVisitor)
14971 }
14972}
14973impl serde::Serialize for SubscribeType {
14974 #[allow(deprecated)]
14975 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14976 where
14977 S: serde::Serializer,
14978 {
14979 let variant = match self {
14980 Self::Unspecified => "UNSPECIFIED",
14981 Self::Frontend => "FRONTEND",
14982 Self::Hummock => "HUMMOCK",
14983 Self::Compactor => "COMPACTOR",
14984 Self::Compute => "COMPUTE",
14985 };
14986 serializer.serialize_str(variant)
14987 }
14988}
14989impl<'de> serde::Deserialize<'de> for SubscribeType {
14990 #[allow(deprecated)]
14991 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14992 where
14993 D: serde::Deserializer<'de>,
14994 {
14995 const FIELDS: &[&str] = &[
14996 "UNSPECIFIED",
14997 "FRONTEND",
14998 "HUMMOCK",
14999 "COMPACTOR",
15000 "COMPUTE",
15001 ];
15002
15003 struct GeneratedVisitor;
15004
15005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15006 type Value = SubscribeType;
15007
15008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15009 write!(formatter, "expected one of: {:?}", &FIELDS)
15010 }
15011
15012 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15013 where
15014 E: serde::de::Error,
15015 {
15016 i32::try_from(v)
15017 .ok()
15018 .and_then(|x| x.try_into().ok())
15019 .ok_or_else(|| {
15020 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15021 })
15022 }
15023
15024 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15025 where
15026 E: serde::de::Error,
15027 {
15028 i32::try_from(v)
15029 .ok()
15030 .and_then(|x| x.try_into().ok())
15031 .ok_or_else(|| {
15032 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15033 })
15034 }
15035
15036 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15037 where
15038 E: serde::de::Error,
15039 {
15040 match value {
15041 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
15042 "FRONTEND" => Ok(SubscribeType::Frontend),
15043 "HUMMOCK" => Ok(SubscribeType::Hummock),
15044 "COMPACTOR" => Ok(SubscribeType::Compactor),
15045 "COMPUTE" => Ok(SubscribeType::Compute),
15046 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15047 }
15048 }
15049 }
15050 deserializer.deserialize_any(GeneratedVisitor)
15051 }
15052}
15053impl serde::Serialize for SystemParams {
15054 #[allow(deprecated)]
15055 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15056 where
15057 S: serde::Serializer,
15058 {
15059 use serde::ser::SerializeStruct;
15060 let mut len = 0;
15061 if self.barrier_interval_ms.is_some() {
15062 len += 1;
15063 }
15064 if self.checkpoint_frequency.is_some() {
15065 len += 1;
15066 }
15067 if self.sstable_size_mb.is_some() {
15068 len += 1;
15069 }
15070 if self.block_size_kb.is_some() {
15071 len += 1;
15072 }
15073 if self.bloom_false_positive.is_some() {
15074 len += 1;
15075 }
15076 if self.state_store.is_some() {
15077 len += 1;
15078 }
15079 if self.data_directory.is_some() {
15080 len += 1;
15081 }
15082 if self.backup_storage_url.is_some() {
15083 len += 1;
15084 }
15085 if self.backup_storage_directory.is_some() {
15086 len += 1;
15087 }
15088 if self.telemetry_enabled.is_some() {
15089 len += 1;
15090 }
15091 if self.parallel_compact_size_mb.is_some() {
15092 len += 1;
15093 }
15094 if self.max_concurrent_creating_streaming_jobs.is_some() {
15095 len += 1;
15096 }
15097 if self.pause_on_next_bootstrap.is_some() {
15098 len += 1;
15099 }
15100 if self.wasm_storage_url.is_some() {
15101 len += 1;
15102 }
15103 if self.enable_tracing.is_some() {
15104 len += 1;
15105 }
15106 if self.use_new_object_prefix_strategy.is_some() {
15107 len += 1;
15108 }
15109 if self.license_key.is_some() {
15110 len += 1;
15111 }
15112 if self.time_travel_retention_ms.is_some() {
15113 len += 1;
15114 }
15115 if self.adaptive_parallelism_strategy.is_some() {
15116 len += 1;
15117 }
15118 if self.per_database_isolation.is_some() {
15119 len += 1;
15120 }
15121 if self.enforce_secret.is_some() {
15122 len += 1;
15123 }
15124 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
15125 if let Some(v) = self.barrier_interval_ms.as_ref() {
15126 struct_ser.serialize_field("barrierIntervalMs", v)?;
15127 }
15128 if let Some(v) = self.checkpoint_frequency.as_ref() {
15129 #[allow(clippy::needless_borrow)]
15130 #[allow(clippy::needless_borrows_for_generic_args)]
15131 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
15132 }
15133 if let Some(v) = self.sstable_size_mb.as_ref() {
15134 struct_ser.serialize_field("sstableSizeMb", v)?;
15135 }
15136 if let Some(v) = self.block_size_kb.as_ref() {
15137 struct_ser.serialize_field("blockSizeKb", v)?;
15138 }
15139 if let Some(v) = self.bloom_false_positive.as_ref() {
15140 struct_ser.serialize_field("bloomFalsePositive", v)?;
15141 }
15142 if let Some(v) = self.state_store.as_ref() {
15143 struct_ser.serialize_field("stateStore", v)?;
15144 }
15145 if let Some(v) = self.data_directory.as_ref() {
15146 struct_ser.serialize_field("dataDirectory", v)?;
15147 }
15148 if let Some(v) = self.backup_storage_url.as_ref() {
15149 struct_ser.serialize_field("backupStorageUrl", v)?;
15150 }
15151 if let Some(v) = self.backup_storage_directory.as_ref() {
15152 struct_ser.serialize_field("backupStorageDirectory", v)?;
15153 }
15154 if let Some(v) = self.telemetry_enabled.as_ref() {
15155 struct_ser.serialize_field("telemetryEnabled", v)?;
15156 }
15157 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
15158 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
15159 }
15160 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
15161 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
15162 }
15163 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
15164 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
15165 }
15166 if let Some(v) = self.wasm_storage_url.as_ref() {
15167 struct_ser.serialize_field("wasmStorageUrl", v)?;
15168 }
15169 if let Some(v) = self.enable_tracing.as_ref() {
15170 struct_ser.serialize_field("enableTracing", v)?;
15171 }
15172 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
15173 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
15174 }
15175 if let Some(v) = self.license_key.as_ref() {
15176 struct_ser.serialize_field("licenseKey", v)?;
15177 }
15178 if let Some(v) = self.time_travel_retention_ms.as_ref() {
15179 #[allow(clippy::needless_borrow)]
15180 #[allow(clippy::needless_borrows_for_generic_args)]
15181 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
15182 }
15183 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
15184 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
15185 }
15186 if let Some(v) = self.per_database_isolation.as_ref() {
15187 struct_ser.serialize_field("perDatabaseIsolation", v)?;
15188 }
15189 if let Some(v) = self.enforce_secret.as_ref() {
15190 struct_ser.serialize_field("enforceSecret", v)?;
15191 }
15192 struct_ser.end()
15193 }
15194}
15195impl<'de> serde::Deserialize<'de> for SystemParams {
15196 #[allow(deprecated)]
15197 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15198 where
15199 D: serde::Deserializer<'de>,
15200 {
15201 const FIELDS: &[&str] = &[
15202 "barrier_interval_ms",
15203 "barrierIntervalMs",
15204 "checkpoint_frequency",
15205 "checkpointFrequency",
15206 "sstable_size_mb",
15207 "sstableSizeMb",
15208 "block_size_kb",
15209 "blockSizeKb",
15210 "bloom_false_positive",
15211 "bloomFalsePositive",
15212 "state_store",
15213 "stateStore",
15214 "data_directory",
15215 "dataDirectory",
15216 "backup_storage_url",
15217 "backupStorageUrl",
15218 "backup_storage_directory",
15219 "backupStorageDirectory",
15220 "telemetry_enabled",
15221 "telemetryEnabled",
15222 "parallel_compact_size_mb",
15223 "parallelCompactSizeMb",
15224 "max_concurrent_creating_streaming_jobs",
15225 "maxConcurrentCreatingStreamingJobs",
15226 "pause_on_next_bootstrap",
15227 "pauseOnNextBootstrap",
15228 "wasm_storage_url",
15229 "wasmStorageUrl",
15230 "enable_tracing",
15231 "enableTracing",
15232 "use_new_object_prefix_strategy",
15233 "useNewObjectPrefixStrategy",
15234 "license_key",
15235 "licenseKey",
15236 "time_travel_retention_ms",
15237 "timeTravelRetentionMs",
15238 "adaptive_parallelism_strategy",
15239 "adaptiveParallelismStrategy",
15240 "per_database_isolation",
15241 "perDatabaseIsolation",
15242 "enforce_secret",
15243 "enforceSecret",
15244 ];
15245
15246 #[allow(clippy::enum_variant_names)]
15247 enum GeneratedField {
15248 BarrierIntervalMs,
15249 CheckpointFrequency,
15250 SstableSizeMb,
15251 BlockSizeKb,
15252 BloomFalsePositive,
15253 StateStore,
15254 DataDirectory,
15255 BackupStorageUrl,
15256 BackupStorageDirectory,
15257 TelemetryEnabled,
15258 ParallelCompactSizeMb,
15259 MaxConcurrentCreatingStreamingJobs,
15260 PauseOnNextBootstrap,
15261 WasmStorageUrl,
15262 EnableTracing,
15263 UseNewObjectPrefixStrategy,
15264 LicenseKey,
15265 TimeTravelRetentionMs,
15266 AdaptiveParallelismStrategy,
15267 PerDatabaseIsolation,
15268 EnforceSecret,
15269 }
15270 impl<'de> serde::Deserialize<'de> for GeneratedField {
15271 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15272 where
15273 D: serde::Deserializer<'de>,
15274 {
15275 struct GeneratedVisitor;
15276
15277 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15278 type Value = GeneratedField;
15279
15280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15281 write!(formatter, "expected one of: {:?}", &FIELDS)
15282 }
15283
15284 #[allow(unused_variables)]
15285 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15286 where
15287 E: serde::de::Error,
15288 {
15289 match value {
15290 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
15291 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
15292 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
15293 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
15294 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
15295 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
15296 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
15297 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
15298 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
15299 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
15300 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
15301 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
15302 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
15303 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
15304 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
15305 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
15306 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
15307 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
15308 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
15309 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
15310 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
15311 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15312 }
15313 }
15314 }
15315 deserializer.deserialize_identifier(GeneratedVisitor)
15316 }
15317 }
15318 struct GeneratedVisitor;
15319 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15320 type Value = SystemParams;
15321
15322 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15323 formatter.write_str("struct meta.SystemParams")
15324 }
15325
15326 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
15327 where
15328 V: serde::de::MapAccess<'de>,
15329 {
15330 let mut barrier_interval_ms__ = None;
15331 let mut checkpoint_frequency__ = None;
15332 let mut sstable_size_mb__ = None;
15333 let mut block_size_kb__ = None;
15334 let mut bloom_false_positive__ = None;
15335 let mut state_store__ = None;
15336 let mut data_directory__ = None;
15337 let mut backup_storage_url__ = None;
15338 let mut backup_storage_directory__ = None;
15339 let mut telemetry_enabled__ = None;
15340 let mut parallel_compact_size_mb__ = None;
15341 let mut max_concurrent_creating_streaming_jobs__ = None;
15342 let mut pause_on_next_bootstrap__ = None;
15343 let mut wasm_storage_url__ = None;
15344 let mut enable_tracing__ = None;
15345 let mut use_new_object_prefix_strategy__ = None;
15346 let mut license_key__ = None;
15347 let mut time_travel_retention_ms__ = None;
15348 let mut adaptive_parallelism_strategy__ = None;
15349 let mut per_database_isolation__ = None;
15350 let mut enforce_secret__ = None;
15351 while let Some(k) = map_.next_key()? {
15352 match k {
15353 GeneratedField::BarrierIntervalMs => {
15354 if barrier_interval_ms__.is_some() {
15355 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
15356 }
15357 barrier_interval_ms__ =
15358 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15359 ;
15360 }
15361 GeneratedField::CheckpointFrequency => {
15362 if checkpoint_frequency__.is_some() {
15363 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
15364 }
15365 checkpoint_frequency__ =
15366 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15367 ;
15368 }
15369 GeneratedField::SstableSizeMb => {
15370 if sstable_size_mb__.is_some() {
15371 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
15372 }
15373 sstable_size_mb__ =
15374 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15375 ;
15376 }
15377 GeneratedField::BlockSizeKb => {
15378 if block_size_kb__.is_some() {
15379 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
15380 }
15381 block_size_kb__ =
15382 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15383 ;
15384 }
15385 GeneratedField::BloomFalsePositive => {
15386 if bloom_false_positive__.is_some() {
15387 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
15388 }
15389 bloom_false_positive__ =
15390 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15391 ;
15392 }
15393 GeneratedField::StateStore => {
15394 if state_store__.is_some() {
15395 return Err(serde::de::Error::duplicate_field("stateStore"));
15396 }
15397 state_store__ = map_.next_value()?;
15398 }
15399 GeneratedField::DataDirectory => {
15400 if data_directory__.is_some() {
15401 return Err(serde::de::Error::duplicate_field("dataDirectory"));
15402 }
15403 data_directory__ = map_.next_value()?;
15404 }
15405 GeneratedField::BackupStorageUrl => {
15406 if backup_storage_url__.is_some() {
15407 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
15408 }
15409 backup_storage_url__ = map_.next_value()?;
15410 }
15411 GeneratedField::BackupStorageDirectory => {
15412 if backup_storage_directory__.is_some() {
15413 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
15414 }
15415 backup_storage_directory__ = map_.next_value()?;
15416 }
15417 GeneratedField::TelemetryEnabled => {
15418 if telemetry_enabled__.is_some() {
15419 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
15420 }
15421 telemetry_enabled__ = map_.next_value()?;
15422 }
15423 GeneratedField::ParallelCompactSizeMb => {
15424 if parallel_compact_size_mb__.is_some() {
15425 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
15426 }
15427 parallel_compact_size_mb__ =
15428 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15429 ;
15430 }
15431 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
15432 if max_concurrent_creating_streaming_jobs__.is_some() {
15433 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
15434 }
15435 max_concurrent_creating_streaming_jobs__ =
15436 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15437 ;
15438 }
15439 GeneratedField::PauseOnNextBootstrap => {
15440 if pause_on_next_bootstrap__.is_some() {
15441 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
15442 }
15443 pause_on_next_bootstrap__ = map_.next_value()?;
15444 }
15445 GeneratedField::WasmStorageUrl => {
15446 if wasm_storage_url__.is_some() {
15447 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
15448 }
15449 wasm_storage_url__ = map_.next_value()?;
15450 }
15451 GeneratedField::EnableTracing => {
15452 if enable_tracing__.is_some() {
15453 return Err(serde::de::Error::duplicate_field("enableTracing"));
15454 }
15455 enable_tracing__ = map_.next_value()?;
15456 }
15457 GeneratedField::UseNewObjectPrefixStrategy => {
15458 if use_new_object_prefix_strategy__.is_some() {
15459 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
15460 }
15461 use_new_object_prefix_strategy__ = map_.next_value()?;
15462 }
15463 GeneratedField::LicenseKey => {
15464 if license_key__.is_some() {
15465 return Err(serde::de::Error::duplicate_field("licenseKey"));
15466 }
15467 license_key__ = map_.next_value()?;
15468 }
15469 GeneratedField::TimeTravelRetentionMs => {
15470 if time_travel_retention_ms__.is_some() {
15471 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
15472 }
15473 time_travel_retention_ms__ =
15474 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15475 ;
15476 }
15477 GeneratedField::AdaptiveParallelismStrategy => {
15478 if adaptive_parallelism_strategy__.is_some() {
15479 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
15480 }
15481 adaptive_parallelism_strategy__ = map_.next_value()?;
15482 }
15483 GeneratedField::PerDatabaseIsolation => {
15484 if per_database_isolation__.is_some() {
15485 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
15486 }
15487 per_database_isolation__ = map_.next_value()?;
15488 }
15489 GeneratedField::EnforceSecret => {
15490 if enforce_secret__.is_some() {
15491 return Err(serde::de::Error::duplicate_field("enforceSecret"));
15492 }
15493 enforce_secret__ = map_.next_value()?;
15494 }
15495 }
15496 }
15497 Ok(SystemParams {
15498 barrier_interval_ms: barrier_interval_ms__,
15499 checkpoint_frequency: checkpoint_frequency__,
15500 sstable_size_mb: sstable_size_mb__,
15501 block_size_kb: block_size_kb__,
15502 bloom_false_positive: bloom_false_positive__,
15503 state_store: state_store__,
15504 data_directory: data_directory__,
15505 backup_storage_url: backup_storage_url__,
15506 backup_storage_directory: backup_storage_directory__,
15507 telemetry_enabled: telemetry_enabled__,
15508 parallel_compact_size_mb: parallel_compact_size_mb__,
15509 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
15510 pause_on_next_bootstrap: pause_on_next_bootstrap__,
15511 wasm_storage_url: wasm_storage_url__,
15512 enable_tracing: enable_tracing__,
15513 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
15514 license_key: license_key__,
15515 time_travel_retention_ms: time_travel_retention_ms__,
15516 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
15517 per_database_isolation: per_database_isolation__,
15518 enforce_secret: enforce_secret__,
15519 })
15520 }
15521 }
15522 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
15523 }
15524}
15525impl serde::Serialize for TableFragments {
15526 #[allow(deprecated)]
15527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15528 where
15529 S: serde::Serializer,
15530 {
15531 use serde::ser::SerializeStruct;
15532 let mut len = 0;
15533 if self.table_id != 0 {
15534 len += 1;
15535 }
15536 if self.state != 0 {
15537 len += 1;
15538 }
15539 if !self.fragments.is_empty() {
15540 len += 1;
15541 }
15542 if !self.actor_status.is_empty() {
15543 len += 1;
15544 }
15545 if self.ctx.is_some() {
15546 len += 1;
15547 }
15548 if self.parallelism.is_some() {
15549 len += 1;
15550 }
15551 if self.max_parallelism.is_some() {
15552 len += 1;
15553 }
15554 if !self.node_label.is_empty() {
15555 len += 1;
15556 }
15557 if self.backfill_done {
15558 len += 1;
15559 }
15560 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
15561 if self.table_id != 0 {
15562 struct_ser.serialize_field("tableId", &self.table_id)?;
15563 }
15564 if self.state != 0 {
15565 let v = table_fragments::State::try_from(self.state)
15566 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15567 struct_ser.serialize_field("state", &v)?;
15568 }
15569 if !self.fragments.is_empty() {
15570 struct_ser.serialize_field("fragments", &self.fragments)?;
15571 }
15572 if !self.actor_status.is_empty() {
15573 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
15574 }
15575 if let Some(v) = self.ctx.as_ref() {
15576 struct_ser.serialize_field("ctx", v)?;
15577 }
15578 if let Some(v) = self.parallelism.as_ref() {
15579 struct_ser.serialize_field("parallelism", v)?;
15580 }
15581 if let Some(v) = self.max_parallelism.as_ref() {
15582 struct_ser.serialize_field("maxParallelism", v)?;
15583 }
15584 if !self.node_label.is_empty() {
15585 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
15586 }
15587 if self.backfill_done {
15588 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
15589 }
15590 struct_ser.end()
15591 }
15592}
15593impl<'de> serde::Deserialize<'de> for TableFragments {
15594 #[allow(deprecated)]
15595 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15596 where
15597 D: serde::Deserializer<'de>,
15598 {
15599 const FIELDS: &[&str] = &[
15600 "table_id",
15601 "tableId",
15602 "state",
15603 "fragments",
15604 "actor_status",
15605 "actorStatus",
15606 "ctx",
15607 "parallelism",
15608 "max_parallelism",
15609 "maxParallelism",
15610 "node_label",
15611 "nodeLabel",
15612 "backfill_done",
15613 "backfillDone",
15614 ];
15615
15616 #[allow(clippy::enum_variant_names)]
15617 enum GeneratedField {
15618 TableId,
15619 State,
15620 Fragments,
15621 ActorStatus,
15622 Ctx,
15623 Parallelism,
15624 MaxParallelism,
15625 NodeLabel,
15626 BackfillDone,
15627 }
15628 impl<'de> serde::Deserialize<'de> for GeneratedField {
15629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15630 where
15631 D: serde::Deserializer<'de>,
15632 {
15633 struct GeneratedVisitor;
15634
15635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15636 type Value = GeneratedField;
15637
15638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15639 write!(formatter, "expected one of: {:?}", &FIELDS)
15640 }
15641
15642 #[allow(unused_variables)]
15643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15644 where
15645 E: serde::de::Error,
15646 {
15647 match value {
15648 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15649 "state" => Ok(GeneratedField::State),
15650 "fragments" => Ok(GeneratedField::Fragments),
15651 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
15652 "ctx" => Ok(GeneratedField::Ctx),
15653 "parallelism" => Ok(GeneratedField::Parallelism),
15654 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
15655 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
15656 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
15657 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15658 }
15659 }
15660 }
15661 deserializer.deserialize_identifier(GeneratedVisitor)
15662 }
15663 }
15664 struct GeneratedVisitor;
15665 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15666 type Value = TableFragments;
15667
15668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15669 formatter.write_str("struct meta.TableFragments")
15670 }
15671
15672 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
15673 where
15674 V: serde::de::MapAccess<'de>,
15675 {
15676 let mut table_id__ = None;
15677 let mut state__ = None;
15678 let mut fragments__ = None;
15679 let mut actor_status__ = None;
15680 let mut ctx__ = None;
15681 let mut parallelism__ = None;
15682 let mut max_parallelism__ = None;
15683 let mut node_label__ = None;
15684 let mut backfill_done__ = None;
15685 while let Some(k) = map_.next_key()? {
15686 match k {
15687 GeneratedField::TableId => {
15688 if table_id__.is_some() {
15689 return Err(serde::de::Error::duplicate_field("tableId"));
15690 }
15691 table_id__ =
15692 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15693 ;
15694 }
15695 GeneratedField::State => {
15696 if state__.is_some() {
15697 return Err(serde::de::Error::duplicate_field("state"));
15698 }
15699 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
15700 }
15701 GeneratedField::Fragments => {
15702 if fragments__.is_some() {
15703 return Err(serde::de::Error::duplicate_field("fragments"));
15704 }
15705 fragments__ = Some(
15706 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15707 .into_iter().map(|(k,v)| (k.0, v)).collect()
15708 );
15709 }
15710 GeneratedField::ActorStatus => {
15711 if actor_status__.is_some() {
15712 return Err(serde::de::Error::duplicate_field("actorStatus"));
15713 }
15714 actor_status__ = Some(
15715 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15716 .into_iter().map(|(k,v)| (k.0, v)).collect()
15717 );
15718 }
15719 GeneratedField::Ctx => {
15720 if ctx__.is_some() {
15721 return Err(serde::de::Error::duplicate_field("ctx"));
15722 }
15723 ctx__ = map_.next_value()?;
15724 }
15725 GeneratedField::Parallelism => {
15726 if parallelism__.is_some() {
15727 return Err(serde::de::Error::duplicate_field("parallelism"));
15728 }
15729 parallelism__ = map_.next_value()?;
15730 }
15731 GeneratedField::MaxParallelism => {
15732 if max_parallelism__.is_some() {
15733 return Err(serde::de::Error::duplicate_field("maxParallelism"));
15734 }
15735 max_parallelism__ =
15736 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15737 ;
15738 }
15739 GeneratedField::NodeLabel => {
15740 if node_label__.is_some() {
15741 return Err(serde::de::Error::duplicate_field("nodeLabel"));
15742 }
15743 node_label__ = Some(map_.next_value()?);
15744 }
15745 GeneratedField::BackfillDone => {
15746 if backfill_done__.is_some() {
15747 return Err(serde::de::Error::duplicate_field("backfillDone"));
15748 }
15749 backfill_done__ = Some(map_.next_value()?);
15750 }
15751 }
15752 }
15753 Ok(TableFragments {
15754 table_id: table_id__.unwrap_or_default(),
15755 state: state__.unwrap_or_default(),
15756 fragments: fragments__.unwrap_or_default(),
15757 actor_status: actor_status__.unwrap_or_default(),
15758 ctx: ctx__,
15759 parallelism: parallelism__,
15760 max_parallelism: max_parallelism__,
15761 node_label: node_label__.unwrap_or_default(),
15762 backfill_done: backfill_done__.unwrap_or_default(),
15763 })
15764 }
15765 }
15766 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
15767 }
15768}
15769impl serde::Serialize for table_fragments::ActorStatus {
15770 #[allow(deprecated)]
15771 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15772 where
15773 S: serde::Serializer,
15774 {
15775 use serde::ser::SerializeStruct;
15776 let mut len = 0;
15777 if self.location.is_some() {
15778 len += 1;
15779 }
15780 if self.state != 0 {
15781 len += 1;
15782 }
15783 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
15784 if let Some(v) = self.location.as_ref() {
15785 struct_ser.serialize_field("location", v)?;
15786 }
15787 if self.state != 0 {
15788 let v = table_fragments::actor_status::ActorState::try_from(self.state)
15789 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15790 struct_ser.serialize_field("state", &v)?;
15791 }
15792 struct_ser.end()
15793 }
15794}
15795impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
15796 #[allow(deprecated)]
15797 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15798 where
15799 D: serde::Deserializer<'de>,
15800 {
15801 const FIELDS: &[&str] = &[
15802 "location",
15803 "state",
15804 ];
15805
15806 #[allow(clippy::enum_variant_names)]
15807 enum GeneratedField {
15808 Location,
15809 State,
15810 }
15811 impl<'de> serde::Deserialize<'de> for GeneratedField {
15812 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15813 where
15814 D: serde::Deserializer<'de>,
15815 {
15816 struct GeneratedVisitor;
15817
15818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15819 type Value = GeneratedField;
15820
15821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15822 write!(formatter, "expected one of: {:?}", &FIELDS)
15823 }
15824
15825 #[allow(unused_variables)]
15826 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15827 where
15828 E: serde::de::Error,
15829 {
15830 match value {
15831 "location" => Ok(GeneratedField::Location),
15832 "state" => Ok(GeneratedField::State),
15833 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15834 }
15835 }
15836 }
15837 deserializer.deserialize_identifier(GeneratedVisitor)
15838 }
15839 }
15840 struct GeneratedVisitor;
15841 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15842 type Value = table_fragments::ActorStatus;
15843
15844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15845 formatter.write_str("struct meta.TableFragments.ActorStatus")
15846 }
15847
15848 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
15849 where
15850 V: serde::de::MapAccess<'de>,
15851 {
15852 let mut location__ = None;
15853 let mut state__ = None;
15854 while let Some(k) = map_.next_key()? {
15855 match k {
15856 GeneratedField::Location => {
15857 if location__.is_some() {
15858 return Err(serde::de::Error::duplicate_field("location"));
15859 }
15860 location__ = map_.next_value()?;
15861 }
15862 GeneratedField::State => {
15863 if state__.is_some() {
15864 return Err(serde::de::Error::duplicate_field("state"));
15865 }
15866 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
15867 }
15868 }
15869 }
15870 Ok(table_fragments::ActorStatus {
15871 location: location__,
15872 state: state__.unwrap_or_default(),
15873 })
15874 }
15875 }
15876 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
15877 }
15878}
15879impl serde::Serialize for table_fragments::actor_status::ActorState {
15880 #[allow(deprecated)]
15881 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15882 where
15883 S: serde::Serializer,
15884 {
15885 let variant = match self {
15886 Self::Unspecified => "UNSPECIFIED",
15887 Self::Inactive => "INACTIVE",
15888 Self::Running => "RUNNING",
15889 };
15890 serializer.serialize_str(variant)
15891 }
15892}
15893impl<'de> serde::Deserialize<'de> for table_fragments::actor_status::ActorState {
15894 #[allow(deprecated)]
15895 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15896 where
15897 D: serde::Deserializer<'de>,
15898 {
15899 const FIELDS: &[&str] = &[
15900 "UNSPECIFIED",
15901 "INACTIVE",
15902 "RUNNING",
15903 ];
15904
15905 struct GeneratedVisitor;
15906
15907 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15908 type Value = table_fragments::actor_status::ActorState;
15909
15910 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15911 write!(formatter, "expected one of: {:?}", &FIELDS)
15912 }
15913
15914 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15915 where
15916 E: serde::de::Error,
15917 {
15918 i32::try_from(v)
15919 .ok()
15920 .and_then(|x| x.try_into().ok())
15921 .ok_or_else(|| {
15922 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15923 })
15924 }
15925
15926 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15927 where
15928 E: serde::de::Error,
15929 {
15930 i32::try_from(v)
15931 .ok()
15932 .and_then(|x| x.try_into().ok())
15933 .ok_or_else(|| {
15934 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15935 })
15936 }
15937
15938 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15939 where
15940 E: serde::de::Error,
15941 {
15942 match value {
15943 "UNSPECIFIED" => Ok(table_fragments::actor_status::ActorState::Unspecified),
15944 "INACTIVE" => Ok(table_fragments::actor_status::ActorState::Inactive),
15945 "RUNNING" => Ok(table_fragments::actor_status::ActorState::Running),
15946 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15947 }
15948 }
15949 }
15950 deserializer.deserialize_any(GeneratedVisitor)
15951 }
15952}
15953impl serde::Serialize for table_fragments::Fragment {
15954 #[allow(deprecated)]
15955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15956 where
15957 S: serde::Serializer,
15958 {
15959 use serde::ser::SerializeStruct;
15960 let mut len = 0;
15961 if self.fragment_id != 0 {
15962 len += 1;
15963 }
15964 if self.fragment_type_mask != 0 {
15965 len += 1;
15966 }
15967 if self.distribution_type != 0 {
15968 len += 1;
15969 }
15970 if !self.actors.is_empty() {
15971 len += 1;
15972 }
15973 if !self.state_table_ids.is_empty() {
15974 len += 1;
15975 }
15976 if !self.upstream_fragment_ids.is_empty() {
15977 len += 1;
15978 }
15979 if self.maybe_vnode_count.is_some() {
15980 len += 1;
15981 }
15982 if self.nodes.is_some() {
15983 len += 1;
15984 }
15985 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
15986 if self.fragment_id != 0 {
15987 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
15988 }
15989 if self.fragment_type_mask != 0 {
15990 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
15991 }
15992 if self.distribution_type != 0 {
15993 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
15994 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
15995 struct_ser.serialize_field("distributionType", &v)?;
15996 }
15997 if !self.actors.is_empty() {
15998 struct_ser.serialize_field("actors", &self.actors)?;
15999 }
16000 if !self.state_table_ids.is_empty() {
16001 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
16002 }
16003 if !self.upstream_fragment_ids.is_empty() {
16004 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
16005 }
16006 if let Some(v) = self.maybe_vnode_count.as_ref() {
16007 struct_ser.serialize_field("maybeVnodeCount", v)?;
16008 }
16009 if let Some(v) = self.nodes.as_ref() {
16010 struct_ser.serialize_field("nodes", v)?;
16011 }
16012 struct_ser.end()
16013 }
16014}
16015impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
16016 #[allow(deprecated)]
16017 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16018 where
16019 D: serde::Deserializer<'de>,
16020 {
16021 const FIELDS: &[&str] = &[
16022 "fragment_id",
16023 "fragmentId",
16024 "fragment_type_mask",
16025 "fragmentTypeMask",
16026 "distribution_type",
16027 "distributionType",
16028 "actors",
16029 "state_table_ids",
16030 "stateTableIds",
16031 "upstream_fragment_ids",
16032 "upstreamFragmentIds",
16033 "maybe_vnode_count",
16034 "maybeVnodeCount",
16035 "nodes",
16036 ];
16037
16038 #[allow(clippy::enum_variant_names)]
16039 enum GeneratedField {
16040 FragmentId,
16041 FragmentTypeMask,
16042 DistributionType,
16043 Actors,
16044 StateTableIds,
16045 UpstreamFragmentIds,
16046 MaybeVnodeCount,
16047 Nodes,
16048 }
16049 impl<'de> serde::Deserialize<'de> for GeneratedField {
16050 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16051 where
16052 D: serde::Deserializer<'de>,
16053 {
16054 struct GeneratedVisitor;
16055
16056 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16057 type Value = GeneratedField;
16058
16059 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16060 write!(formatter, "expected one of: {:?}", &FIELDS)
16061 }
16062
16063 #[allow(unused_variables)]
16064 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16065 where
16066 E: serde::de::Error,
16067 {
16068 match value {
16069 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
16070 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
16071 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
16072 "actors" => Ok(GeneratedField::Actors),
16073 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
16074 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
16075 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
16076 "nodes" => Ok(GeneratedField::Nodes),
16077 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16078 }
16079 }
16080 }
16081 deserializer.deserialize_identifier(GeneratedVisitor)
16082 }
16083 }
16084 struct GeneratedVisitor;
16085 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16086 type Value = table_fragments::Fragment;
16087
16088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16089 formatter.write_str("struct meta.TableFragments.Fragment")
16090 }
16091
16092 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
16093 where
16094 V: serde::de::MapAccess<'de>,
16095 {
16096 let mut fragment_id__ = None;
16097 let mut fragment_type_mask__ = None;
16098 let mut distribution_type__ = None;
16099 let mut actors__ = None;
16100 let mut state_table_ids__ = None;
16101 let mut upstream_fragment_ids__ = None;
16102 let mut maybe_vnode_count__ = None;
16103 let mut nodes__ = None;
16104 while let Some(k) = map_.next_key()? {
16105 match k {
16106 GeneratedField::FragmentId => {
16107 if fragment_id__.is_some() {
16108 return Err(serde::de::Error::duplicate_field("fragmentId"));
16109 }
16110 fragment_id__ =
16111 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16112 ;
16113 }
16114 GeneratedField::FragmentTypeMask => {
16115 if fragment_type_mask__.is_some() {
16116 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
16117 }
16118 fragment_type_mask__ =
16119 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16120 ;
16121 }
16122 GeneratedField::DistributionType => {
16123 if distribution_type__.is_some() {
16124 return Err(serde::de::Error::duplicate_field("distributionType"));
16125 }
16126 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
16127 }
16128 GeneratedField::Actors => {
16129 if actors__.is_some() {
16130 return Err(serde::de::Error::duplicate_field("actors"));
16131 }
16132 actors__ = Some(map_.next_value()?);
16133 }
16134 GeneratedField::StateTableIds => {
16135 if state_table_ids__.is_some() {
16136 return Err(serde::de::Error::duplicate_field("stateTableIds"));
16137 }
16138 state_table_ids__ =
16139 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16140 .into_iter().map(|x| x.0).collect())
16141 ;
16142 }
16143 GeneratedField::UpstreamFragmentIds => {
16144 if upstream_fragment_ids__.is_some() {
16145 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
16146 }
16147 upstream_fragment_ids__ =
16148 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16149 .into_iter().map(|x| x.0).collect())
16150 ;
16151 }
16152 GeneratedField::MaybeVnodeCount => {
16153 if maybe_vnode_count__.is_some() {
16154 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
16155 }
16156 maybe_vnode_count__ =
16157 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16158 ;
16159 }
16160 GeneratedField::Nodes => {
16161 if nodes__.is_some() {
16162 return Err(serde::de::Error::duplicate_field("nodes"));
16163 }
16164 nodes__ = map_.next_value()?;
16165 }
16166 }
16167 }
16168 Ok(table_fragments::Fragment {
16169 fragment_id: fragment_id__.unwrap_or_default(),
16170 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
16171 distribution_type: distribution_type__.unwrap_or_default(),
16172 actors: actors__.unwrap_or_default(),
16173 state_table_ids: state_table_ids__.unwrap_or_default(),
16174 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
16175 maybe_vnode_count: maybe_vnode_count__,
16176 nodes: nodes__,
16177 })
16178 }
16179 }
16180 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
16181 }
16182}
16183impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
16184 #[allow(deprecated)]
16185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16186 where
16187 S: serde::Serializer,
16188 {
16189 let variant = match self {
16190 Self::Unspecified => "UNSPECIFIED",
16191 Self::Single => "SINGLE",
16192 Self::Hash => "HASH",
16193 };
16194 serializer.serialize_str(variant)
16195 }
16196}
16197impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
16198 #[allow(deprecated)]
16199 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16200 where
16201 D: serde::Deserializer<'de>,
16202 {
16203 const FIELDS: &[&str] = &[
16204 "UNSPECIFIED",
16205 "SINGLE",
16206 "HASH",
16207 ];
16208
16209 struct GeneratedVisitor;
16210
16211 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16212 type Value = table_fragments::fragment::FragmentDistributionType;
16213
16214 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16215 write!(formatter, "expected one of: {:?}", &FIELDS)
16216 }
16217
16218 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16219 where
16220 E: serde::de::Error,
16221 {
16222 i32::try_from(v)
16223 .ok()
16224 .and_then(|x| x.try_into().ok())
16225 .ok_or_else(|| {
16226 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16227 })
16228 }
16229
16230 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16231 where
16232 E: serde::de::Error,
16233 {
16234 i32::try_from(v)
16235 .ok()
16236 .and_then(|x| x.try_into().ok())
16237 .ok_or_else(|| {
16238 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16239 })
16240 }
16241
16242 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16243 where
16244 E: serde::de::Error,
16245 {
16246 match value {
16247 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
16248 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
16249 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
16250 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16251 }
16252 }
16253 }
16254 deserializer.deserialize_any(GeneratedVisitor)
16255 }
16256}
16257impl serde::Serialize for table_fragments::State {
16258 #[allow(deprecated)]
16259 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16260 where
16261 S: serde::Serializer,
16262 {
16263 let variant = match self {
16264 Self::Unspecified => "UNSPECIFIED",
16265 Self::Initial => "INITIAL",
16266 Self::Creating => "CREATING",
16267 Self::Created => "CREATED",
16268 };
16269 serializer.serialize_str(variant)
16270 }
16271}
16272impl<'de> serde::Deserialize<'de> for table_fragments::State {
16273 #[allow(deprecated)]
16274 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16275 where
16276 D: serde::Deserializer<'de>,
16277 {
16278 const FIELDS: &[&str] = &[
16279 "UNSPECIFIED",
16280 "INITIAL",
16281 "CREATING",
16282 "CREATED",
16283 ];
16284
16285 struct GeneratedVisitor;
16286
16287 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16288 type Value = table_fragments::State;
16289
16290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16291 write!(formatter, "expected one of: {:?}", &FIELDS)
16292 }
16293
16294 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16295 where
16296 E: serde::de::Error,
16297 {
16298 i32::try_from(v)
16299 .ok()
16300 .and_then(|x| x.try_into().ok())
16301 .ok_or_else(|| {
16302 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16303 })
16304 }
16305
16306 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16307 where
16308 E: serde::de::Error,
16309 {
16310 i32::try_from(v)
16311 .ok()
16312 .and_then(|x| x.try_into().ok())
16313 .ok_or_else(|| {
16314 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16315 })
16316 }
16317
16318 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16319 where
16320 E: serde::de::Error,
16321 {
16322 match value {
16323 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
16324 "INITIAL" => Ok(table_fragments::State::Initial),
16325 "CREATING" => Ok(table_fragments::State::Creating),
16326 "CREATED" => Ok(table_fragments::State::Created),
16327 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16328 }
16329 }
16330 }
16331 deserializer.deserialize_any(GeneratedVisitor)
16332 }
16333}
16334impl serde::Serialize for TableParallelism {
16335 #[allow(deprecated)]
16336 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16337 where
16338 S: serde::Serializer,
16339 {
16340 use serde::ser::SerializeStruct;
16341 let mut len = 0;
16342 if self.parallelism.is_some() {
16343 len += 1;
16344 }
16345 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
16346 if let Some(v) = self.parallelism.as_ref() {
16347 match v {
16348 table_parallelism::Parallelism::Fixed(v) => {
16349 struct_ser.serialize_field("fixed", v)?;
16350 }
16351 table_parallelism::Parallelism::Auto(v) => {
16352 struct_ser.serialize_field("auto", v)?;
16353 }
16354 table_parallelism::Parallelism::Custom(v) => {
16355 struct_ser.serialize_field("custom", v)?;
16356 }
16357 table_parallelism::Parallelism::Adaptive(v) => {
16358 struct_ser.serialize_field("adaptive", v)?;
16359 }
16360 }
16361 }
16362 struct_ser.end()
16363 }
16364}
16365impl<'de> serde::Deserialize<'de> for TableParallelism {
16366 #[allow(deprecated)]
16367 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16368 where
16369 D: serde::Deserializer<'de>,
16370 {
16371 const FIELDS: &[&str] = &[
16372 "fixed",
16373 "auto",
16374 "custom",
16375 "adaptive",
16376 ];
16377
16378 #[allow(clippy::enum_variant_names)]
16379 enum GeneratedField {
16380 Fixed,
16381 Auto,
16382 Custom,
16383 Adaptive,
16384 }
16385 impl<'de> serde::Deserialize<'de> for GeneratedField {
16386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16387 where
16388 D: serde::Deserializer<'de>,
16389 {
16390 struct GeneratedVisitor;
16391
16392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16393 type Value = GeneratedField;
16394
16395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16396 write!(formatter, "expected one of: {:?}", &FIELDS)
16397 }
16398
16399 #[allow(unused_variables)]
16400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16401 where
16402 E: serde::de::Error,
16403 {
16404 match value {
16405 "fixed" => Ok(GeneratedField::Fixed),
16406 "auto" => Ok(GeneratedField::Auto),
16407 "custom" => Ok(GeneratedField::Custom),
16408 "adaptive" => Ok(GeneratedField::Adaptive),
16409 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16410 }
16411 }
16412 }
16413 deserializer.deserialize_identifier(GeneratedVisitor)
16414 }
16415 }
16416 struct GeneratedVisitor;
16417 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16418 type Value = TableParallelism;
16419
16420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16421 formatter.write_str("struct meta.TableParallelism")
16422 }
16423
16424 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
16425 where
16426 V: serde::de::MapAccess<'de>,
16427 {
16428 let mut parallelism__ = None;
16429 while let Some(k) = map_.next_key()? {
16430 match k {
16431 GeneratedField::Fixed => {
16432 if parallelism__.is_some() {
16433 return Err(serde::de::Error::duplicate_field("fixed"));
16434 }
16435 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
16436;
16437 }
16438 GeneratedField::Auto => {
16439 if parallelism__.is_some() {
16440 return Err(serde::de::Error::duplicate_field("auto"));
16441 }
16442 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
16443;
16444 }
16445 GeneratedField::Custom => {
16446 if parallelism__.is_some() {
16447 return Err(serde::de::Error::duplicate_field("custom"));
16448 }
16449 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
16450;
16451 }
16452 GeneratedField::Adaptive => {
16453 if parallelism__.is_some() {
16454 return Err(serde::de::Error::duplicate_field("adaptive"));
16455 }
16456 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
16457;
16458 }
16459 }
16460 }
16461 Ok(TableParallelism {
16462 parallelism: parallelism__,
16463 })
16464 }
16465 }
16466 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
16467 }
16468}
16469impl serde::Serialize for table_parallelism::AdaptiveParallelism {
16470 #[allow(deprecated)]
16471 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16472 where
16473 S: serde::Serializer,
16474 {
16475 use serde::ser::SerializeStruct;
16476 let len = 0;
16477 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
16478 struct_ser.end()
16479 }
16480}
16481impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
16482 #[allow(deprecated)]
16483 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16484 where
16485 D: serde::Deserializer<'de>,
16486 {
16487 const FIELDS: &[&str] = &[
16488 ];
16489
16490 #[allow(clippy::enum_variant_names)]
16491 enum GeneratedField {
16492 }
16493 impl<'de> serde::Deserialize<'de> for GeneratedField {
16494 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16495 where
16496 D: serde::Deserializer<'de>,
16497 {
16498 struct GeneratedVisitor;
16499
16500 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16501 type Value = GeneratedField;
16502
16503 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16504 write!(formatter, "expected one of: {:?}", &FIELDS)
16505 }
16506
16507 #[allow(unused_variables)]
16508 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16509 where
16510 E: serde::de::Error,
16511 {
16512 Err(serde::de::Error::unknown_field(value, FIELDS))
16513 }
16514 }
16515 deserializer.deserialize_identifier(GeneratedVisitor)
16516 }
16517 }
16518 struct GeneratedVisitor;
16519 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16520 type Value = table_parallelism::AdaptiveParallelism;
16521
16522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16523 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
16524 }
16525
16526 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
16527 where
16528 V: serde::de::MapAccess<'de>,
16529 {
16530 while map_.next_key::<GeneratedField>()?.is_some() {
16531 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16532 }
16533 Ok(table_parallelism::AdaptiveParallelism {
16534 })
16535 }
16536 }
16537 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
16538 }
16539}
16540impl serde::Serialize for table_parallelism::AutoParallelism {
16541 #[allow(deprecated)]
16542 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16543 where
16544 S: serde::Serializer,
16545 {
16546 use serde::ser::SerializeStruct;
16547 let len = 0;
16548 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
16549 struct_ser.end()
16550 }
16551}
16552impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
16553 #[allow(deprecated)]
16554 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16555 where
16556 D: serde::Deserializer<'de>,
16557 {
16558 const FIELDS: &[&str] = &[
16559 ];
16560
16561 #[allow(clippy::enum_variant_names)]
16562 enum GeneratedField {
16563 }
16564 impl<'de> serde::Deserialize<'de> for GeneratedField {
16565 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16566 where
16567 D: serde::Deserializer<'de>,
16568 {
16569 struct GeneratedVisitor;
16570
16571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16572 type Value = GeneratedField;
16573
16574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16575 write!(formatter, "expected one of: {:?}", &FIELDS)
16576 }
16577
16578 #[allow(unused_variables)]
16579 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16580 where
16581 E: serde::de::Error,
16582 {
16583 Err(serde::de::Error::unknown_field(value, FIELDS))
16584 }
16585 }
16586 deserializer.deserialize_identifier(GeneratedVisitor)
16587 }
16588 }
16589 struct GeneratedVisitor;
16590 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16591 type Value = table_parallelism::AutoParallelism;
16592
16593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16594 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
16595 }
16596
16597 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
16598 where
16599 V: serde::de::MapAccess<'de>,
16600 {
16601 while map_.next_key::<GeneratedField>()?.is_some() {
16602 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16603 }
16604 Ok(table_parallelism::AutoParallelism {
16605 })
16606 }
16607 }
16608 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
16609 }
16610}
16611impl serde::Serialize for table_parallelism::CustomParallelism {
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 use serde::ser::SerializeStruct;
16618 let len = 0;
16619 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
16620 struct_ser.end()
16621 }
16622}
16623impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
16624 #[allow(deprecated)]
16625 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16626 where
16627 D: serde::Deserializer<'de>,
16628 {
16629 const FIELDS: &[&str] = &[
16630 ];
16631
16632 #[allow(clippy::enum_variant_names)]
16633 enum GeneratedField {
16634 }
16635 impl<'de> serde::Deserialize<'de> for GeneratedField {
16636 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16637 where
16638 D: serde::Deserializer<'de>,
16639 {
16640 struct GeneratedVisitor;
16641
16642 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16643 type Value = GeneratedField;
16644
16645 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16646 write!(formatter, "expected one of: {:?}", &FIELDS)
16647 }
16648
16649 #[allow(unused_variables)]
16650 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16651 where
16652 E: serde::de::Error,
16653 {
16654 Err(serde::de::Error::unknown_field(value, FIELDS))
16655 }
16656 }
16657 deserializer.deserialize_identifier(GeneratedVisitor)
16658 }
16659 }
16660 struct GeneratedVisitor;
16661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16662 type Value = table_parallelism::CustomParallelism;
16663
16664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16665 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
16666 }
16667
16668 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
16669 where
16670 V: serde::de::MapAccess<'de>,
16671 {
16672 while map_.next_key::<GeneratedField>()?.is_some() {
16673 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16674 }
16675 Ok(table_parallelism::CustomParallelism {
16676 })
16677 }
16678 }
16679 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
16680 }
16681}
16682impl serde::Serialize for table_parallelism::FixedParallelism {
16683 #[allow(deprecated)]
16684 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16685 where
16686 S: serde::Serializer,
16687 {
16688 use serde::ser::SerializeStruct;
16689 let mut len = 0;
16690 if self.parallelism != 0 {
16691 len += 1;
16692 }
16693 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
16694 if self.parallelism != 0 {
16695 struct_ser.serialize_field("parallelism", &self.parallelism)?;
16696 }
16697 struct_ser.end()
16698 }
16699}
16700impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
16701 #[allow(deprecated)]
16702 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16703 where
16704 D: serde::Deserializer<'de>,
16705 {
16706 const FIELDS: &[&str] = &[
16707 "parallelism",
16708 ];
16709
16710 #[allow(clippy::enum_variant_names)]
16711 enum GeneratedField {
16712 Parallelism,
16713 }
16714 impl<'de> serde::Deserialize<'de> for GeneratedField {
16715 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16716 where
16717 D: serde::Deserializer<'de>,
16718 {
16719 struct GeneratedVisitor;
16720
16721 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16722 type Value = GeneratedField;
16723
16724 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16725 write!(formatter, "expected one of: {:?}", &FIELDS)
16726 }
16727
16728 #[allow(unused_variables)]
16729 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16730 where
16731 E: serde::de::Error,
16732 {
16733 match value {
16734 "parallelism" => Ok(GeneratedField::Parallelism),
16735 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16736 }
16737 }
16738 }
16739 deserializer.deserialize_identifier(GeneratedVisitor)
16740 }
16741 }
16742 struct GeneratedVisitor;
16743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16744 type Value = table_parallelism::FixedParallelism;
16745
16746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16747 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
16748 }
16749
16750 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
16751 where
16752 V: serde::de::MapAccess<'de>,
16753 {
16754 let mut parallelism__ = None;
16755 while let Some(k) = map_.next_key()? {
16756 match k {
16757 GeneratedField::Parallelism => {
16758 if parallelism__.is_some() {
16759 return Err(serde::de::Error::duplicate_field("parallelism"));
16760 }
16761 parallelism__ =
16762 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16763 ;
16764 }
16765 }
16766 }
16767 Ok(table_parallelism::FixedParallelism {
16768 parallelism: parallelism__.unwrap_or_default(),
16769 })
16770 }
16771 }
16772 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
16773 }
16774}
16775impl serde::Serialize for TelemetryInfoResponse {
16776 #[allow(deprecated)]
16777 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16778 where
16779 S: serde::Serializer,
16780 {
16781 use serde::ser::SerializeStruct;
16782 let mut len = 0;
16783 if self.tracking_id.is_some() {
16784 len += 1;
16785 }
16786 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
16787 if let Some(v) = self.tracking_id.as_ref() {
16788 struct_ser.serialize_field("trackingId", v)?;
16789 }
16790 struct_ser.end()
16791 }
16792}
16793impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
16794 #[allow(deprecated)]
16795 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16796 where
16797 D: serde::Deserializer<'de>,
16798 {
16799 const FIELDS: &[&str] = &[
16800 "tracking_id",
16801 "trackingId",
16802 ];
16803
16804 #[allow(clippy::enum_variant_names)]
16805 enum GeneratedField {
16806 TrackingId,
16807 }
16808 impl<'de> serde::Deserialize<'de> for GeneratedField {
16809 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16810 where
16811 D: serde::Deserializer<'de>,
16812 {
16813 struct GeneratedVisitor;
16814
16815 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16816 type Value = GeneratedField;
16817
16818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16819 write!(formatter, "expected one of: {:?}", &FIELDS)
16820 }
16821
16822 #[allow(unused_variables)]
16823 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16824 where
16825 E: serde::de::Error,
16826 {
16827 match value {
16828 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
16829 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16830 }
16831 }
16832 }
16833 deserializer.deserialize_identifier(GeneratedVisitor)
16834 }
16835 }
16836 struct GeneratedVisitor;
16837 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16838 type Value = TelemetryInfoResponse;
16839
16840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16841 formatter.write_str("struct meta.TelemetryInfoResponse")
16842 }
16843
16844 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
16845 where
16846 V: serde::de::MapAccess<'de>,
16847 {
16848 let mut tracking_id__ = None;
16849 while let Some(k) = map_.next_key()? {
16850 match k {
16851 GeneratedField::TrackingId => {
16852 if tracking_id__.is_some() {
16853 return Err(serde::de::Error::duplicate_field("trackingId"));
16854 }
16855 tracking_id__ = map_.next_value()?;
16856 }
16857 }
16858 }
16859 Ok(TelemetryInfoResponse {
16860 tracking_id: tracking_id__,
16861 })
16862 }
16863 }
16864 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
16865 }
16866}
16867impl serde::Serialize for ThrottleTarget {
16868 #[allow(deprecated)]
16869 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16870 where
16871 S: serde::Serializer,
16872 {
16873 let variant = match self {
16874 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
16875 Self::Source => "SOURCE",
16876 Self::Mv => "MV",
16877 Self::TableWithSource => "TABLE_WITH_SOURCE",
16878 Self::CdcTable => "CDC_TABLE",
16879 Self::TableDml => "TABLE_DML",
16880 Self::Sink => "SINK",
16881 Self::Fragment => "FRAGMENT",
16882 };
16883 serializer.serialize_str(variant)
16884 }
16885}
16886impl<'de> serde::Deserialize<'de> for ThrottleTarget {
16887 #[allow(deprecated)]
16888 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16889 where
16890 D: serde::Deserializer<'de>,
16891 {
16892 const FIELDS: &[&str] = &[
16893 "THROTTLE_TARGET_UNSPECIFIED",
16894 "SOURCE",
16895 "MV",
16896 "TABLE_WITH_SOURCE",
16897 "CDC_TABLE",
16898 "TABLE_DML",
16899 "SINK",
16900 "FRAGMENT",
16901 ];
16902
16903 struct GeneratedVisitor;
16904
16905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16906 type Value = ThrottleTarget;
16907
16908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16909 write!(formatter, "expected one of: {:?}", &FIELDS)
16910 }
16911
16912 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16913 where
16914 E: serde::de::Error,
16915 {
16916 i32::try_from(v)
16917 .ok()
16918 .and_then(|x| x.try_into().ok())
16919 .ok_or_else(|| {
16920 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16921 })
16922 }
16923
16924 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16925 where
16926 E: serde::de::Error,
16927 {
16928 i32::try_from(v)
16929 .ok()
16930 .and_then(|x| x.try_into().ok())
16931 .ok_or_else(|| {
16932 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16933 })
16934 }
16935
16936 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16937 where
16938 E: serde::de::Error,
16939 {
16940 match value {
16941 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
16942 "SOURCE" => Ok(ThrottleTarget::Source),
16943 "MV" => Ok(ThrottleTarget::Mv),
16944 "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
16945 "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
16946 "TABLE_DML" => Ok(ThrottleTarget::TableDml),
16947 "SINK" => Ok(ThrottleTarget::Sink),
16948 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
16949 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16950 }
16951 }
16952 }
16953 deserializer.deserialize_any(GeneratedVisitor)
16954 }
16955}
16956impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
16957 #[allow(deprecated)]
16958 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16959 where
16960 S: serde::Serializer,
16961 {
16962 use serde::ser::SerializeStruct;
16963 let mut len = 0;
16964 if self.id != 0 {
16965 len += 1;
16966 }
16967 if !self.node_label.is_empty() {
16968 len += 1;
16969 }
16970 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
16971 if self.id != 0 {
16972 struct_ser.serialize_field("id", &self.id)?;
16973 }
16974 if !self.node_label.is_empty() {
16975 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
16976 }
16977 struct_ser.end()
16978 }
16979}
16980impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
16981 #[allow(deprecated)]
16982 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16983 where
16984 D: serde::Deserializer<'de>,
16985 {
16986 const FIELDS: &[&str] = &[
16987 "id",
16988 "node_label",
16989 "nodeLabel",
16990 ];
16991
16992 #[allow(clippy::enum_variant_names)]
16993 enum GeneratedField {
16994 Id,
16995 NodeLabel,
16996 }
16997 impl<'de> serde::Deserialize<'de> for GeneratedField {
16998 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16999 where
17000 D: serde::Deserializer<'de>,
17001 {
17002 struct GeneratedVisitor;
17003
17004 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17005 type Value = GeneratedField;
17006
17007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17008 write!(formatter, "expected one of: {:?}", &FIELDS)
17009 }
17010
17011 #[allow(unused_variables)]
17012 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17013 where
17014 E: serde::de::Error,
17015 {
17016 match value {
17017 "id" => Ok(GeneratedField::Id),
17018 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
17019 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17020 }
17021 }
17022 }
17023 deserializer.deserialize_identifier(GeneratedVisitor)
17024 }
17025 }
17026 struct GeneratedVisitor;
17027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17028 type Value = UpdateStreamingJobNodeLabelsRequest;
17029
17030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17031 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
17032 }
17033
17034 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
17035 where
17036 V: serde::de::MapAccess<'de>,
17037 {
17038 let mut id__ = None;
17039 let mut node_label__ = None;
17040 while let Some(k) = map_.next_key()? {
17041 match k {
17042 GeneratedField::Id => {
17043 if id__.is_some() {
17044 return Err(serde::de::Error::duplicate_field("id"));
17045 }
17046 id__ =
17047 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17048 ;
17049 }
17050 GeneratedField::NodeLabel => {
17051 if node_label__.is_some() {
17052 return Err(serde::de::Error::duplicate_field("nodeLabel"));
17053 }
17054 node_label__ = Some(map_.next_value()?);
17055 }
17056 }
17057 }
17058 Ok(UpdateStreamingJobNodeLabelsRequest {
17059 id: id__.unwrap_or_default(),
17060 node_label: node_label__.unwrap_or_default(),
17061 })
17062 }
17063 }
17064 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
17065 }
17066}
17067impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
17068 #[allow(deprecated)]
17069 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17070 where
17071 S: serde::Serializer,
17072 {
17073 use serde::ser::SerializeStruct;
17074 let len = 0;
17075 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
17076 struct_ser.end()
17077 }
17078}
17079impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
17080 #[allow(deprecated)]
17081 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17082 where
17083 D: serde::Deserializer<'de>,
17084 {
17085 const FIELDS: &[&str] = &[
17086 ];
17087
17088 #[allow(clippy::enum_variant_names)]
17089 enum GeneratedField {
17090 }
17091 impl<'de> serde::Deserialize<'de> for GeneratedField {
17092 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17093 where
17094 D: serde::Deserializer<'de>,
17095 {
17096 struct GeneratedVisitor;
17097
17098 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17099 type Value = GeneratedField;
17100
17101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17102 write!(formatter, "expected one of: {:?}", &FIELDS)
17103 }
17104
17105 #[allow(unused_variables)]
17106 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17107 where
17108 E: serde::de::Error,
17109 {
17110 Err(serde::de::Error::unknown_field(value, FIELDS))
17111 }
17112 }
17113 deserializer.deserialize_identifier(GeneratedVisitor)
17114 }
17115 }
17116 struct GeneratedVisitor;
17117 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17118 type Value = UpdateStreamingJobNodeLabelsResponse;
17119
17120 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17121 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
17122 }
17123
17124 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
17125 where
17126 V: serde::de::MapAccess<'de>,
17127 {
17128 while map_.next_key::<GeneratedField>()?.is_some() {
17129 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17130 }
17131 Ok(UpdateStreamingJobNodeLabelsResponse {
17132 })
17133 }
17134 }
17135 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
17136 }
17137}
17138impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
17139 #[allow(deprecated)]
17140 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17141 where
17142 S: serde::Serializer,
17143 {
17144 use serde::ser::SerializeStruct;
17145 let mut len = 0;
17146 if !self.worker_ids.is_empty() {
17147 len += 1;
17148 }
17149 if self.schedulability != 0 {
17150 len += 1;
17151 }
17152 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
17153 if !self.worker_ids.is_empty() {
17154 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
17155 }
17156 if self.schedulability != 0 {
17157 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
17158 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
17159 struct_ser.serialize_field("schedulability", &v)?;
17160 }
17161 struct_ser.end()
17162 }
17163}
17164impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
17165 #[allow(deprecated)]
17166 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17167 where
17168 D: serde::Deserializer<'de>,
17169 {
17170 const FIELDS: &[&str] = &[
17171 "worker_ids",
17172 "workerIds",
17173 "schedulability",
17174 ];
17175
17176 #[allow(clippy::enum_variant_names)]
17177 enum GeneratedField {
17178 WorkerIds,
17179 Schedulability,
17180 }
17181 impl<'de> serde::Deserialize<'de> for GeneratedField {
17182 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17183 where
17184 D: serde::Deserializer<'de>,
17185 {
17186 struct GeneratedVisitor;
17187
17188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17189 type Value = GeneratedField;
17190
17191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17192 write!(formatter, "expected one of: {:?}", &FIELDS)
17193 }
17194
17195 #[allow(unused_variables)]
17196 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17197 where
17198 E: serde::de::Error,
17199 {
17200 match value {
17201 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
17202 "schedulability" => Ok(GeneratedField::Schedulability),
17203 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17204 }
17205 }
17206 }
17207 deserializer.deserialize_identifier(GeneratedVisitor)
17208 }
17209 }
17210 struct GeneratedVisitor;
17211 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17212 type Value = UpdateWorkerNodeSchedulabilityRequest;
17213
17214 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17215 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
17216 }
17217
17218 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
17219 where
17220 V: serde::de::MapAccess<'de>,
17221 {
17222 let mut worker_ids__ = None;
17223 let mut schedulability__ = None;
17224 while let Some(k) = map_.next_key()? {
17225 match k {
17226 GeneratedField::WorkerIds => {
17227 if worker_ids__.is_some() {
17228 return Err(serde::de::Error::duplicate_field("workerIds"));
17229 }
17230 worker_ids__ =
17231 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17232 .into_iter().map(|x| x.0).collect())
17233 ;
17234 }
17235 GeneratedField::Schedulability => {
17236 if schedulability__.is_some() {
17237 return Err(serde::de::Error::duplicate_field("schedulability"));
17238 }
17239 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
17240 }
17241 }
17242 }
17243 Ok(UpdateWorkerNodeSchedulabilityRequest {
17244 worker_ids: worker_ids__.unwrap_or_default(),
17245 schedulability: schedulability__.unwrap_or_default(),
17246 })
17247 }
17248 }
17249 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
17250 }
17251}
17252impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
17253 #[allow(deprecated)]
17254 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17255 where
17256 S: serde::Serializer,
17257 {
17258 let variant = match self {
17259 Self::Unspecified => "UNSPECIFIED",
17260 Self::Schedulable => "SCHEDULABLE",
17261 Self::Unschedulable => "UNSCHEDULABLE",
17262 };
17263 serializer.serialize_str(variant)
17264 }
17265}
17266impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
17267 #[allow(deprecated)]
17268 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17269 where
17270 D: serde::Deserializer<'de>,
17271 {
17272 const FIELDS: &[&str] = &[
17273 "UNSPECIFIED",
17274 "SCHEDULABLE",
17275 "UNSCHEDULABLE",
17276 ];
17277
17278 struct GeneratedVisitor;
17279
17280 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17281 type Value = update_worker_node_schedulability_request::Schedulability;
17282
17283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17284 write!(formatter, "expected one of: {:?}", &FIELDS)
17285 }
17286
17287 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17288 where
17289 E: serde::de::Error,
17290 {
17291 i32::try_from(v)
17292 .ok()
17293 .and_then(|x| x.try_into().ok())
17294 .ok_or_else(|| {
17295 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17296 })
17297 }
17298
17299 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17300 where
17301 E: serde::de::Error,
17302 {
17303 i32::try_from(v)
17304 .ok()
17305 .and_then(|x| x.try_into().ok())
17306 .ok_or_else(|| {
17307 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17308 })
17309 }
17310
17311 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17312 where
17313 E: serde::de::Error,
17314 {
17315 match value {
17316 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
17317 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
17318 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
17319 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17320 }
17321 }
17322 }
17323 deserializer.deserialize_any(GeneratedVisitor)
17324 }
17325}
17326impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
17327 #[allow(deprecated)]
17328 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17329 where
17330 S: serde::Serializer,
17331 {
17332 use serde::ser::SerializeStruct;
17333 let mut len = 0;
17334 if self.status.is_some() {
17335 len += 1;
17336 }
17337 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
17338 if let Some(v) = self.status.as_ref() {
17339 struct_ser.serialize_field("status", v)?;
17340 }
17341 struct_ser.end()
17342 }
17343}
17344impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
17345 #[allow(deprecated)]
17346 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17347 where
17348 D: serde::Deserializer<'de>,
17349 {
17350 const FIELDS: &[&str] = &[
17351 "status",
17352 ];
17353
17354 #[allow(clippy::enum_variant_names)]
17355 enum GeneratedField {
17356 Status,
17357 }
17358 impl<'de> serde::Deserialize<'de> for GeneratedField {
17359 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17360 where
17361 D: serde::Deserializer<'de>,
17362 {
17363 struct GeneratedVisitor;
17364
17365 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17366 type Value = GeneratedField;
17367
17368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17369 write!(formatter, "expected one of: {:?}", &FIELDS)
17370 }
17371
17372 #[allow(unused_variables)]
17373 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17374 where
17375 E: serde::de::Error,
17376 {
17377 match value {
17378 "status" => Ok(GeneratedField::Status),
17379 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17380 }
17381 }
17382 }
17383 deserializer.deserialize_identifier(GeneratedVisitor)
17384 }
17385 }
17386 struct GeneratedVisitor;
17387 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17388 type Value = UpdateWorkerNodeSchedulabilityResponse;
17389
17390 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17391 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
17392 }
17393
17394 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
17395 where
17396 V: serde::de::MapAccess<'de>,
17397 {
17398 let mut status__ = None;
17399 while let Some(k) = map_.next_key()? {
17400 match k {
17401 GeneratedField::Status => {
17402 if status__.is_some() {
17403 return Err(serde::de::Error::duplicate_field("status"));
17404 }
17405 status__ = map_.next_value()?;
17406 }
17407 }
17408 }
17409 Ok(UpdateWorkerNodeSchedulabilityResponse {
17410 status: status__,
17411 })
17412 }
17413 }
17414 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
17415 }
17416}
17417impl serde::Serialize for WorkerReschedule {
17418 #[allow(deprecated)]
17419 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17420 where
17421 S: serde::Serializer,
17422 {
17423 use serde::ser::SerializeStruct;
17424 let mut len = 0;
17425 if !self.worker_actor_diff.is_empty() {
17426 len += 1;
17427 }
17428 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
17429 if !self.worker_actor_diff.is_empty() {
17430 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
17431 }
17432 struct_ser.end()
17433 }
17434}
17435impl<'de> serde::Deserialize<'de> for WorkerReschedule {
17436 #[allow(deprecated)]
17437 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17438 where
17439 D: serde::Deserializer<'de>,
17440 {
17441 const FIELDS: &[&str] = &[
17442 "worker_actor_diff",
17443 "workerActorDiff",
17444 ];
17445
17446 #[allow(clippy::enum_variant_names)]
17447 enum GeneratedField {
17448 WorkerActorDiff,
17449 }
17450 impl<'de> serde::Deserialize<'de> for GeneratedField {
17451 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17452 where
17453 D: serde::Deserializer<'de>,
17454 {
17455 struct GeneratedVisitor;
17456
17457 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17458 type Value = GeneratedField;
17459
17460 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17461 write!(formatter, "expected one of: {:?}", &FIELDS)
17462 }
17463
17464 #[allow(unused_variables)]
17465 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17466 where
17467 E: serde::de::Error,
17468 {
17469 match value {
17470 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
17471 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17472 }
17473 }
17474 }
17475 deserializer.deserialize_identifier(GeneratedVisitor)
17476 }
17477 }
17478 struct GeneratedVisitor;
17479 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17480 type Value = WorkerReschedule;
17481
17482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17483 formatter.write_str("struct meta.WorkerReschedule")
17484 }
17485
17486 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
17487 where
17488 V: serde::de::MapAccess<'de>,
17489 {
17490 let mut worker_actor_diff__ = None;
17491 while let Some(k) = map_.next_key()? {
17492 match k {
17493 GeneratedField::WorkerActorDiff => {
17494 if worker_actor_diff__.is_some() {
17495 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
17496 }
17497 worker_actor_diff__ = Some(
17498 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
17499 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
17500 );
17501 }
17502 }
17503 }
17504 Ok(WorkerReschedule {
17505 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
17506 })
17507 }
17508 }
17509 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
17510 }
17511}