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.cluster_resource.is_some() {
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 let Some(v) = self.cluster_resource.as_ref() {
11781 struct_ser.serialize_field("clusterResource", v)?;
11782 }
11783 if !self.nodes.is_empty() {
11784 struct_ser.serialize_field("nodes", &self.nodes)?;
11785 }
11786 if let Some(v) = self.hummock_version.as_ref() {
11787 struct_ser.serialize_field("hummockVersion", v)?;
11788 }
11789 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
11790 struct_ser.serialize_field("metaBackupManifestId", v)?;
11791 }
11792 if let Some(v) = self.hummock_write_limits.as_ref() {
11793 struct_ser.serialize_field("hummockWriteLimits", v)?;
11794 }
11795 if !self.streaming_worker_slot_mappings.is_empty() {
11796 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
11797 }
11798 if !self.serving_worker_slot_mappings.is_empty() {
11799 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
11800 }
11801 if let Some(v) = self.version.as_ref() {
11802 struct_ser.serialize_field("version", v)?;
11803 }
11804 struct_ser.end()
11805 }
11806}
11807impl<'de> serde::Deserialize<'de> for MetaSnapshot {
11808 #[allow(deprecated)]
11809 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11810 where
11811 D: serde::Deserializer<'de>,
11812 {
11813 const FIELDS: &[&str] = &[
11814 "databases",
11815 "schemas",
11816 "sources",
11817 "sinks",
11818 "tables",
11819 "indexes",
11820 "views",
11821 "functions",
11822 "connections",
11823 "subscriptions",
11824 "users",
11825 "session_params",
11826 "sessionParams",
11827 "secrets",
11828 "cluster_resource",
11829 "clusterResource",
11830 "nodes",
11831 "hummock_version",
11832 "hummockVersion",
11833 "meta_backup_manifest_id",
11834 "metaBackupManifestId",
11835 "hummock_write_limits",
11836 "hummockWriteLimits",
11837 "streaming_worker_slot_mappings",
11838 "streamingWorkerSlotMappings",
11839 "serving_worker_slot_mappings",
11840 "servingWorkerSlotMappings",
11841 "version",
11842 ];
11843
11844 #[allow(clippy::enum_variant_names)]
11845 enum GeneratedField {
11846 Databases,
11847 Schemas,
11848 Sources,
11849 Sinks,
11850 Tables,
11851 Indexes,
11852 Views,
11853 Functions,
11854 Connections,
11855 Subscriptions,
11856 Users,
11857 SessionParams,
11858 Secrets,
11859 ClusterResource,
11860 Nodes,
11861 HummockVersion,
11862 MetaBackupManifestId,
11863 HummockWriteLimits,
11864 StreamingWorkerSlotMappings,
11865 ServingWorkerSlotMappings,
11866 Version,
11867 }
11868 impl<'de> serde::Deserialize<'de> for GeneratedField {
11869 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11870 where
11871 D: serde::Deserializer<'de>,
11872 {
11873 struct GeneratedVisitor;
11874
11875 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11876 type Value = GeneratedField;
11877
11878 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11879 write!(formatter, "expected one of: {:?}", &FIELDS)
11880 }
11881
11882 #[allow(unused_variables)]
11883 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11884 where
11885 E: serde::de::Error,
11886 {
11887 match value {
11888 "databases" => Ok(GeneratedField::Databases),
11889 "schemas" => Ok(GeneratedField::Schemas),
11890 "sources" => Ok(GeneratedField::Sources),
11891 "sinks" => Ok(GeneratedField::Sinks),
11892 "tables" => Ok(GeneratedField::Tables),
11893 "indexes" => Ok(GeneratedField::Indexes),
11894 "views" => Ok(GeneratedField::Views),
11895 "functions" => Ok(GeneratedField::Functions),
11896 "connections" => Ok(GeneratedField::Connections),
11897 "subscriptions" => Ok(GeneratedField::Subscriptions),
11898 "users" => Ok(GeneratedField::Users),
11899 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
11900 "secrets" => Ok(GeneratedField::Secrets),
11901 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
11902 "nodes" => Ok(GeneratedField::Nodes),
11903 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
11904 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
11905 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
11906 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
11907 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
11908 "version" => Ok(GeneratedField::Version),
11909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11910 }
11911 }
11912 }
11913 deserializer.deserialize_identifier(GeneratedVisitor)
11914 }
11915 }
11916 struct GeneratedVisitor;
11917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11918 type Value = MetaSnapshot;
11919
11920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11921 formatter.write_str("struct meta.MetaSnapshot")
11922 }
11923
11924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
11925 where
11926 V: serde::de::MapAccess<'de>,
11927 {
11928 let mut databases__ = None;
11929 let mut schemas__ = None;
11930 let mut sources__ = None;
11931 let mut sinks__ = None;
11932 let mut tables__ = None;
11933 let mut indexes__ = None;
11934 let mut views__ = None;
11935 let mut functions__ = None;
11936 let mut connections__ = None;
11937 let mut subscriptions__ = None;
11938 let mut users__ = None;
11939 let mut session_params__ = None;
11940 let mut secrets__ = None;
11941 let mut cluster_resource__ = None;
11942 let mut nodes__ = None;
11943 let mut hummock_version__ = None;
11944 let mut meta_backup_manifest_id__ = None;
11945 let mut hummock_write_limits__ = None;
11946 let mut streaming_worker_slot_mappings__ = None;
11947 let mut serving_worker_slot_mappings__ = None;
11948 let mut version__ = None;
11949 while let Some(k) = map_.next_key()? {
11950 match k {
11951 GeneratedField::Databases => {
11952 if databases__.is_some() {
11953 return Err(serde::de::Error::duplicate_field("databases"));
11954 }
11955 databases__ = Some(map_.next_value()?);
11956 }
11957 GeneratedField::Schemas => {
11958 if schemas__.is_some() {
11959 return Err(serde::de::Error::duplicate_field("schemas"));
11960 }
11961 schemas__ = Some(map_.next_value()?);
11962 }
11963 GeneratedField::Sources => {
11964 if sources__.is_some() {
11965 return Err(serde::de::Error::duplicate_field("sources"));
11966 }
11967 sources__ = Some(map_.next_value()?);
11968 }
11969 GeneratedField::Sinks => {
11970 if sinks__.is_some() {
11971 return Err(serde::de::Error::duplicate_field("sinks"));
11972 }
11973 sinks__ = Some(map_.next_value()?);
11974 }
11975 GeneratedField::Tables => {
11976 if tables__.is_some() {
11977 return Err(serde::de::Error::duplicate_field("tables"));
11978 }
11979 tables__ = Some(map_.next_value()?);
11980 }
11981 GeneratedField::Indexes => {
11982 if indexes__.is_some() {
11983 return Err(serde::de::Error::duplicate_field("indexes"));
11984 }
11985 indexes__ = Some(map_.next_value()?);
11986 }
11987 GeneratedField::Views => {
11988 if views__.is_some() {
11989 return Err(serde::de::Error::duplicate_field("views"));
11990 }
11991 views__ = Some(map_.next_value()?);
11992 }
11993 GeneratedField::Functions => {
11994 if functions__.is_some() {
11995 return Err(serde::de::Error::duplicate_field("functions"));
11996 }
11997 functions__ = Some(map_.next_value()?);
11998 }
11999 GeneratedField::Connections => {
12000 if connections__.is_some() {
12001 return Err(serde::de::Error::duplicate_field("connections"));
12002 }
12003 connections__ = Some(map_.next_value()?);
12004 }
12005 GeneratedField::Subscriptions => {
12006 if subscriptions__.is_some() {
12007 return Err(serde::de::Error::duplicate_field("subscriptions"));
12008 }
12009 subscriptions__ = Some(map_.next_value()?);
12010 }
12011 GeneratedField::Users => {
12012 if users__.is_some() {
12013 return Err(serde::de::Error::duplicate_field("users"));
12014 }
12015 users__ = Some(map_.next_value()?);
12016 }
12017 GeneratedField::SessionParams => {
12018 if session_params__.is_some() {
12019 return Err(serde::de::Error::duplicate_field("sessionParams"));
12020 }
12021 session_params__ = map_.next_value()?;
12022 }
12023 GeneratedField::Secrets => {
12024 if secrets__.is_some() {
12025 return Err(serde::de::Error::duplicate_field("secrets"));
12026 }
12027 secrets__ = Some(map_.next_value()?);
12028 }
12029 GeneratedField::ClusterResource => {
12030 if cluster_resource__.is_some() {
12031 return Err(serde::de::Error::duplicate_field("clusterResource"));
12032 }
12033 cluster_resource__ = map_.next_value()?;
12034 }
12035 GeneratedField::Nodes => {
12036 if nodes__.is_some() {
12037 return Err(serde::de::Error::duplicate_field("nodes"));
12038 }
12039 nodes__ = Some(map_.next_value()?);
12040 }
12041 GeneratedField::HummockVersion => {
12042 if hummock_version__.is_some() {
12043 return Err(serde::de::Error::duplicate_field("hummockVersion"));
12044 }
12045 hummock_version__ = map_.next_value()?;
12046 }
12047 GeneratedField::MetaBackupManifestId => {
12048 if meta_backup_manifest_id__.is_some() {
12049 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
12050 }
12051 meta_backup_manifest_id__ = map_.next_value()?;
12052 }
12053 GeneratedField::HummockWriteLimits => {
12054 if hummock_write_limits__.is_some() {
12055 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
12056 }
12057 hummock_write_limits__ = map_.next_value()?;
12058 }
12059 GeneratedField::StreamingWorkerSlotMappings => {
12060 if streaming_worker_slot_mappings__.is_some() {
12061 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
12062 }
12063 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
12064 }
12065 GeneratedField::ServingWorkerSlotMappings => {
12066 if serving_worker_slot_mappings__.is_some() {
12067 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
12068 }
12069 serving_worker_slot_mappings__ = Some(map_.next_value()?);
12070 }
12071 GeneratedField::Version => {
12072 if version__.is_some() {
12073 return Err(serde::de::Error::duplicate_field("version"));
12074 }
12075 version__ = map_.next_value()?;
12076 }
12077 }
12078 }
12079 Ok(MetaSnapshot {
12080 databases: databases__.unwrap_or_default(),
12081 schemas: schemas__.unwrap_or_default(),
12082 sources: sources__.unwrap_or_default(),
12083 sinks: sinks__.unwrap_or_default(),
12084 tables: tables__.unwrap_or_default(),
12085 indexes: indexes__.unwrap_or_default(),
12086 views: views__.unwrap_or_default(),
12087 functions: functions__.unwrap_or_default(),
12088 connections: connections__.unwrap_or_default(),
12089 subscriptions: subscriptions__.unwrap_or_default(),
12090 users: users__.unwrap_or_default(),
12091 session_params: session_params__,
12092 secrets: secrets__.unwrap_or_default(),
12093 cluster_resource: cluster_resource__,
12094 nodes: nodes__.unwrap_or_default(),
12095 hummock_version: hummock_version__,
12096 meta_backup_manifest_id: meta_backup_manifest_id__,
12097 hummock_write_limits: hummock_write_limits__,
12098 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
12099 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
12100 version: version__,
12101 })
12102 }
12103 }
12104 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
12105 }
12106}
12107impl serde::Serialize for meta_snapshot::SnapshotVersion {
12108 #[allow(deprecated)]
12109 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12110 where
12111 S: serde::Serializer,
12112 {
12113 use serde::ser::SerializeStruct;
12114 let mut len = 0;
12115 if self.catalog_version != 0 {
12116 len += 1;
12117 }
12118 if self.worker_node_version != 0 {
12119 len += 1;
12120 }
12121 if self.streaming_worker_slot_mapping_version != 0 {
12122 len += 1;
12123 }
12124 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
12125 if self.catalog_version != 0 {
12126 #[allow(clippy::needless_borrow)]
12127 #[allow(clippy::needless_borrows_for_generic_args)]
12128 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
12129 }
12130 if self.worker_node_version != 0 {
12131 #[allow(clippy::needless_borrow)]
12132 #[allow(clippy::needless_borrows_for_generic_args)]
12133 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
12134 }
12135 if self.streaming_worker_slot_mapping_version != 0 {
12136 #[allow(clippy::needless_borrow)]
12137 #[allow(clippy::needless_borrows_for_generic_args)]
12138 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
12139 }
12140 struct_ser.end()
12141 }
12142}
12143impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
12144 #[allow(deprecated)]
12145 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12146 where
12147 D: serde::Deserializer<'de>,
12148 {
12149 const FIELDS: &[&str] = &[
12150 "catalog_version",
12151 "catalogVersion",
12152 "worker_node_version",
12153 "workerNodeVersion",
12154 "streaming_worker_slot_mapping_version",
12155 "streamingWorkerSlotMappingVersion",
12156 ];
12157
12158 #[allow(clippy::enum_variant_names)]
12159 enum GeneratedField {
12160 CatalogVersion,
12161 WorkerNodeVersion,
12162 StreamingWorkerSlotMappingVersion,
12163 }
12164 impl<'de> serde::Deserialize<'de> for GeneratedField {
12165 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12166 where
12167 D: serde::Deserializer<'de>,
12168 {
12169 struct GeneratedVisitor;
12170
12171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12172 type Value = GeneratedField;
12173
12174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12175 write!(formatter, "expected one of: {:?}", &FIELDS)
12176 }
12177
12178 #[allow(unused_variables)]
12179 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12180 where
12181 E: serde::de::Error,
12182 {
12183 match value {
12184 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
12185 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
12186 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
12187 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12188 }
12189 }
12190 }
12191 deserializer.deserialize_identifier(GeneratedVisitor)
12192 }
12193 }
12194 struct GeneratedVisitor;
12195 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12196 type Value = meta_snapshot::SnapshotVersion;
12197
12198 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12199 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
12200 }
12201
12202 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
12203 where
12204 V: serde::de::MapAccess<'de>,
12205 {
12206 let mut catalog_version__ = None;
12207 let mut worker_node_version__ = None;
12208 let mut streaming_worker_slot_mapping_version__ = None;
12209 while let Some(k) = map_.next_key()? {
12210 match k {
12211 GeneratedField::CatalogVersion => {
12212 if catalog_version__.is_some() {
12213 return Err(serde::de::Error::duplicate_field("catalogVersion"));
12214 }
12215 catalog_version__ =
12216 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12217 ;
12218 }
12219 GeneratedField::WorkerNodeVersion => {
12220 if worker_node_version__.is_some() {
12221 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
12222 }
12223 worker_node_version__ =
12224 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12225 ;
12226 }
12227 GeneratedField::StreamingWorkerSlotMappingVersion => {
12228 if streaming_worker_slot_mapping_version__.is_some() {
12229 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
12230 }
12231 streaming_worker_slot_mapping_version__ =
12232 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12233 ;
12234 }
12235 }
12236 }
12237 Ok(meta_snapshot::SnapshotVersion {
12238 catalog_version: catalog_version__.unwrap_or_default(),
12239 worker_node_version: worker_node_version__.unwrap_or_default(),
12240 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
12241 })
12242 }
12243 }
12244 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
12245 }
12246}
12247impl serde::Serialize for MigrationPlan {
12248 #[allow(deprecated)]
12249 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12250 where
12251 S: serde::Serializer,
12252 {
12253 use serde::ser::SerializeStruct;
12254 let mut len = 0;
12255 if !self.worker_slot_migration_plan.is_empty() {
12256 len += 1;
12257 }
12258 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
12259 if !self.worker_slot_migration_plan.is_empty() {
12260 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
12261 .map(|(k, v)| (k, v.to_string())).collect();
12262 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
12263 }
12264 struct_ser.end()
12265 }
12266}
12267impl<'de> serde::Deserialize<'de> for MigrationPlan {
12268 #[allow(deprecated)]
12269 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12270 where
12271 D: serde::Deserializer<'de>,
12272 {
12273 const FIELDS: &[&str] = &[
12274 "worker_slot_migration_plan",
12275 "workerSlotMigrationPlan",
12276 ];
12277
12278 #[allow(clippy::enum_variant_names)]
12279 enum GeneratedField {
12280 WorkerSlotMigrationPlan,
12281 }
12282 impl<'de> serde::Deserialize<'de> for GeneratedField {
12283 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12284 where
12285 D: serde::Deserializer<'de>,
12286 {
12287 struct GeneratedVisitor;
12288
12289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12290 type Value = GeneratedField;
12291
12292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12293 write!(formatter, "expected one of: {:?}", &FIELDS)
12294 }
12295
12296 #[allow(unused_variables)]
12297 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12298 where
12299 E: serde::de::Error,
12300 {
12301 match value {
12302 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
12303 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12304 }
12305 }
12306 }
12307 deserializer.deserialize_identifier(GeneratedVisitor)
12308 }
12309 }
12310 struct GeneratedVisitor;
12311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12312 type Value = MigrationPlan;
12313
12314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12315 formatter.write_str("struct meta.MigrationPlan")
12316 }
12317
12318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
12319 where
12320 V: serde::de::MapAccess<'de>,
12321 {
12322 let mut worker_slot_migration_plan__ = None;
12323 while let Some(k) = map_.next_key()? {
12324 match k {
12325 GeneratedField::WorkerSlotMigrationPlan => {
12326 if worker_slot_migration_plan__.is_some() {
12327 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
12328 }
12329 worker_slot_migration_plan__ = Some(
12330 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
12331 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
12332 );
12333 }
12334 }
12335 }
12336 Ok(MigrationPlan {
12337 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
12338 })
12339 }
12340 }
12341 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
12342 }
12343}
12344impl serde::Serialize for Object {
12345 #[allow(deprecated)]
12346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12347 where
12348 S: serde::Serializer,
12349 {
12350 use serde::ser::SerializeStruct;
12351 let mut len = 0;
12352 if self.object_info.is_some() {
12353 len += 1;
12354 }
12355 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
12356 if let Some(v) = self.object_info.as_ref() {
12357 match v {
12358 object::ObjectInfo::Database(v) => {
12359 struct_ser.serialize_field("database", v)?;
12360 }
12361 object::ObjectInfo::Schema(v) => {
12362 struct_ser.serialize_field("schema", v)?;
12363 }
12364 object::ObjectInfo::Table(v) => {
12365 struct_ser.serialize_field("table", v)?;
12366 }
12367 object::ObjectInfo::Index(v) => {
12368 struct_ser.serialize_field("index", v)?;
12369 }
12370 object::ObjectInfo::Source(v) => {
12371 struct_ser.serialize_field("source", v)?;
12372 }
12373 object::ObjectInfo::Sink(v) => {
12374 struct_ser.serialize_field("sink", v)?;
12375 }
12376 object::ObjectInfo::View(v) => {
12377 struct_ser.serialize_field("view", v)?;
12378 }
12379 object::ObjectInfo::Function(v) => {
12380 struct_ser.serialize_field("function", v)?;
12381 }
12382 object::ObjectInfo::Connection(v) => {
12383 struct_ser.serialize_field("connection", v)?;
12384 }
12385 object::ObjectInfo::Subscription(v) => {
12386 struct_ser.serialize_field("subscription", v)?;
12387 }
12388 object::ObjectInfo::Secret(v) => {
12389 struct_ser.serialize_field("secret", v)?;
12390 }
12391 }
12392 }
12393 struct_ser.end()
12394 }
12395}
12396impl<'de> serde::Deserialize<'de> for Object {
12397 #[allow(deprecated)]
12398 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12399 where
12400 D: serde::Deserializer<'de>,
12401 {
12402 const FIELDS: &[&str] = &[
12403 "database",
12404 "schema",
12405 "table",
12406 "index",
12407 "source",
12408 "sink",
12409 "view",
12410 "function",
12411 "connection",
12412 "subscription",
12413 "secret",
12414 ];
12415
12416 #[allow(clippy::enum_variant_names)]
12417 enum GeneratedField {
12418 Database,
12419 Schema,
12420 Table,
12421 Index,
12422 Source,
12423 Sink,
12424 View,
12425 Function,
12426 Connection,
12427 Subscription,
12428 Secret,
12429 }
12430 impl<'de> serde::Deserialize<'de> for GeneratedField {
12431 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12432 where
12433 D: serde::Deserializer<'de>,
12434 {
12435 struct GeneratedVisitor;
12436
12437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12438 type Value = GeneratedField;
12439
12440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12441 write!(formatter, "expected one of: {:?}", &FIELDS)
12442 }
12443
12444 #[allow(unused_variables)]
12445 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12446 where
12447 E: serde::de::Error,
12448 {
12449 match value {
12450 "database" => Ok(GeneratedField::Database),
12451 "schema" => Ok(GeneratedField::Schema),
12452 "table" => Ok(GeneratedField::Table),
12453 "index" => Ok(GeneratedField::Index),
12454 "source" => Ok(GeneratedField::Source),
12455 "sink" => Ok(GeneratedField::Sink),
12456 "view" => Ok(GeneratedField::View),
12457 "function" => Ok(GeneratedField::Function),
12458 "connection" => Ok(GeneratedField::Connection),
12459 "subscription" => Ok(GeneratedField::Subscription),
12460 "secret" => Ok(GeneratedField::Secret),
12461 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12462 }
12463 }
12464 }
12465 deserializer.deserialize_identifier(GeneratedVisitor)
12466 }
12467 }
12468 struct GeneratedVisitor;
12469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12470 type Value = Object;
12471
12472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12473 formatter.write_str("struct meta.Object")
12474 }
12475
12476 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
12477 where
12478 V: serde::de::MapAccess<'de>,
12479 {
12480 let mut object_info__ = None;
12481 while let Some(k) = map_.next_key()? {
12482 match k {
12483 GeneratedField::Database => {
12484 if object_info__.is_some() {
12485 return Err(serde::de::Error::duplicate_field("database"));
12486 }
12487 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
12488;
12489 }
12490 GeneratedField::Schema => {
12491 if object_info__.is_some() {
12492 return Err(serde::de::Error::duplicate_field("schema"));
12493 }
12494 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
12495;
12496 }
12497 GeneratedField::Table => {
12498 if object_info__.is_some() {
12499 return Err(serde::de::Error::duplicate_field("table"));
12500 }
12501 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
12502;
12503 }
12504 GeneratedField::Index => {
12505 if object_info__.is_some() {
12506 return Err(serde::de::Error::duplicate_field("index"));
12507 }
12508 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
12509;
12510 }
12511 GeneratedField::Source => {
12512 if object_info__.is_some() {
12513 return Err(serde::de::Error::duplicate_field("source"));
12514 }
12515 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
12516;
12517 }
12518 GeneratedField::Sink => {
12519 if object_info__.is_some() {
12520 return Err(serde::de::Error::duplicate_field("sink"));
12521 }
12522 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
12523;
12524 }
12525 GeneratedField::View => {
12526 if object_info__.is_some() {
12527 return Err(serde::de::Error::duplicate_field("view"));
12528 }
12529 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
12530;
12531 }
12532 GeneratedField::Function => {
12533 if object_info__.is_some() {
12534 return Err(serde::de::Error::duplicate_field("function"));
12535 }
12536 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
12537;
12538 }
12539 GeneratedField::Connection => {
12540 if object_info__.is_some() {
12541 return Err(serde::de::Error::duplicate_field("connection"));
12542 }
12543 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
12544;
12545 }
12546 GeneratedField::Subscription => {
12547 if object_info__.is_some() {
12548 return Err(serde::de::Error::duplicate_field("subscription"));
12549 }
12550 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
12551;
12552 }
12553 GeneratedField::Secret => {
12554 if object_info__.is_some() {
12555 return Err(serde::de::Error::duplicate_field("secret"));
12556 }
12557 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
12558;
12559 }
12560 }
12561 }
12562 Ok(Object {
12563 object_info: object_info__,
12564 })
12565 }
12566 }
12567 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
12568 }
12569}
12570impl serde::Serialize for ObjectGroup {
12571 #[allow(deprecated)]
12572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12573 where
12574 S: serde::Serializer,
12575 {
12576 use serde::ser::SerializeStruct;
12577 let mut len = 0;
12578 if !self.objects.is_empty() {
12579 len += 1;
12580 }
12581 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
12582 if !self.objects.is_empty() {
12583 struct_ser.serialize_field("objects", &self.objects)?;
12584 }
12585 struct_ser.end()
12586 }
12587}
12588impl<'de> serde::Deserialize<'de> for ObjectGroup {
12589 #[allow(deprecated)]
12590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12591 where
12592 D: serde::Deserializer<'de>,
12593 {
12594 const FIELDS: &[&str] = &[
12595 "objects",
12596 ];
12597
12598 #[allow(clippy::enum_variant_names)]
12599 enum GeneratedField {
12600 Objects,
12601 }
12602 impl<'de> serde::Deserialize<'de> for GeneratedField {
12603 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12604 where
12605 D: serde::Deserializer<'de>,
12606 {
12607 struct GeneratedVisitor;
12608
12609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12610 type Value = GeneratedField;
12611
12612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12613 write!(formatter, "expected one of: {:?}", &FIELDS)
12614 }
12615
12616 #[allow(unused_variables)]
12617 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12618 where
12619 E: serde::de::Error,
12620 {
12621 match value {
12622 "objects" => Ok(GeneratedField::Objects),
12623 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12624 }
12625 }
12626 }
12627 deserializer.deserialize_identifier(GeneratedVisitor)
12628 }
12629 }
12630 struct GeneratedVisitor;
12631 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12632 type Value = ObjectGroup;
12633
12634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12635 formatter.write_str("struct meta.ObjectGroup")
12636 }
12637
12638 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
12639 where
12640 V: serde::de::MapAccess<'de>,
12641 {
12642 let mut objects__ = None;
12643 while let Some(k) = map_.next_key()? {
12644 match k {
12645 GeneratedField::Objects => {
12646 if objects__.is_some() {
12647 return Err(serde::de::Error::duplicate_field("objects"));
12648 }
12649 objects__ = Some(map_.next_value()?);
12650 }
12651 }
12652 }
12653 Ok(ObjectGroup {
12654 objects: objects__.unwrap_or_default(),
12655 })
12656 }
12657 }
12658 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
12659 }
12660}
12661impl serde::Serialize for PauseRequest {
12662 #[allow(deprecated)]
12663 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12664 where
12665 S: serde::Serializer,
12666 {
12667 use serde::ser::SerializeStruct;
12668 let len = 0;
12669 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
12670 struct_ser.end()
12671 }
12672}
12673impl<'de> serde::Deserialize<'de> for PauseRequest {
12674 #[allow(deprecated)]
12675 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12676 where
12677 D: serde::Deserializer<'de>,
12678 {
12679 const FIELDS: &[&str] = &[
12680 ];
12681
12682 #[allow(clippy::enum_variant_names)]
12683 enum GeneratedField {
12684 }
12685 impl<'de> serde::Deserialize<'de> for GeneratedField {
12686 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12687 where
12688 D: serde::Deserializer<'de>,
12689 {
12690 struct GeneratedVisitor;
12691
12692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12693 type Value = GeneratedField;
12694
12695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12696 write!(formatter, "expected one of: {:?}", &FIELDS)
12697 }
12698
12699 #[allow(unused_variables)]
12700 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12701 where
12702 E: serde::de::Error,
12703 {
12704 Err(serde::de::Error::unknown_field(value, FIELDS))
12705 }
12706 }
12707 deserializer.deserialize_identifier(GeneratedVisitor)
12708 }
12709 }
12710 struct GeneratedVisitor;
12711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12712 type Value = PauseRequest;
12713
12714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12715 formatter.write_str("struct meta.PauseRequest")
12716 }
12717
12718 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
12719 where
12720 V: serde::de::MapAccess<'de>,
12721 {
12722 while map_.next_key::<GeneratedField>()?.is_some() {
12723 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12724 }
12725 Ok(PauseRequest {
12726 })
12727 }
12728 }
12729 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
12730 }
12731}
12732impl serde::Serialize for PauseResponse {
12733 #[allow(deprecated)]
12734 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12735 where
12736 S: serde::Serializer,
12737 {
12738 use serde::ser::SerializeStruct;
12739 let len = 0;
12740 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
12741 struct_ser.end()
12742 }
12743}
12744impl<'de> serde::Deserialize<'de> for PauseResponse {
12745 #[allow(deprecated)]
12746 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12747 where
12748 D: serde::Deserializer<'de>,
12749 {
12750 const FIELDS: &[&str] = &[
12751 ];
12752
12753 #[allow(clippy::enum_variant_names)]
12754 enum GeneratedField {
12755 }
12756 impl<'de> serde::Deserialize<'de> for GeneratedField {
12757 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12758 where
12759 D: serde::Deserializer<'de>,
12760 {
12761 struct GeneratedVisitor;
12762
12763 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12764 type Value = GeneratedField;
12765
12766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12767 write!(formatter, "expected one of: {:?}", &FIELDS)
12768 }
12769
12770 #[allow(unused_variables)]
12771 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12772 where
12773 E: serde::de::Error,
12774 {
12775 Err(serde::de::Error::unknown_field(value, FIELDS))
12776 }
12777 }
12778 deserializer.deserialize_identifier(GeneratedVisitor)
12779 }
12780 }
12781 struct GeneratedVisitor;
12782 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12783 type Value = PauseResponse;
12784
12785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12786 formatter.write_str("struct meta.PauseResponse")
12787 }
12788
12789 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
12790 where
12791 V: serde::de::MapAccess<'de>,
12792 {
12793 while map_.next_key::<GeneratedField>()?.is_some() {
12794 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12795 }
12796 Ok(PauseResponse {
12797 })
12798 }
12799 }
12800 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
12801 }
12802}
12803impl serde::Serialize for RecoverRequest {
12804 #[allow(deprecated)]
12805 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12806 where
12807 S: serde::Serializer,
12808 {
12809 use serde::ser::SerializeStruct;
12810 let len = 0;
12811 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
12812 struct_ser.end()
12813 }
12814}
12815impl<'de> serde::Deserialize<'de> for RecoverRequest {
12816 #[allow(deprecated)]
12817 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12818 where
12819 D: serde::Deserializer<'de>,
12820 {
12821 const FIELDS: &[&str] = &[
12822 ];
12823
12824 #[allow(clippy::enum_variant_names)]
12825 enum GeneratedField {
12826 }
12827 impl<'de> serde::Deserialize<'de> for GeneratedField {
12828 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12829 where
12830 D: serde::Deserializer<'de>,
12831 {
12832 struct GeneratedVisitor;
12833
12834 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12835 type Value = GeneratedField;
12836
12837 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12838 write!(formatter, "expected one of: {:?}", &FIELDS)
12839 }
12840
12841 #[allow(unused_variables)]
12842 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12843 where
12844 E: serde::de::Error,
12845 {
12846 Err(serde::de::Error::unknown_field(value, FIELDS))
12847 }
12848 }
12849 deserializer.deserialize_identifier(GeneratedVisitor)
12850 }
12851 }
12852 struct GeneratedVisitor;
12853 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12854 type Value = RecoverRequest;
12855
12856 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12857 formatter.write_str("struct meta.RecoverRequest")
12858 }
12859
12860 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
12861 where
12862 V: serde::de::MapAccess<'de>,
12863 {
12864 while map_.next_key::<GeneratedField>()?.is_some() {
12865 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12866 }
12867 Ok(RecoverRequest {
12868 })
12869 }
12870 }
12871 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
12872 }
12873}
12874impl serde::Serialize for RecoverResponse {
12875 #[allow(deprecated)]
12876 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12877 where
12878 S: serde::Serializer,
12879 {
12880 use serde::ser::SerializeStruct;
12881 let len = 0;
12882 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
12883 struct_ser.end()
12884 }
12885}
12886impl<'de> serde::Deserialize<'de> for RecoverResponse {
12887 #[allow(deprecated)]
12888 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12889 where
12890 D: serde::Deserializer<'de>,
12891 {
12892 const FIELDS: &[&str] = &[
12893 ];
12894
12895 #[allow(clippy::enum_variant_names)]
12896 enum GeneratedField {
12897 }
12898 impl<'de> serde::Deserialize<'de> for GeneratedField {
12899 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12900 where
12901 D: serde::Deserializer<'de>,
12902 {
12903 struct GeneratedVisitor;
12904
12905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12906 type Value = GeneratedField;
12907
12908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12909 write!(formatter, "expected one of: {:?}", &FIELDS)
12910 }
12911
12912 #[allow(unused_variables)]
12913 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12914 where
12915 E: serde::de::Error,
12916 {
12917 Err(serde::de::Error::unknown_field(value, FIELDS))
12918 }
12919 }
12920 deserializer.deserialize_identifier(GeneratedVisitor)
12921 }
12922 }
12923 struct GeneratedVisitor;
12924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12925 type Value = RecoverResponse;
12926
12927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12928 formatter.write_str("struct meta.RecoverResponse")
12929 }
12930
12931 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
12932 where
12933 V: serde::de::MapAccess<'de>,
12934 {
12935 while map_.next_key::<GeneratedField>()?.is_some() {
12936 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12937 }
12938 Ok(RecoverResponse {
12939 })
12940 }
12941 }
12942 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
12943 }
12944}
12945impl serde::Serialize for Recovery {
12946 #[allow(deprecated)]
12947 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12948 where
12949 S: serde::Serializer,
12950 {
12951 use serde::ser::SerializeStruct;
12952 let len = 0;
12953 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
12954 struct_ser.end()
12955 }
12956}
12957impl<'de> serde::Deserialize<'de> for Recovery {
12958 #[allow(deprecated)]
12959 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12960 where
12961 D: serde::Deserializer<'de>,
12962 {
12963 const FIELDS: &[&str] = &[
12964 ];
12965
12966 #[allow(clippy::enum_variant_names)]
12967 enum GeneratedField {
12968 }
12969 impl<'de> serde::Deserialize<'de> for GeneratedField {
12970 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12971 where
12972 D: serde::Deserializer<'de>,
12973 {
12974 struct GeneratedVisitor;
12975
12976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12977 type Value = GeneratedField;
12978
12979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12980 write!(formatter, "expected one of: {:?}", &FIELDS)
12981 }
12982
12983 #[allow(unused_variables)]
12984 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12985 where
12986 E: serde::de::Error,
12987 {
12988 Err(serde::de::Error::unknown_field(value, FIELDS))
12989 }
12990 }
12991 deserializer.deserialize_identifier(GeneratedVisitor)
12992 }
12993 }
12994 struct GeneratedVisitor;
12995 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12996 type Value = Recovery;
12997
12998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12999 formatter.write_str("struct meta.Recovery")
13000 }
13001
13002 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
13003 where
13004 V: serde::de::MapAccess<'de>,
13005 {
13006 while map_.next_key::<GeneratedField>()?.is_some() {
13007 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13008 }
13009 Ok(Recovery {
13010 })
13011 }
13012 }
13013 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
13014 }
13015}
13016impl serde::Serialize for RecoveryStatus {
13017 #[allow(deprecated)]
13018 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13019 where
13020 S: serde::Serializer,
13021 {
13022 let variant = match self {
13023 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
13024 Self::StatusStarting => "STATUS_STARTING",
13025 Self::StatusRecovering => "STATUS_RECOVERING",
13026 Self::StatusRunning => "STATUS_RUNNING",
13027 };
13028 serializer.serialize_str(variant)
13029 }
13030}
13031impl<'de> serde::Deserialize<'de> for RecoveryStatus {
13032 #[allow(deprecated)]
13033 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13034 where
13035 D: serde::Deserializer<'de>,
13036 {
13037 const FIELDS: &[&str] = &[
13038 "STATUS_UNSPECIFIED",
13039 "STATUS_STARTING",
13040 "STATUS_RECOVERING",
13041 "STATUS_RUNNING",
13042 ];
13043
13044 struct GeneratedVisitor;
13045
13046 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13047 type Value = RecoveryStatus;
13048
13049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13050 write!(formatter, "expected one of: {:?}", &FIELDS)
13051 }
13052
13053 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13054 where
13055 E: serde::de::Error,
13056 {
13057 i32::try_from(v)
13058 .ok()
13059 .and_then(|x| x.try_into().ok())
13060 .ok_or_else(|| {
13061 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13062 })
13063 }
13064
13065 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13066 where
13067 E: serde::de::Error,
13068 {
13069 i32::try_from(v)
13070 .ok()
13071 .and_then(|x| x.try_into().ok())
13072 .ok_or_else(|| {
13073 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13074 })
13075 }
13076
13077 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13078 where
13079 E: serde::de::Error,
13080 {
13081 match value {
13082 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
13083 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
13084 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
13085 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
13086 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13087 }
13088 }
13089 }
13090 deserializer.deserialize_any(GeneratedVisitor)
13091 }
13092}
13093impl serde::Serialize for RefreshRequest {
13094 #[allow(deprecated)]
13095 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13096 where
13097 S: serde::Serializer,
13098 {
13099 use serde::ser::SerializeStruct;
13100 let mut len = 0;
13101 if self.table_id != 0 {
13102 len += 1;
13103 }
13104 if self.associated_source_id != 0 {
13105 len += 1;
13106 }
13107 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
13108 if self.table_id != 0 {
13109 struct_ser.serialize_field("tableId", &self.table_id)?;
13110 }
13111 if self.associated_source_id != 0 {
13112 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
13113 }
13114 struct_ser.end()
13115 }
13116}
13117impl<'de> serde::Deserialize<'de> for RefreshRequest {
13118 #[allow(deprecated)]
13119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13120 where
13121 D: serde::Deserializer<'de>,
13122 {
13123 const FIELDS: &[&str] = &[
13124 "table_id",
13125 "tableId",
13126 "associated_source_id",
13127 "associatedSourceId",
13128 ];
13129
13130 #[allow(clippy::enum_variant_names)]
13131 enum GeneratedField {
13132 TableId,
13133 AssociatedSourceId,
13134 }
13135 impl<'de> serde::Deserialize<'de> for GeneratedField {
13136 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13137 where
13138 D: serde::Deserializer<'de>,
13139 {
13140 struct GeneratedVisitor;
13141
13142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13143 type Value = GeneratedField;
13144
13145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13146 write!(formatter, "expected one of: {:?}", &FIELDS)
13147 }
13148
13149 #[allow(unused_variables)]
13150 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13151 where
13152 E: serde::de::Error,
13153 {
13154 match value {
13155 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13156 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
13157 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13158 }
13159 }
13160 }
13161 deserializer.deserialize_identifier(GeneratedVisitor)
13162 }
13163 }
13164 struct GeneratedVisitor;
13165 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13166 type Value = RefreshRequest;
13167
13168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13169 formatter.write_str("struct meta.RefreshRequest")
13170 }
13171
13172 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
13173 where
13174 V: serde::de::MapAccess<'de>,
13175 {
13176 let mut table_id__ = None;
13177 let mut associated_source_id__ = None;
13178 while let Some(k) = map_.next_key()? {
13179 match k {
13180 GeneratedField::TableId => {
13181 if table_id__.is_some() {
13182 return Err(serde::de::Error::duplicate_field("tableId"));
13183 }
13184 table_id__ =
13185 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13186 ;
13187 }
13188 GeneratedField::AssociatedSourceId => {
13189 if associated_source_id__.is_some() {
13190 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
13191 }
13192 associated_source_id__ =
13193 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13194 ;
13195 }
13196 }
13197 }
13198 Ok(RefreshRequest {
13199 table_id: table_id__.unwrap_or_default(),
13200 associated_source_id: associated_source_id__.unwrap_or_default(),
13201 })
13202 }
13203 }
13204 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
13205 }
13206}
13207impl serde::Serialize for RefreshResponse {
13208 #[allow(deprecated)]
13209 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13210 where
13211 S: serde::Serializer,
13212 {
13213 use serde::ser::SerializeStruct;
13214 let mut len = 0;
13215 if self.status.is_some() {
13216 len += 1;
13217 }
13218 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
13219 if let Some(v) = self.status.as_ref() {
13220 struct_ser.serialize_field("status", v)?;
13221 }
13222 struct_ser.end()
13223 }
13224}
13225impl<'de> serde::Deserialize<'de> for RefreshResponse {
13226 #[allow(deprecated)]
13227 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13228 where
13229 D: serde::Deserializer<'de>,
13230 {
13231 const FIELDS: &[&str] = &[
13232 "status",
13233 ];
13234
13235 #[allow(clippy::enum_variant_names)]
13236 enum GeneratedField {
13237 Status,
13238 }
13239 impl<'de> serde::Deserialize<'de> for GeneratedField {
13240 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13241 where
13242 D: serde::Deserializer<'de>,
13243 {
13244 struct GeneratedVisitor;
13245
13246 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13247 type Value = GeneratedField;
13248
13249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13250 write!(formatter, "expected one of: {:?}", &FIELDS)
13251 }
13252
13253 #[allow(unused_variables)]
13254 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13255 where
13256 E: serde::de::Error,
13257 {
13258 match value {
13259 "status" => Ok(GeneratedField::Status),
13260 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13261 }
13262 }
13263 }
13264 deserializer.deserialize_identifier(GeneratedVisitor)
13265 }
13266 }
13267 struct GeneratedVisitor;
13268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13269 type Value = RefreshResponse;
13270
13271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13272 formatter.write_str("struct meta.RefreshResponse")
13273 }
13274
13275 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
13276 where
13277 V: serde::de::MapAccess<'de>,
13278 {
13279 let mut status__ = None;
13280 while let Some(k) = map_.next_key()? {
13281 match k {
13282 GeneratedField::Status => {
13283 if status__.is_some() {
13284 return Err(serde::de::Error::duplicate_field("status"));
13285 }
13286 status__ = map_.next_value()?;
13287 }
13288 }
13289 }
13290 Ok(RefreshResponse {
13291 status: status__,
13292 })
13293 }
13294 }
13295 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
13296 }
13297}
13298impl serde::Serialize for RelationIdInfos {
13299 #[allow(deprecated)]
13300 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13301 where
13302 S: serde::Serializer,
13303 {
13304 use serde::ser::SerializeStruct;
13305 let mut len = 0;
13306 if !self.map.is_empty() {
13307 len += 1;
13308 }
13309 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
13310 if !self.map.is_empty() {
13311 struct_ser.serialize_field("map", &self.map)?;
13312 }
13313 struct_ser.end()
13314 }
13315}
13316impl<'de> serde::Deserialize<'de> for RelationIdInfos {
13317 #[allow(deprecated)]
13318 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13319 where
13320 D: serde::Deserializer<'de>,
13321 {
13322 const FIELDS: &[&str] = &[
13323 "map",
13324 ];
13325
13326 #[allow(clippy::enum_variant_names)]
13327 enum GeneratedField {
13328 Map,
13329 }
13330 impl<'de> serde::Deserialize<'de> for GeneratedField {
13331 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13332 where
13333 D: serde::Deserializer<'de>,
13334 {
13335 struct GeneratedVisitor;
13336
13337 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13338 type Value = GeneratedField;
13339
13340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13341 write!(formatter, "expected one of: {:?}", &FIELDS)
13342 }
13343
13344 #[allow(unused_variables)]
13345 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13346 where
13347 E: serde::de::Error,
13348 {
13349 match value {
13350 "map" => Ok(GeneratedField::Map),
13351 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13352 }
13353 }
13354 }
13355 deserializer.deserialize_identifier(GeneratedVisitor)
13356 }
13357 }
13358 struct GeneratedVisitor;
13359 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13360 type Value = RelationIdInfos;
13361
13362 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13363 formatter.write_str("struct meta.RelationIdInfos")
13364 }
13365
13366 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
13367 where
13368 V: serde::de::MapAccess<'de>,
13369 {
13370 let mut map__ = None;
13371 while let Some(k) = map_.next_key()? {
13372 match k {
13373 GeneratedField::Map => {
13374 if map__.is_some() {
13375 return Err(serde::de::Error::duplicate_field("map"));
13376 }
13377 map__ = Some(
13378 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13379 .into_iter().map(|(k,v)| (k.0, v)).collect()
13380 );
13381 }
13382 }
13383 }
13384 Ok(RelationIdInfos {
13385 map: map__.unwrap_or_default(),
13386 })
13387 }
13388 }
13389 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
13390 }
13391}
13392impl serde::Serialize for RescheduleRequest {
13393 #[allow(deprecated)]
13394 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13395 where
13396 S: serde::Serializer,
13397 {
13398 use serde::ser::SerializeStruct;
13399 let mut len = 0;
13400 if self.revision != 0 {
13401 len += 1;
13402 }
13403 if self.resolve_no_shuffle_upstream {
13404 len += 1;
13405 }
13406 if !self.worker_reschedules.is_empty() {
13407 len += 1;
13408 }
13409 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
13410 if self.revision != 0 {
13411 #[allow(clippy::needless_borrow)]
13412 #[allow(clippy::needless_borrows_for_generic_args)]
13413 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13414 }
13415 if self.resolve_no_shuffle_upstream {
13416 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
13417 }
13418 if !self.worker_reschedules.is_empty() {
13419 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
13420 }
13421 struct_ser.end()
13422 }
13423}
13424impl<'de> serde::Deserialize<'de> for RescheduleRequest {
13425 #[allow(deprecated)]
13426 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13427 where
13428 D: serde::Deserializer<'de>,
13429 {
13430 const FIELDS: &[&str] = &[
13431 "revision",
13432 "resolve_no_shuffle_upstream",
13433 "resolveNoShuffleUpstream",
13434 "worker_reschedules",
13435 "workerReschedules",
13436 ];
13437
13438 #[allow(clippy::enum_variant_names)]
13439 enum GeneratedField {
13440 Revision,
13441 ResolveNoShuffleUpstream,
13442 WorkerReschedules,
13443 }
13444 impl<'de> serde::Deserialize<'de> for GeneratedField {
13445 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13446 where
13447 D: serde::Deserializer<'de>,
13448 {
13449 struct GeneratedVisitor;
13450
13451 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13452 type Value = GeneratedField;
13453
13454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13455 write!(formatter, "expected one of: {:?}", &FIELDS)
13456 }
13457
13458 #[allow(unused_variables)]
13459 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13460 where
13461 E: serde::de::Error,
13462 {
13463 match value {
13464 "revision" => Ok(GeneratedField::Revision),
13465 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
13466 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
13467 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13468 }
13469 }
13470 }
13471 deserializer.deserialize_identifier(GeneratedVisitor)
13472 }
13473 }
13474 struct GeneratedVisitor;
13475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13476 type Value = RescheduleRequest;
13477
13478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13479 formatter.write_str("struct meta.RescheduleRequest")
13480 }
13481
13482 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
13483 where
13484 V: serde::de::MapAccess<'de>,
13485 {
13486 let mut revision__ = None;
13487 let mut resolve_no_shuffle_upstream__ = None;
13488 let mut worker_reschedules__ = None;
13489 while let Some(k) = map_.next_key()? {
13490 match k {
13491 GeneratedField::Revision => {
13492 if revision__.is_some() {
13493 return Err(serde::de::Error::duplicate_field("revision"));
13494 }
13495 revision__ =
13496 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13497 ;
13498 }
13499 GeneratedField::ResolveNoShuffleUpstream => {
13500 if resolve_no_shuffle_upstream__.is_some() {
13501 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
13502 }
13503 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
13504 }
13505 GeneratedField::WorkerReschedules => {
13506 if worker_reschedules__.is_some() {
13507 return Err(serde::de::Error::duplicate_field("workerReschedules"));
13508 }
13509 worker_reschedules__ = Some(
13510 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13511 .into_iter().map(|(k,v)| (k.0, v)).collect()
13512 );
13513 }
13514 }
13515 }
13516 Ok(RescheduleRequest {
13517 revision: revision__.unwrap_or_default(),
13518 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
13519 worker_reschedules: worker_reschedules__.unwrap_or_default(),
13520 })
13521 }
13522 }
13523 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
13524 }
13525}
13526impl serde::Serialize for RescheduleResponse {
13527 #[allow(deprecated)]
13528 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13529 where
13530 S: serde::Serializer,
13531 {
13532 use serde::ser::SerializeStruct;
13533 let mut len = 0;
13534 if self.success {
13535 len += 1;
13536 }
13537 if self.revision != 0 {
13538 len += 1;
13539 }
13540 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
13541 if self.success {
13542 struct_ser.serialize_field("success", &self.success)?;
13543 }
13544 if self.revision != 0 {
13545 #[allow(clippy::needless_borrow)]
13546 #[allow(clippy::needless_borrows_for_generic_args)]
13547 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13548 }
13549 struct_ser.end()
13550 }
13551}
13552impl<'de> serde::Deserialize<'de> for RescheduleResponse {
13553 #[allow(deprecated)]
13554 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13555 where
13556 D: serde::Deserializer<'de>,
13557 {
13558 const FIELDS: &[&str] = &[
13559 "success",
13560 "revision",
13561 ];
13562
13563 #[allow(clippy::enum_variant_names)]
13564 enum GeneratedField {
13565 Success,
13566 Revision,
13567 }
13568 impl<'de> serde::Deserialize<'de> for GeneratedField {
13569 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13570 where
13571 D: serde::Deserializer<'de>,
13572 {
13573 struct GeneratedVisitor;
13574
13575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13576 type Value = GeneratedField;
13577
13578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13579 write!(formatter, "expected one of: {:?}", &FIELDS)
13580 }
13581
13582 #[allow(unused_variables)]
13583 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13584 where
13585 E: serde::de::Error,
13586 {
13587 match value {
13588 "success" => Ok(GeneratedField::Success),
13589 "revision" => Ok(GeneratedField::Revision),
13590 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13591 }
13592 }
13593 }
13594 deserializer.deserialize_identifier(GeneratedVisitor)
13595 }
13596 }
13597 struct GeneratedVisitor;
13598 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13599 type Value = RescheduleResponse;
13600
13601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13602 formatter.write_str("struct meta.RescheduleResponse")
13603 }
13604
13605 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
13606 where
13607 V: serde::de::MapAccess<'de>,
13608 {
13609 let mut success__ = None;
13610 let mut revision__ = None;
13611 while let Some(k) = map_.next_key()? {
13612 match k {
13613 GeneratedField::Success => {
13614 if success__.is_some() {
13615 return Err(serde::de::Error::duplicate_field("success"));
13616 }
13617 success__ = Some(map_.next_value()?);
13618 }
13619 GeneratedField::Revision => {
13620 if revision__.is_some() {
13621 return Err(serde::de::Error::duplicate_field("revision"));
13622 }
13623 revision__ =
13624 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13625 ;
13626 }
13627 }
13628 }
13629 Ok(RescheduleResponse {
13630 success: success__.unwrap_or_default(),
13631 revision: revision__.unwrap_or_default(),
13632 })
13633 }
13634 }
13635 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
13636 }
13637}
13638impl serde::Serialize for ResumeRequest {
13639 #[allow(deprecated)]
13640 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13641 where
13642 S: serde::Serializer,
13643 {
13644 use serde::ser::SerializeStruct;
13645 let len = 0;
13646 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
13647 struct_ser.end()
13648 }
13649}
13650impl<'de> serde::Deserialize<'de> for ResumeRequest {
13651 #[allow(deprecated)]
13652 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13653 where
13654 D: serde::Deserializer<'de>,
13655 {
13656 const FIELDS: &[&str] = &[
13657 ];
13658
13659 #[allow(clippy::enum_variant_names)]
13660 enum GeneratedField {
13661 }
13662 impl<'de> serde::Deserialize<'de> for GeneratedField {
13663 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13664 where
13665 D: serde::Deserializer<'de>,
13666 {
13667 struct GeneratedVisitor;
13668
13669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13670 type Value = GeneratedField;
13671
13672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13673 write!(formatter, "expected one of: {:?}", &FIELDS)
13674 }
13675
13676 #[allow(unused_variables)]
13677 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13678 where
13679 E: serde::de::Error,
13680 {
13681 Err(serde::de::Error::unknown_field(value, FIELDS))
13682 }
13683 }
13684 deserializer.deserialize_identifier(GeneratedVisitor)
13685 }
13686 }
13687 struct GeneratedVisitor;
13688 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13689 type Value = ResumeRequest;
13690
13691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13692 formatter.write_str("struct meta.ResumeRequest")
13693 }
13694
13695 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
13696 where
13697 V: serde::de::MapAccess<'de>,
13698 {
13699 while map_.next_key::<GeneratedField>()?.is_some() {
13700 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13701 }
13702 Ok(ResumeRequest {
13703 })
13704 }
13705 }
13706 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
13707 }
13708}
13709impl serde::Serialize for ResumeResponse {
13710 #[allow(deprecated)]
13711 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13712 where
13713 S: serde::Serializer,
13714 {
13715 use serde::ser::SerializeStruct;
13716 let len = 0;
13717 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
13718 struct_ser.end()
13719 }
13720}
13721impl<'de> serde::Deserialize<'de> for ResumeResponse {
13722 #[allow(deprecated)]
13723 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13724 where
13725 D: serde::Deserializer<'de>,
13726 {
13727 const FIELDS: &[&str] = &[
13728 ];
13729
13730 #[allow(clippy::enum_variant_names)]
13731 enum GeneratedField {
13732 }
13733 impl<'de> serde::Deserialize<'de> for GeneratedField {
13734 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13735 where
13736 D: serde::Deserializer<'de>,
13737 {
13738 struct GeneratedVisitor;
13739
13740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13741 type Value = GeneratedField;
13742
13743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13744 write!(formatter, "expected one of: {:?}", &FIELDS)
13745 }
13746
13747 #[allow(unused_variables)]
13748 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13749 where
13750 E: serde::de::Error,
13751 {
13752 Err(serde::de::Error::unknown_field(value, FIELDS))
13753 }
13754 }
13755 deserializer.deserialize_identifier(GeneratedVisitor)
13756 }
13757 }
13758 struct GeneratedVisitor;
13759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13760 type Value = ResumeResponse;
13761
13762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13763 formatter.write_str("struct meta.ResumeResponse")
13764 }
13765
13766 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
13767 where
13768 V: serde::de::MapAccess<'de>,
13769 {
13770 while map_.next_key::<GeneratedField>()?.is_some() {
13771 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13772 }
13773 Ok(ResumeResponse {
13774 })
13775 }
13776 }
13777 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
13778 }
13779}
13780impl serde::Serialize for SetSessionParamRequest {
13781 #[allow(deprecated)]
13782 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13783 where
13784 S: serde::Serializer,
13785 {
13786 use serde::ser::SerializeStruct;
13787 let mut len = 0;
13788 if !self.param.is_empty() {
13789 len += 1;
13790 }
13791 if self.value.is_some() {
13792 len += 1;
13793 }
13794 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
13795 if !self.param.is_empty() {
13796 struct_ser.serialize_field("param", &self.param)?;
13797 }
13798 if let Some(v) = self.value.as_ref() {
13799 struct_ser.serialize_field("value", v)?;
13800 }
13801 struct_ser.end()
13802 }
13803}
13804impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
13805 #[allow(deprecated)]
13806 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13807 where
13808 D: serde::Deserializer<'de>,
13809 {
13810 const FIELDS: &[&str] = &[
13811 "param",
13812 "value",
13813 ];
13814
13815 #[allow(clippy::enum_variant_names)]
13816 enum GeneratedField {
13817 Param,
13818 Value,
13819 }
13820 impl<'de> serde::Deserialize<'de> for GeneratedField {
13821 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13822 where
13823 D: serde::Deserializer<'de>,
13824 {
13825 struct GeneratedVisitor;
13826
13827 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13828 type Value = GeneratedField;
13829
13830 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13831 write!(formatter, "expected one of: {:?}", &FIELDS)
13832 }
13833
13834 #[allow(unused_variables)]
13835 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13836 where
13837 E: serde::de::Error,
13838 {
13839 match value {
13840 "param" => Ok(GeneratedField::Param),
13841 "value" => Ok(GeneratedField::Value),
13842 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13843 }
13844 }
13845 }
13846 deserializer.deserialize_identifier(GeneratedVisitor)
13847 }
13848 }
13849 struct GeneratedVisitor;
13850 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13851 type Value = SetSessionParamRequest;
13852
13853 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13854 formatter.write_str("struct meta.SetSessionParamRequest")
13855 }
13856
13857 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
13858 where
13859 V: serde::de::MapAccess<'de>,
13860 {
13861 let mut param__ = None;
13862 let mut value__ = None;
13863 while let Some(k) = map_.next_key()? {
13864 match k {
13865 GeneratedField::Param => {
13866 if param__.is_some() {
13867 return Err(serde::de::Error::duplicate_field("param"));
13868 }
13869 param__ = Some(map_.next_value()?);
13870 }
13871 GeneratedField::Value => {
13872 if value__.is_some() {
13873 return Err(serde::de::Error::duplicate_field("value"));
13874 }
13875 value__ = map_.next_value()?;
13876 }
13877 }
13878 }
13879 Ok(SetSessionParamRequest {
13880 param: param__.unwrap_or_default(),
13881 value: value__,
13882 })
13883 }
13884 }
13885 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
13886 }
13887}
13888impl serde::Serialize for SetSessionParamResponse {
13889 #[allow(deprecated)]
13890 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13891 where
13892 S: serde::Serializer,
13893 {
13894 use serde::ser::SerializeStruct;
13895 let mut len = 0;
13896 if !self.param.is_empty() {
13897 len += 1;
13898 }
13899 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
13900 if !self.param.is_empty() {
13901 struct_ser.serialize_field("param", &self.param)?;
13902 }
13903 struct_ser.end()
13904 }
13905}
13906impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
13907 #[allow(deprecated)]
13908 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13909 where
13910 D: serde::Deserializer<'de>,
13911 {
13912 const FIELDS: &[&str] = &[
13913 "param",
13914 ];
13915
13916 #[allow(clippy::enum_variant_names)]
13917 enum GeneratedField {
13918 Param,
13919 }
13920 impl<'de> serde::Deserialize<'de> for GeneratedField {
13921 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13922 where
13923 D: serde::Deserializer<'de>,
13924 {
13925 struct GeneratedVisitor;
13926
13927 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13928 type Value = GeneratedField;
13929
13930 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13931 write!(formatter, "expected one of: {:?}", &FIELDS)
13932 }
13933
13934 #[allow(unused_variables)]
13935 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13936 where
13937 E: serde::de::Error,
13938 {
13939 match value {
13940 "param" => Ok(GeneratedField::Param),
13941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13942 }
13943 }
13944 }
13945 deserializer.deserialize_identifier(GeneratedVisitor)
13946 }
13947 }
13948 struct GeneratedVisitor;
13949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13950 type Value = SetSessionParamResponse;
13951
13952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13953 formatter.write_str("struct meta.SetSessionParamResponse")
13954 }
13955
13956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
13957 where
13958 V: serde::de::MapAccess<'de>,
13959 {
13960 let mut param__ = None;
13961 while let Some(k) = map_.next_key()? {
13962 match k {
13963 GeneratedField::Param => {
13964 if param__.is_some() {
13965 return Err(serde::de::Error::duplicate_field("param"));
13966 }
13967 param__ = Some(map_.next_value()?);
13968 }
13969 }
13970 }
13971 Ok(SetSessionParamResponse {
13972 param: param__.unwrap_or_default(),
13973 })
13974 }
13975 }
13976 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
13977 }
13978}
13979impl serde::Serialize for SetSyncLogStoreAlignedRequest {
13980 #[allow(deprecated)]
13981 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13982 where
13983 S: serde::Serializer,
13984 {
13985 use serde::ser::SerializeStruct;
13986 let mut len = 0;
13987 if self.job_id != 0 {
13988 len += 1;
13989 }
13990 if self.aligned {
13991 len += 1;
13992 }
13993 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
13994 if self.job_id != 0 {
13995 struct_ser.serialize_field("jobId", &self.job_id)?;
13996 }
13997 if self.aligned {
13998 struct_ser.serialize_field("aligned", &self.aligned)?;
13999 }
14000 struct_ser.end()
14001 }
14002}
14003impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
14004 #[allow(deprecated)]
14005 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14006 where
14007 D: serde::Deserializer<'de>,
14008 {
14009 const FIELDS: &[&str] = &[
14010 "job_id",
14011 "jobId",
14012 "aligned",
14013 ];
14014
14015 #[allow(clippy::enum_variant_names)]
14016 enum GeneratedField {
14017 JobId,
14018 Aligned,
14019 }
14020 impl<'de> serde::Deserialize<'de> for GeneratedField {
14021 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14022 where
14023 D: serde::Deserializer<'de>,
14024 {
14025 struct GeneratedVisitor;
14026
14027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14028 type Value = GeneratedField;
14029
14030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14031 write!(formatter, "expected one of: {:?}", &FIELDS)
14032 }
14033
14034 #[allow(unused_variables)]
14035 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14036 where
14037 E: serde::de::Error,
14038 {
14039 match value {
14040 "jobId" | "job_id" => Ok(GeneratedField::JobId),
14041 "aligned" => Ok(GeneratedField::Aligned),
14042 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14043 }
14044 }
14045 }
14046 deserializer.deserialize_identifier(GeneratedVisitor)
14047 }
14048 }
14049 struct GeneratedVisitor;
14050 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14051 type Value = SetSyncLogStoreAlignedRequest;
14052
14053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14054 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
14055 }
14056
14057 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
14058 where
14059 V: serde::de::MapAccess<'de>,
14060 {
14061 let mut job_id__ = None;
14062 let mut aligned__ = None;
14063 while let Some(k) = map_.next_key()? {
14064 match k {
14065 GeneratedField::JobId => {
14066 if job_id__.is_some() {
14067 return Err(serde::de::Error::duplicate_field("jobId"));
14068 }
14069 job_id__ =
14070 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14071 ;
14072 }
14073 GeneratedField::Aligned => {
14074 if aligned__.is_some() {
14075 return Err(serde::de::Error::duplicate_field("aligned"));
14076 }
14077 aligned__ = Some(map_.next_value()?);
14078 }
14079 }
14080 }
14081 Ok(SetSyncLogStoreAlignedRequest {
14082 job_id: job_id__.unwrap_or_default(),
14083 aligned: aligned__.unwrap_or_default(),
14084 })
14085 }
14086 }
14087 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
14088 }
14089}
14090impl serde::Serialize for SetSyncLogStoreAlignedResponse {
14091 #[allow(deprecated)]
14092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14093 where
14094 S: serde::Serializer,
14095 {
14096 use serde::ser::SerializeStruct;
14097 let len = 0;
14098 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
14099 struct_ser.end()
14100 }
14101}
14102impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
14103 #[allow(deprecated)]
14104 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14105 where
14106 D: serde::Deserializer<'de>,
14107 {
14108 const FIELDS: &[&str] = &[
14109 ];
14110
14111 #[allow(clippy::enum_variant_names)]
14112 enum GeneratedField {
14113 }
14114 impl<'de> serde::Deserialize<'de> for GeneratedField {
14115 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14116 where
14117 D: serde::Deserializer<'de>,
14118 {
14119 struct GeneratedVisitor;
14120
14121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14122 type Value = GeneratedField;
14123
14124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14125 write!(formatter, "expected one of: {:?}", &FIELDS)
14126 }
14127
14128 #[allow(unused_variables)]
14129 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14130 where
14131 E: serde::de::Error,
14132 {
14133 Err(serde::de::Error::unknown_field(value, FIELDS))
14134 }
14135 }
14136 deserializer.deserialize_identifier(GeneratedVisitor)
14137 }
14138 }
14139 struct GeneratedVisitor;
14140 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14141 type Value = SetSyncLogStoreAlignedResponse;
14142
14143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14144 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
14145 }
14146
14147 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
14148 where
14149 V: serde::de::MapAccess<'de>,
14150 {
14151 while map_.next_key::<GeneratedField>()?.is_some() {
14152 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14153 }
14154 Ok(SetSyncLogStoreAlignedResponse {
14155 })
14156 }
14157 }
14158 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
14159 }
14160}
14161impl serde::Serialize for SetSystemParamRequest {
14162 #[allow(deprecated)]
14163 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14164 where
14165 S: serde::Serializer,
14166 {
14167 use serde::ser::SerializeStruct;
14168 let mut len = 0;
14169 if !self.param.is_empty() {
14170 len += 1;
14171 }
14172 if self.value.is_some() {
14173 len += 1;
14174 }
14175 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
14176 if !self.param.is_empty() {
14177 struct_ser.serialize_field("param", &self.param)?;
14178 }
14179 if let Some(v) = self.value.as_ref() {
14180 struct_ser.serialize_field("value", v)?;
14181 }
14182 struct_ser.end()
14183 }
14184}
14185impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
14186 #[allow(deprecated)]
14187 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14188 where
14189 D: serde::Deserializer<'de>,
14190 {
14191 const FIELDS: &[&str] = &[
14192 "param",
14193 "value",
14194 ];
14195
14196 #[allow(clippy::enum_variant_names)]
14197 enum GeneratedField {
14198 Param,
14199 Value,
14200 }
14201 impl<'de> serde::Deserialize<'de> for GeneratedField {
14202 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14203 where
14204 D: serde::Deserializer<'de>,
14205 {
14206 struct GeneratedVisitor;
14207
14208 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14209 type Value = GeneratedField;
14210
14211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14212 write!(formatter, "expected one of: {:?}", &FIELDS)
14213 }
14214
14215 #[allow(unused_variables)]
14216 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14217 where
14218 E: serde::de::Error,
14219 {
14220 match value {
14221 "param" => Ok(GeneratedField::Param),
14222 "value" => Ok(GeneratedField::Value),
14223 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14224 }
14225 }
14226 }
14227 deserializer.deserialize_identifier(GeneratedVisitor)
14228 }
14229 }
14230 struct GeneratedVisitor;
14231 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14232 type Value = SetSystemParamRequest;
14233
14234 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14235 formatter.write_str("struct meta.SetSystemParamRequest")
14236 }
14237
14238 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
14239 where
14240 V: serde::de::MapAccess<'de>,
14241 {
14242 let mut param__ = None;
14243 let mut value__ = None;
14244 while let Some(k) = map_.next_key()? {
14245 match k {
14246 GeneratedField::Param => {
14247 if param__.is_some() {
14248 return Err(serde::de::Error::duplicate_field("param"));
14249 }
14250 param__ = Some(map_.next_value()?);
14251 }
14252 GeneratedField::Value => {
14253 if value__.is_some() {
14254 return Err(serde::de::Error::duplicate_field("value"));
14255 }
14256 value__ = map_.next_value()?;
14257 }
14258 }
14259 }
14260 Ok(SetSystemParamRequest {
14261 param: param__.unwrap_or_default(),
14262 value: value__,
14263 })
14264 }
14265 }
14266 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
14267 }
14268}
14269impl serde::Serialize for SetSystemParamResponse {
14270 #[allow(deprecated)]
14271 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14272 where
14273 S: serde::Serializer,
14274 {
14275 use serde::ser::SerializeStruct;
14276 let mut len = 0;
14277 if self.params.is_some() {
14278 len += 1;
14279 }
14280 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
14281 if let Some(v) = self.params.as_ref() {
14282 struct_ser.serialize_field("params", v)?;
14283 }
14284 struct_ser.end()
14285 }
14286}
14287impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
14288 #[allow(deprecated)]
14289 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14290 where
14291 D: serde::Deserializer<'de>,
14292 {
14293 const FIELDS: &[&str] = &[
14294 "params",
14295 ];
14296
14297 #[allow(clippy::enum_variant_names)]
14298 enum GeneratedField {
14299 Params,
14300 }
14301 impl<'de> serde::Deserialize<'de> for GeneratedField {
14302 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14303 where
14304 D: serde::Deserializer<'de>,
14305 {
14306 struct GeneratedVisitor;
14307
14308 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14309 type Value = GeneratedField;
14310
14311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14312 write!(formatter, "expected one of: {:?}", &FIELDS)
14313 }
14314
14315 #[allow(unused_variables)]
14316 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14317 where
14318 E: serde::de::Error,
14319 {
14320 match value {
14321 "params" => Ok(GeneratedField::Params),
14322 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14323 }
14324 }
14325 }
14326 deserializer.deserialize_identifier(GeneratedVisitor)
14327 }
14328 }
14329 struct GeneratedVisitor;
14330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14331 type Value = SetSystemParamResponse;
14332
14333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14334 formatter.write_str("struct meta.SetSystemParamResponse")
14335 }
14336
14337 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
14338 where
14339 V: serde::de::MapAccess<'de>,
14340 {
14341 let mut params__ = None;
14342 while let Some(k) = map_.next_key()? {
14343 match k {
14344 GeneratedField::Params => {
14345 if params__.is_some() {
14346 return Err(serde::de::Error::duplicate_field("params"));
14347 }
14348 params__ = map_.next_value()?;
14349 }
14350 }
14351 }
14352 Ok(SetSystemParamResponse {
14353 params: params__,
14354 })
14355 }
14356 }
14357 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
14358 }
14359}
14360impl serde::Serialize for SubscribeRequest {
14361 #[allow(deprecated)]
14362 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14363 where
14364 S: serde::Serializer,
14365 {
14366 use serde::ser::SerializeStruct;
14367 let mut len = 0;
14368 if self.subscribe_type != 0 {
14369 len += 1;
14370 }
14371 if self.host.is_some() {
14372 len += 1;
14373 }
14374 if self.worker_id != 0 {
14375 len += 1;
14376 }
14377 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
14378 if self.subscribe_type != 0 {
14379 let v = SubscribeType::try_from(self.subscribe_type)
14380 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
14381 struct_ser.serialize_field("subscribeType", &v)?;
14382 }
14383 if let Some(v) = self.host.as_ref() {
14384 struct_ser.serialize_field("host", v)?;
14385 }
14386 if self.worker_id != 0 {
14387 struct_ser.serialize_field("workerId", &self.worker_id)?;
14388 }
14389 struct_ser.end()
14390 }
14391}
14392impl<'de> serde::Deserialize<'de> for SubscribeRequest {
14393 #[allow(deprecated)]
14394 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14395 where
14396 D: serde::Deserializer<'de>,
14397 {
14398 const FIELDS: &[&str] = &[
14399 "subscribe_type",
14400 "subscribeType",
14401 "host",
14402 "worker_id",
14403 "workerId",
14404 ];
14405
14406 #[allow(clippy::enum_variant_names)]
14407 enum GeneratedField {
14408 SubscribeType,
14409 Host,
14410 WorkerId,
14411 }
14412 impl<'de> serde::Deserialize<'de> for GeneratedField {
14413 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14414 where
14415 D: serde::Deserializer<'de>,
14416 {
14417 struct GeneratedVisitor;
14418
14419 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14420 type Value = GeneratedField;
14421
14422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14423 write!(formatter, "expected one of: {:?}", &FIELDS)
14424 }
14425
14426 #[allow(unused_variables)]
14427 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14428 where
14429 E: serde::de::Error,
14430 {
14431 match value {
14432 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
14433 "host" => Ok(GeneratedField::Host),
14434 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
14435 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14436 }
14437 }
14438 }
14439 deserializer.deserialize_identifier(GeneratedVisitor)
14440 }
14441 }
14442 struct GeneratedVisitor;
14443 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14444 type Value = SubscribeRequest;
14445
14446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14447 formatter.write_str("struct meta.SubscribeRequest")
14448 }
14449
14450 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
14451 where
14452 V: serde::de::MapAccess<'de>,
14453 {
14454 let mut subscribe_type__ = None;
14455 let mut host__ = None;
14456 let mut worker_id__ = None;
14457 while let Some(k) = map_.next_key()? {
14458 match k {
14459 GeneratedField::SubscribeType => {
14460 if subscribe_type__.is_some() {
14461 return Err(serde::de::Error::duplicate_field("subscribeType"));
14462 }
14463 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
14464 }
14465 GeneratedField::Host => {
14466 if host__.is_some() {
14467 return Err(serde::de::Error::duplicate_field("host"));
14468 }
14469 host__ = map_.next_value()?;
14470 }
14471 GeneratedField::WorkerId => {
14472 if worker_id__.is_some() {
14473 return Err(serde::de::Error::duplicate_field("workerId"));
14474 }
14475 worker_id__ =
14476 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14477 ;
14478 }
14479 }
14480 }
14481 Ok(SubscribeRequest {
14482 subscribe_type: subscribe_type__.unwrap_or_default(),
14483 host: host__,
14484 worker_id: worker_id__.unwrap_or_default(),
14485 })
14486 }
14487 }
14488 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
14489 }
14490}
14491impl serde::Serialize for SubscribeResponse {
14492 #[allow(deprecated)]
14493 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14494 where
14495 S: serde::Serializer,
14496 {
14497 use serde::ser::SerializeStruct;
14498 let mut len = 0;
14499 if self.status.is_some() {
14500 len += 1;
14501 }
14502 if self.operation != 0 {
14503 len += 1;
14504 }
14505 if self.version != 0 {
14506 len += 1;
14507 }
14508 if self.info.is_some() {
14509 len += 1;
14510 }
14511 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
14512 if let Some(v) = self.status.as_ref() {
14513 struct_ser.serialize_field("status", v)?;
14514 }
14515 if self.operation != 0 {
14516 let v = subscribe_response::Operation::try_from(self.operation)
14517 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
14518 struct_ser.serialize_field("operation", &v)?;
14519 }
14520 if self.version != 0 {
14521 #[allow(clippy::needless_borrow)]
14522 #[allow(clippy::needless_borrows_for_generic_args)]
14523 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
14524 }
14525 if let Some(v) = self.info.as_ref() {
14526 match v {
14527 subscribe_response::Info::Database(v) => {
14528 struct_ser.serialize_field("database", v)?;
14529 }
14530 subscribe_response::Info::Schema(v) => {
14531 struct_ser.serialize_field("schema", v)?;
14532 }
14533 subscribe_response::Info::Function(v) => {
14534 struct_ser.serialize_field("function", v)?;
14535 }
14536 subscribe_response::Info::User(v) => {
14537 struct_ser.serialize_field("user", v)?;
14538 }
14539 subscribe_response::Info::SessionParam(v) => {
14540 struct_ser.serialize_field("sessionParam", v)?;
14541 }
14542 subscribe_response::Info::Node(v) => {
14543 struct_ser.serialize_field("node", v)?;
14544 }
14545 subscribe_response::Info::HummockVersionDeltas(v) => {
14546 struct_ser.serialize_field("hummockVersionDeltas", v)?;
14547 }
14548 subscribe_response::Info::Snapshot(v) => {
14549 struct_ser.serialize_field("snapshot", v)?;
14550 }
14551 subscribe_response::Info::MetaBackupManifestId(v) => {
14552 struct_ser.serialize_field("metaBackupManifestId", v)?;
14553 }
14554 subscribe_response::Info::SystemParams(v) => {
14555 struct_ser.serialize_field("systemParams", v)?;
14556 }
14557 subscribe_response::Info::HummockWriteLimits(v) => {
14558 struct_ser.serialize_field("hummockWriteLimits", v)?;
14559 }
14560 subscribe_response::Info::ObjectGroup(v) => {
14561 struct_ser.serialize_field("objectGroup", v)?;
14562 }
14563 subscribe_response::Info::Connection(v) => {
14564 struct_ser.serialize_field("connection", v)?;
14565 }
14566 subscribe_response::Info::HummockStats(v) => {
14567 struct_ser.serialize_field("hummockStats", v)?;
14568 }
14569 subscribe_response::Info::Recovery(v) => {
14570 struct_ser.serialize_field("recovery", v)?;
14571 }
14572 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
14573 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
14574 }
14575 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
14576 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
14577 }
14578 subscribe_response::Info::Secret(v) => {
14579 struct_ser.serialize_field("secret", v)?;
14580 }
14581 subscribe_response::Info::ClusterResource(v) => {
14582 struct_ser.serialize_field("clusterResource", v)?;
14583 }
14584 }
14585 }
14586 struct_ser.end()
14587 }
14588}
14589impl<'de> serde::Deserialize<'de> for SubscribeResponse {
14590 #[allow(deprecated)]
14591 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14592 where
14593 D: serde::Deserializer<'de>,
14594 {
14595 const FIELDS: &[&str] = &[
14596 "status",
14597 "operation",
14598 "version",
14599 "database",
14600 "schema",
14601 "function",
14602 "user",
14603 "session_param",
14604 "sessionParam",
14605 "node",
14606 "hummock_version_deltas",
14607 "hummockVersionDeltas",
14608 "snapshot",
14609 "meta_backup_manifest_id",
14610 "metaBackupManifestId",
14611 "system_params",
14612 "systemParams",
14613 "hummock_write_limits",
14614 "hummockWriteLimits",
14615 "object_group",
14616 "objectGroup",
14617 "connection",
14618 "hummock_stats",
14619 "hummockStats",
14620 "recovery",
14621 "streaming_worker_slot_mapping",
14622 "streamingWorkerSlotMapping",
14623 "serving_worker_slot_mappings",
14624 "servingWorkerSlotMappings",
14625 "secret",
14626 "cluster_resource",
14627 "clusterResource",
14628 ];
14629
14630 #[allow(clippy::enum_variant_names)]
14631 enum GeneratedField {
14632 Status,
14633 Operation,
14634 Version,
14635 Database,
14636 Schema,
14637 Function,
14638 User,
14639 SessionParam,
14640 Node,
14641 HummockVersionDeltas,
14642 Snapshot,
14643 MetaBackupManifestId,
14644 SystemParams,
14645 HummockWriteLimits,
14646 ObjectGroup,
14647 Connection,
14648 HummockStats,
14649 Recovery,
14650 StreamingWorkerSlotMapping,
14651 ServingWorkerSlotMappings,
14652 Secret,
14653 ClusterResource,
14654 }
14655 impl<'de> serde::Deserialize<'de> for GeneratedField {
14656 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14657 where
14658 D: serde::Deserializer<'de>,
14659 {
14660 struct GeneratedVisitor;
14661
14662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14663 type Value = GeneratedField;
14664
14665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14666 write!(formatter, "expected one of: {:?}", &FIELDS)
14667 }
14668
14669 #[allow(unused_variables)]
14670 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14671 where
14672 E: serde::de::Error,
14673 {
14674 match value {
14675 "status" => Ok(GeneratedField::Status),
14676 "operation" => Ok(GeneratedField::Operation),
14677 "version" => Ok(GeneratedField::Version),
14678 "database" => Ok(GeneratedField::Database),
14679 "schema" => Ok(GeneratedField::Schema),
14680 "function" => Ok(GeneratedField::Function),
14681 "user" => Ok(GeneratedField::User),
14682 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
14683 "node" => Ok(GeneratedField::Node),
14684 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
14685 "snapshot" => Ok(GeneratedField::Snapshot),
14686 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
14687 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
14688 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
14689 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
14690 "connection" => Ok(GeneratedField::Connection),
14691 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
14692 "recovery" => Ok(GeneratedField::Recovery),
14693 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
14694 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
14695 "secret" => Ok(GeneratedField::Secret),
14696 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
14697 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14698 }
14699 }
14700 }
14701 deserializer.deserialize_identifier(GeneratedVisitor)
14702 }
14703 }
14704 struct GeneratedVisitor;
14705 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14706 type Value = SubscribeResponse;
14707
14708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14709 formatter.write_str("struct meta.SubscribeResponse")
14710 }
14711
14712 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
14713 where
14714 V: serde::de::MapAccess<'de>,
14715 {
14716 let mut status__ = None;
14717 let mut operation__ = None;
14718 let mut version__ = None;
14719 let mut info__ = None;
14720 while let Some(k) = map_.next_key()? {
14721 match k {
14722 GeneratedField::Status => {
14723 if status__.is_some() {
14724 return Err(serde::de::Error::duplicate_field("status"));
14725 }
14726 status__ = map_.next_value()?;
14727 }
14728 GeneratedField::Operation => {
14729 if operation__.is_some() {
14730 return Err(serde::de::Error::duplicate_field("operation"));
14731 }
14732 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
14733 }
14734 GeneratedField::Version => {
14735 if version__.is_some() {
14736 return Err(serde::de::Error::duplicate_field("version"));
14737 }
14738 version__ =
14739 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14740 ;
14741 }
14742 GeneratedField::Database => {
14743 if info__.is_some() {
14744 return Err(serde::de::Error::duplicate_field("database"));
14745 }
14746 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
14747;
14748 }
14749 GeneratedField::Schema => {
14750 if info__.is_some() {
14751 return Err(serde::de::Error::duplicate_field("schema"));
14752 }
14753 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
14754;
14755 }
14756 GeneratedField::Function => {
14757 if info__.is_some() {
14758 return Err(serde::de::Error::duplicate_field("function"));
14759 }
14760 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
14761;
14762 }
14763 GeneratedField::User => {
14764 if info__.is_some() {
14765 return Err(serde::de::Error::duplicate_field("user"));
14766 }
14767 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
14768;
14769 }
14770 GeneratedField::SessionParam => {
14771 if info__.is_some() {
14772 return Err(serde::de::Error::duplicate_field("sessionParam"));
14773 }
14774 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
14775;
14776 }
14777 GeneratedField::Node => {
14778 if info__.is_some() {
14779 return Err(serde::de::Error::duplicate_field("node"));
14780 }
14781 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
14782;
14783 }
14784 GeneratedField::HummockVersionDeltas => {
14785 if info__.is_some() {
14786 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
14787 }
14788 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
14789;
14790 }
14791 GeneratedField::Snapshot => {
14792 if info__.is_some() {
14793 return Err(serde::de::Error::duplicate_field("snapshot"));
14794 }
14795 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
14796;
14797 }
14798 GeneratedField::MetaBackupManifestId => {
14799 if info__.is_some() {
14800 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14801 }
14802 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
14803;
14804 }
14805 GeneratedField::SystemParams => {
14806 if info__.is_some() {
14807 return Err(serde::de::Error::duplicate_field("systemParams"));
14808 }
14809 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
14810;
14811 }
14812 GeneratedField::HummockWriteLimits => {
14813 if info__.is_some() {
14814 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14815 }
14816 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
14817;
14818 }
14819 GeneratedField::ObjectGroup => {
14820 if info__.is_some() {
14821 return Err(serde::de::Error::duplicate_field("objectGroup"));
14822 }
14823 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
14824;
14825 }
14826 GeneratedField::Connection => {
14827 if info__.is_some() {
14828 return Err(serde::de::Error::duplicate_field("connection"));
14829 }
14830 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
14831;
14832 }
14833 GeneratedField::HummockStats => {
14834 if info__.is_some() {
14835 return Err(serde::de::Error::duplicate_field("hummockStats"));
14836 }
14837 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
14838;
14839 }
14840 GeneratedField::Recovery => {
14841 if info__.is_some() {
14842 return Err(serde::de::Error::duplicate_field("recovery"));
14843 }
14844 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
14845;
14846 }
14847 GeneratedField::StreamingWorkerSlotMapping => {
14848 if info__.is_some() {
14849 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
14850 }
14851 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
14852;
14853 }
14854 GeneratedField::ServingWorkerSlotMappings => {
14855 if info__.is_some() {
14856 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14857 }
14858 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
14859;
14860 }
14861 GeneratedField::Secret => {
14862 if info__.is_some() {
14863 return Err(serde::de::Error::duplicate_field("secret"));
14864 }
14865 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
14866;
14867 }
14868 GeneratedField::ClusterResource => {
14869 if info__.is_some() {
14870 return Err(serde::de::Error::duplicate_field("clusterResource"));
14871 }
14872 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ClusterResource)
14873;
14874 }
14875 }
14876 }
14877 Ok(SubscribeResponse {
14878 status: status__,
14879 operation: operation__.unwrap_or_default(),
14880 version: version__.unwrap_or_default(),
14881 info: info__,
14882 })
14883 }
14884 }
14885 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
14886 }
14887}
14888impl serde::Serialize for subscribe_response::Operation {
14889 #[allow(deprecated)]
14890 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14891 where
14892 S: serde::Serializer,
14893 {
14894 let variant = match self {
14895 Self::Unspecified => "UNSPECIFIED",
14896 Self::Add => "ADD",
14897 Self::Delete => "DELETE",
14898 Self::Update => "UPDATE",
14899 Self::Snapshot => "SNAPSHOT",
14900 };
14901 serializer.serialize_str(variant)
14902 }
14903}
14904impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
14905 #[allow(deprecated)]
14906 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14907 where
14908 D: serde::Deserializer<'de>,
14909 {
14910 const FIELDS: &[&str] = &[
14911 "UNSPECIFIED",
14912 "ADD",
14913 "DELETE",
14914 "UPDATE",
14915 "SNAPSHOT",
14916 ];
14917
14918 struct GeneratedVisitor;
14919
14920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14921 type Value = subscribe_response::Operation;
14922
14923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14924 write!(formatter, "expected one of: {:?}", &FIELDS)
14925 }
14926
14927 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14928 where
14929 E: serde::de::Error,
14930 {
14931 i32::try_from(v)
14932 .ok()
14933 .and_then(|x| x.try_into().ok())
14934 .ok_or_else(|| {
14935 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14936 })
14937 }
14938
14939 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14940 where
14941 E: serde::de::Error,
14942 {
14943 i32::try_from(v)
14944 .ok()
14945 .and_then(|x| x.try_into().ok())
14946 .ok_or_else(|| {
14947 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14948 })
14949 }
14950
14951 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14952 where
14953 E: serde::de::Error,
14954 {
14955 match value {
14956 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
14957 "ADD" => Ok(subscribe_response::Operation::Add),
14958 "DELETE" => Ok(subscribe_response::Operation::Delete),
14959 "UPDATE" => Ok(subscribe_response::Operation::Update),
14960 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
14961 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14962 }
14963 }
14964 }
14965 deserializer.deserialize_any(GeneratedVisitor)
14966 }
14967}
14968impl serde::Serialize for SubscribeType {
14969 #[allow(deprecated)]
14970 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14971 where
14972 S: serde::Serializer,
14973 {
14974 let variant = match self {
14975 Self::Unspecified => "UNSPECIFIED",
14976 Self::Frontend => "FRONTEND",
14977 Self::Hummock => "HUMMOCK",
14978 Self::Compactor => "COMPACTOR",
14979 Self::Compute => "COMPUTE",
14980 };
14981 serializer.serialize_str(variant)
14982 }
14983}
14984impl<'de> serde::Deserialize<'de> for SubscribeType {
14985 #[allow(deprecated)]
14986 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14987 where
14988 D: serde::Deserializer<'de>,
14989 {
14990 const FIELDS: &[&str] = &[
14991 "UNSPECIFIED",
14992 "FRONTEND",
14993 "HUMMOCK",
14994 "COMPACTOR",
14995 "COMPUTE",
14996 ];
14997
14998 struct GeneratedVisitor;
14999
15000 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15001 type Value = SubscribeType;
15002
15003 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15004 write!(formatter, "expected one of: {:?}", &FIELDS)
15005 }
15006
15007 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15008 where
15009 E: serde::de::Error,
15010 {
15011 i32::try_from(v)
15012 .ok()
15013 .and_then(|x| x.try_into().ok())
15014 .ok_or_else(|| {
15015 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15016 })
15017 }
15018
15019 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15020 where
15021 E: serde::de::Error,
15022 {
15023 i32::try_from(v)
15024 .ok()
15025 .and_then(|x| x.try_into().ok())
15026 .ok_or_else(|| {
15027 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15028 })
15029 }
15030
15031 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15032 where
15033 E: serde::de::Error,
15034 {
15035 match value {
15036 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
15037 "FRONTEND" => Ok(SubscribeType::Frontend),
15038 "HUMMOCK" => Ok(SubscribeType::Hummock),
15039 "COMPACTOR" => Ok(SubscribeType::Compactor),
15040 "COMPUTE" => Ok(SubscribeType::Compute),
15041 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15042 }
15043 }
15044 }
15045 deserializer.deserialize_any(GeneratedVisitor)
15046 }
15047}
15048impl serde::Serialize for SystemParams {
15049 #[allow(deprecated)]
15050 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15051 where
15052 S: serde::Serializer,
15053 {
15054 use serde::ser::SerializeStruct;
15055 let mut len = 0;
15056 if self.barrier_interval_ms.is_some() {
15057 len += 1;
15058 }
15059 if self.checkpoint_frequency.is_some() {
15060 len += 1;
15061 }
15062 if self.sstable_size_mb.is_some() {
15063 len += 1;
15064 }
15065 if self.block_size_kb.is_some() {
15066 len += 1;
15067 }
15068 if self.bloom_false_positive.is_some() {
15069 len += 1;
15070 }
15071 if self.state_store.is_some() {
15072 len += 1;
15073 }
15074 if self.data_directory.is_some() {
15075 len += 1;
15076 }
15077 if self.backup_storage_url.is_some() {
15078 len += 1;
15079 }
15080 if self.backup_storage_directory.is_some() {
15081 len += 1;
15082 }
15083 if self.telemetry_enabled.is_some() {
15084 len += 1;
15085 }
15086 if self.parallel_compact_size_mb.is_some() {
15087 len += 1;
15088 }
15089 if self.max_concurrent_creating_streaming_jobs.is_some() {
15090 len += 1;
15091 }
15092 if self.pause_on_next_bootstrap.is_some() {
15093 len += 1;
15094 }
15095 if self.wasm_storage_url.is_some() {
15096 len += 1;
15097 }
15098 if self.enable_tracing.is_some() {
15099 len += 1;
15100 }
15101 if self.use_new_object_prefix_strategy.is_some() {
15102 len += 1;
15103 }
15104 if self.license_key.is_some() {
15105 len += 1;
15106 }
15107 if self.time_travel_retention_ms.is_some() {
15108 len += 1;
15109 }
15110 if self.adaptive_parallelism_strategy.is_some() {
15111 len += 1;
15112 }
15113 if self.per_database_isolation.is_some() {
15114 len += 1;
15115 }
15116 if self.enforce_secret.is_some() {
15117 len += 1;
15118 }
15119 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
15120 if let Some(v) = self.barrier_interval_ms.as_ref() {
15121 struct_ser.serialize_field("barrierIntervalMs", v)?;
15122 }
15123 if let Some(v) = self.checkpoint_frequency.as_ref() {
15124 #[allow(clippy::needless_borrow)]
15125 #[allow(clippy::needless_borrows_for_generic_args)]
15126 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
15127 }
15128 if let Some(v) = self.sstable_size_mb.as_ref() {
15129 struct_ser.serialize_field("sstableSizeMb", v)?;
15130 }
15131 if let Some(v) = self.block_size_kb.as_ref() {
15132 struct_ser.serialize_field("blockSizeKb", v)?;
15133 }
15134 if let Some(v) = self.bloom_false_positive.as_ref() {
15135 struct_ser.serialize_field("bloomFalsePositive", v)?;
15136 }
15137 if let Some(v) = self.state_store.as_ref() {
15138 struct_ser.serialize_field("stateStore", v)?;
15139 }
15140 if let Some(v) = self.data_directory.as_ref() {
15141 struct_ser.serialize_field("dataDirectory", v)?;
15142 }
15143 if let Some(v) = self.backup_storage_url.as_ref() {
15144 struct_ser.serialize_field("backupStorageUrl", v)?;
15145 }
15146 if let Some(v) = self.backup_storage_directory.as_ref() {
15147 struct_ser.serialize_field("backupStorageDirectory", v)?;
15148 }
15149 if let Some(v) = self.telemetry_enabled.as_ref() {
15150 struct_ser.serialize_field("telemetryEnabled", v)?;
15151 }
15152 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
15153 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
15154 }
15155 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
15156 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
15157 }
15158 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
15159 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
15160 }
15161 if let Some(v) = self.wasm_storage_url.as_ref() {
15162 struct_ser.serialize_field("wasmStorageUrl", v)?;
15163 }
15164 if let Some(v) = self.enable_tracing.as_ref() {
15165 struct_ser.serialize_field("enableTracing", v)?;
15166 }
15167 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
15168 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
15169 }
15170 if let Some(v) = self.license_key.as_ref() {
15171 struct_ser.serialize_field("licenseKey", v)?;
15172 }
15173 if let Some(v) = self.time_travel_retention_ms.as_ref() {
15174 #[allow(clippy::needless_borrow)]
15175 #[allow(clippy::needless_borrows_for_generic_args)]
15176 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
15177 }
15178 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
15179 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
15180 }
15181 if let Some(v) = self.per_database_isolation.as_ref() {
15182 struct_ser.serialize_field("perDatabaseIsolation", v)?;
15183 }
15184 if let Some(v) = self.enforce_secret.as_ref() {
15185 struct_ser.serialize_field("enforceSecret", v)?;
15186 }
15187 struct_ser.end()
15188 }
15189}
15190impl<'de> serde::Deserialize<'de> for SystemParams {
15191 #[allow(deprecated)]
15192 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15193 where
15194 D: serde::Deserializer<'de>,
15195 {
15196 const FIELDS: &[&str] = &[
15197 "barrier_interval_ms",
15198 "barrierIntervalMs",
15199 "checkpoint_frequency",
15200 "checkpointFrequency",
15201 "sstable_size_mb",
15202 "sstableSizeMb",
15203 "block_size_kb",
15204 "blockSizeKb",
15205 "bloom_false_positive",
15206 "bloomFalsePositive",
15207 "state_store",
15208 "stateStore",
15209 "data_directory",
15210 "dataDirectory",
15211 "backup_storage_url",
15212 "backupStorageUrl",
15213 "backup_storage_directory",
15214 "backupStorageDirectory",
15215 "telemetry_enabled",
15216 "telemetryEnabled",
15217 "parallel_compact_size_mb",
15218 "parallelCompactSizeMb",
15219 "max_concurrent_creating_streaming_jobs",
15220 "maxConcurrentCreatingStreamingJobs",
15221 "pause_on_next_bootstrap",
15222 "pauseOnNextBootstrap",
15223 "wasm_storage_url",
15224 "wasmStorageUrl",
15225 "enable_tracing",
15226 "enableTracing",
15227 "use_new_object_prefix_strategy",
15228 "useNewObjectPrefixStrategy",
15229 "license_key",
15230 "licenseKey",
15231 "time_travel_retention_ms",
15232 "timeTravelRetentionMs",
15233 "adaptive_parallelism_strategy",
15234 "adaptiveParallelismStrategy",
15235 "per_database_isolation",
15236 "perDatabaseIsolation",
15237 "enforce_secret",
15238 "enforceSecret",
15239 ];
15240
15241 #[allow(clippy::enum_variant_names)]
15242 enum GeneratedField {
15243 BarrierIntervalMs,
15244 CheckpointFrequency,
15245 SstableSizeMb,
15246 BlockSizeKb,
15247 BloomFalsePositive,
15248 StateStore,
15249 DataDirectory,
15250 BackupStorageUrl,
15251 BackupStorageDirectory,
15252 TelemetryEnabled,
15253 ParallelCompactSizeMb,
15254 MaxConcurrentCreatingStreamingJobs,
15255 PauseOnNextBootstrap,
15256 WasmStorageUrl,
15257 EnableTracing,
15258 UseNewObjectPrefixStrategy,
15259 LicenseKey,
15260 TimeTravelRetentionMs,
15261 AdaptiveParallelismStrategy,
15262 PerDatabaseIsolation,
15263 EnforceSecret,
15264 }
15265 impl<'de> serde::Deserialize<'de> for GeneratedField {
15266 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15267 where
15268 D: serde::Deserializer<'de>,
15269 {
15270 struct GeneratedVisitor;
15271
15272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15273 type Value = GeneratedField;
15274
15275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15276 write!(formatter, "expected one of: {:?}", &FIELDS)
15277 }
15278
15279 #[allow(unused_variables)]
15280 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15281 where
15282 E: serde::de::Error,
15283 {
15284 match value {
15285 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
15286 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
15287 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
15288 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
15289 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
15290 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
15291 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
15292 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
15293 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
15294 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
15295 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
15296 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
15297 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
15298 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
15299 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
15300 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
15301 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
15302 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
15303 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
15304 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
15305 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
15306 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15307 }
15308 }
15309 }
15310 deserializer.deserialize_identifier(GeneratedVisitor)
15311 }
15312 }
15313 struct GeneratedVisitor;
15314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15315 type Value = SystemParams;
15316
15317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15318 formatter.write_str("struct meta.SystemParams")
15319 }
15320
15321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
15322 where
15323 V: serde::de::MapAccess<'de>,
15324 {
15325 let mut barrier_interval_ms__ = None;
15326 let mut checkpoint_frequency__ = None;
15327 let mut sstable_size_mb__ = None;
15328 let mut block_size_kb__ = None;
15329 let mut bloom_false_positive__ = None;
15330 let mut state_store__ = None;
15331 let mut data_directory__ = None;
15332 let mut backup_storage_url__ = None;
15333 let mut backup_storage_directory__ = None;
15334 let mut telemetry_enabled__ = None;
15335 let mut parallel_compact_size_mb__ = None;
15336 let mut max_concurrent_creating_streaming_jobs__ = None;
15337 let mut pause_on_next_bootstrap__ = None;
15338 let mut wasm_storage_url__ = None;
15339 let mut enable_tracing__ = None;
15340 let mut use_new_object_prefix_strategy__ = None;
15341 let mut license_key__ = None;
15342 let mut time_travel_retention_ms__ = None;
15343 let mut adaptive_parallelism_strategy__ = None;
15344 let mut per_database_isolation__ = None;
15345 let mut enforce_secret__ = None;
15346 while let Some(k) = map_.next_key()? {
15347 match k {
15348 GeneratedField::BarrierIntervalMs => {
15349 if barrier_interval_ms__.is_some() {
15350 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
15351 }
15352 barrier_interval_ms__ =
15353 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15354 ;
15355 }
15356 GeneratedField::CheckpointFrequency => {
15357 if checkpoint_frequency__.is_some() {
15358 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
15359 }
15360 checkpoint_frequency__ =
15361 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15362 ;
15363 }
15364 GeneratedField::SstableSizeMb => {
15365 if sstable_size_mb__.is_some() {
15366 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
15367 }
15368 sstable_size_mb__ =
15369 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15370 ;
15371 }
15372 GeneratedField::BlockSizeKb => {
15373 if block_size_kb__.is_some() {
15374 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
15375 }
15376 block_size_kb__ =
15377 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15378 ;
15379 }
15380 GeneratedField::BloomFalsePositive => {
15381 if bloom_false_positive__.is_some() {
15382 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
15383 }
15384 bloom_false_positive__ =
15385 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15386 ;
15387 }
15388 GeneratedField::StateStore => {
15389 if state_store__.is_some() {
15390 return Err(serde::de::Error::duplicate_field("stateStore"));
15391 }
15392 state_store__ = map_.next_value()?;
15393 }
15394 GeneratedField::DataDirectory => {
15395 if data_directory__.is_some() {
15396 return Err(serde::de::Error::duplicate_field("dataDirectory"));
15397 }
15398 data_directory__ = map_.next_value()?;
15399 }
15400 GeneratedField::BackupStorageUrl => {
15401 if backup_storage_url__.is_some() {
15402 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
15403 }
15404 backup_storage_url__ = map_.next_value()?;
15405 }
15406 GeneratedField::BackupStorageDirectory => {
15407 if backup_storage_directory__.is_some() {
15408 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
15409 }
15410 backup_storage_directory__ = map_.next_value()?;
15411 }
15412 GeneratedField::TelemetryEnabled => {
15413 if telemetry_enabled__.is_some() {
15414 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
15415 }
15416 telemetry_enabled__ = map_.next_value()?;
15417 }
15418 GeneratedField::ParallelCompactSizeMb => {
15419 if parallel_compact_size_mb__.is_some() {
15420 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
15421 }
15422 parallel_compact_size_mb__ =
15423 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15424 ;
15425 }
15426 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
15427 if max_concurrent_creating_streaming_jobs__.is_some() {
15428 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
15429 }
15430 max_concurrent_creating_streaming_jobs__ =
15431 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15432 ;
15433 }
15434 GeneratedField::PauseOnNextBootstrap => {
15435 if pause_on_next_bootstrap__.is_some() {
15436 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
15437 }
15438 pause_on_next_bootstrap__ = map_.next_value()?;
15439 }
15440 GeneratedField::WasmStorageUrl => {
15441 if wasm_storage_url__.is_some() {
15442 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
15443 }
15444 wasm_storage_url__ = map_.next_value()?;
15445 }
15446 GeneratedField::EnableTracing => {
15447 if enable_tracing__.is_some() {
15448 return Err(serde::de::Error::duplicate_field("enableTracing"));
15449 }
15450 enable_tracing__ = map_.next_value()?;
15451 }
15452 GeneratedField::UseNewObjectPrefixStrategy => {
15453 if use_new_object_prefix_strategy__.is_some() {
15454 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
15455 }
15456 use_new_object_prefix_strategy__ = map_.next_value()?;
15457 }
15458 GeneratedField::LicenseKey => {
15459 if license_key__.is_some() {
15460 return Err(serde::de::Error::duplicate_field("licenseKey"));
15461 }
15462 license_key__ = map_.next_value()?;
15463 }
15464 GeneratedField::TimeTravelRetentionMs => {
15465 if time_travel_retention_ms__.is_some() {
15466 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
15467 }
15468 time_travel_retention_ms__ =
15469 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15470 ;
15471 }
15472 GeneratedField::AdaptiveParallelismStrategy => {
15473 if adaptive_parallelism_strategy__.is_some() {
15474 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
15475 }
15476 adaptive_parallelism_strategy__ = map_.next_value()?;
15477 }
15478 GeneratedField::PerDatabaseIsolation => {
15479 if per_database_isolation__.is_some() {
15480 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
15481 }
15482 per_database_isolation__ = map_.next_value()?;
15483 }
15484 GeneratedField::EnforceSecret => {
15485 if enforce_secret__.is_some() {
15486 return Err(serde::de::Error::duplicate_field("enforceSecret"));
15487 }
15488 enforce_secret__ = map_.next_value()?;
15489 }
15490 }
15491 }
15492 Ok(SystemParams {
15493 barrier_interval_ms: barrier_interval_ms__,
15494 checkpoint_frequency: checkpoint_frequency__,
15495 sstable_size_mb: sstable_size_mb__,
15496 block_size_kb: block_size_kb__,
15497 bloom_false_positive: bloom_false_positive__,
15498 state_store: state_store__,
15499 data_directory: data_directory__,
15500 backup_storage_url: backup_storage_url__,
15501 backup_storage_directory: backup_storage_directory__,
15502 telemetry_enabled: telemetry_enabled__,
15503 parallel_compact_size_mb: parallel_compact_size_mb__,
15504 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
15505 pause_on_next_bootstrap: pause_on_next_bootstrap__,
15506 wasm_storage_url: wasm_storage_url__,
15507 enable_tracing: enable_tracing__,
15508 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
15509 license_key: license_key__,
15510 time_travel_retention_ms: time_travel_retention_ms__,
15511 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
15512 per_database_isolation: per_database_isolation__,
15513 enforce_secret: enforce_secret__,
15514 })
15515 }
15516 }
15517 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
15518 }
15519}
15520impl serde::Serialize for TableFragments {
15521 #[allow(deprecated)]
15522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15523 where
15524 S: serde::Serializer,
15525 {
15526 use serde::ser::SerializeStruct;
15527 let mut len = 0;
15528 if self.table_id != 0 {
15529 len += 1;
15530 }
15531 if self.state != 0 {
15532 len += 1;
15533 }
15534 if !self.fragments.is_empty() {
15535 len += 1;
15536 }
15537 if !self.actor_status.is_empty() {
15538 len += 1;
15539 }
15540 if self.ctx.is_some() {
15541 len += 1;
15542 }
15543 if self.parallelism.is_some() {
15544 len += 1;
15545 }
15546 if self.max_parallelism.is_some() {
15547 len += 1;
15548 }
15549 if !self.node_label.is_empty() {
15550 len += 1;
15551 }
15552 if self.backfill_done {
15553 len += 1;
15554 }
15555 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
15556 if self.table_id != 0 {
15557 struct_ser.serialize_field("tableId", &self.table_id)?;
15558 }
15559 if self.state != 0 {
15560 let v = table_fragments::State::try_from(self.state)
15561 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15562 struct_ser.serialize_field("state", &v)?;
15563 }
15564 if !self.fragments.is_empty() {
15565 struct_ser.serialize_field("fragments", &self.fragments)?;
15566 }
15567 if !self.actor_status.is_empty() {
15568 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
15569 }
15570 if let Some(v) = self.ctx.as_ref() {
15571 struct_ser.serialize_field("ctx", v)?;
15572 }
15573 if let Some(v) = self.parallelism.as_ref() {
15574 struct_ser.serialize_field("parallelism", v)?;
15575 }
15576 if let Some(v) = self.max_parallelism.as_ref() {
15577 struct_ser.serialize_field("maxParallelism", v)?;
15578 }
15579 if !self.node_label.is_empty() {
15580 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
15581 }
15582 if self.backfill_done {
15583 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
15584 }
15585 struct_ser.end()
15586 }
15587}
15588impl<'de> serde::Deserialize<'de> for TableFragments {
15589 #[allow(deprecated)]
15590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15591 where
15592 D: serde::Deserializer<'de>,
15593 {
15594 const FIELDS: &[&str] = &[
15595 "table_id",
15596 "tableId",
15597 "state",
15598 "fragments",
15599 "actor_status",
15600 "actorStatus",
15601 "ctx",
15602 "parallelism",
15603 "max_parallelism",
15604 "maxParallelism",
15605 "node_label",
15606 "nodeLabel",
15607 "backfill_done",
15608 "backfillDone",
15609 ];
15610
15611 #[allow(clippy::enum_variant_names)]
15612 enum GeneratedField {
15613 TableId,
15614 State,
15615 Fragments,
15616 ActorStatus,
15617 Ctx,
15618 Parallelism,
15619 MaxParallelism,
15620 NodeLabel,
15621 BackfillDone,
15622 }
15623 impl<'de> serde::Deserialize<'de> for GeneratedField {
15624 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15625 where
15626 D: serde::Deserializer<'de>,
15627 {
15628 struct GeneratedVisitor;
15629
15630 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15631 type Value = GeneratedField;
15632
15633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15634 write!(formatter, "expected one of: {:?}", &FIELDS)
15635 }
15636
15637 #[allow(unused_variables)]
15638 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15639 where
15640 E: serde::de::Error,
15641 {
15642 match value {
15643 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15644 "state" => Ok(GeneratedField::State),
15645 "fragments" => Ok(GeneratedField::Fragments),
15646 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
15647 "ctx" => Ok(GeneratedField::Ctx),
15648 "parallelism" => Ok(GeneratedField::Parallelism),
15649 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
15650 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
15651 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
15652 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15653 }
15654 }
15655 }
15656 deserializer.deserialize_identifier(GeneratedVisitor)
15657 }
15658 }
15659 struct GeneratedVisitor;
15660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15661 type Value = TableFragments;
15662
15663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15664 formatter.write_str("struct meta.TableFragments")
15665 }
15666
15667 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
15668 where
15669 V: serde::de::MapAccess<'de>,
15670 {
15671 let mut table_id__ = None;
15672 let mut state__ = None;
15673 let mut fragments__ = None;
15674 let mut actor_status__ = None;
15675 let mut ctx__ = None;
15676 let mut parallelism__ = None;
15677 let mut max_parallelism__ = None;
15678 let mut node_label__ = None;
15679 let mut backfill_done__ = None;
15680 while let Some(k) = map_.next_key()? {
15681 match k {
15682 GeneratedField::TableId => {
15683 if table_id__.is_some() {
15684 return Err(serde::de::Error::duplicate_field("tableId"));
15685 }
15686 table_id__ =
15687 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15688 ;
15689 }
15690 GeneratedField::State => {
15691 if state__.is_some() {
15692 return Err(serde::de::Error::duplicate_field("state"));
15693 }
15694 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
15695 }
15696 GeneratedField::Fragments => {
15697 if fragments__.is_some() {
15698 return Err(serde::de::Error::duplicate_field("fragments"));
15699 }
15700 fragments__ = Some(
15701 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15702 .into_iter().map(|(k,v)| (k.0, v)).collect()
15703 );
15704 }
15705 GeneratedField::ActorStatus => {
15706 if actor_status__.is_some() {
15707 return Err(serde::de::Error::duplicate_field("actorStatus"));
15708 }
15709 actor_status__ = Some(
15710 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15711 .into_iter().map(|(k,v)| (k.0, v)).collect()
15712 );
15713 }
15714 GeneratedField::Ctx => {
15715 if ctx__.is_some() {
15716 return Err(serde::de::Error::duplicate_field("ctx"));
15717 }
15718 ctx__ = map_.next_value()?;
15719 }
15720 GeneratedField::Parallelism => {
15721 if parallelism__.is_some() {
15722 return Err(serde::de::Error::duplicate_field("parallelism"));
15723 }
15724 parallelism__ = map_.next_value()?;
15725 }
15726 GeneratedField::MaxParallelism => {
15727 if max_parallelism__.is_some() {
15728 return Err(serde::de::Error::duplicate_field("maxParallelism"));
15729 }
15730 max_parallelism__ =
15731 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15732 ;
15733 }
15734 GeneratedField::NodeLabel => {
15735 if node_label__.is_some() {
15736 return Err(serde::de::Error::duplicate_field("nodeLabel"));
15737 }
15738 node_label__ = Some(map_.next_value()?);
15739 }
15740 GeneratedField::BackfillDone => {
15741 if backfill_done__.is_some() {
15742 return Err(serde::de::Error::duplicate_field("backfillDone"));
15743 }
15744 backfill_done__ = Some(map_.next_value()?);
15745 }
15746 }
15747 }
15748 Ok(TableFragments {
15749 table_id: table_id__.unwrap_or_default(),
15750 state: state__.unwrap_or_default(),
15751 fragments: fragments__.unwrap_or_default(),
15752 actor_status: actor_status__.unwrap_or_default(),
15753 ctx: ctx__,
15754 parallelism: parallelism__,
15755 max_parallelism: max_parallelism__,
15756 node_label: node_label__.unwrap_or_default(),
15757 backfill_done: backfill_done__.unwrap_or_default(),
15758 })
15759 }
15760 }
15761 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
15762 }
15763}
15764impl serde::Serialize for table_fragments::ActorStatus {
15765 #[allow(deprecated)]
15766 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15767 where
15768 S: serde::Serializer,
15769 {
15770 use serde::ser::SerializeStruct;
15771 let mut len = 0;
15772 if self.location.is_some() {
15773 len += 1;
15774 }
15775 if self.state != 0 {
15776 len += 1;
15777 }
15778 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
15779 if let Some(v) = self.location.as_ref() {
15780 struct_ser.serialize_field("location", v)?;
15781 }
15782 if self.state != 0 {
15783 let v = table_fragments::actor_status::ActorState::try_from(self.state)
15784 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15785 struct_ser.serialize_field("state", &v)?;
15786 }
15787 struct_ser.end()
15788 }
15789}
15790impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
15791 #[allow(deprecated)]
15792 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15793 where
15794 D: serde::Deserializer<'de>,
15795 {
15796 const FIELDS: &[&str] = &[
15797 "location",
15798 "state",
15799 ];
15800
15801 #[allow(clippy::enum_variant_names)]
15802 enum GeneratedField {
15803 Location,
15804 State,
15805 }
15806 impl<'de> serde::Deserialize<'de> for GeneratedField {
15807 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15808 where
15809 D: serde::Deserializer<'de>,
15810 {
15811 struct GeneratedVisitor;
15812
15813 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15814 type Value = GeneratedField;
15815
15816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15817 write!(formatter, "expected one of: {:?}", &FIELDS)
15818 }
15819
15820 #[allow(unused_variables)]
15821 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15822 where
15823 E: serde::de::Error,
15824 {
15825 match value {
15826 "location" => Ok(GeneratedField::Location),
15827 "state" => Ok(GeneratedField::State),
15828 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15829 }
15830 }
15831 }
15832 deserializer.deserialize_identifier(GeneratedVisitor)
15833 }
15834 }
15835 struct GeneratedVisitor;
15836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15837 type Value = table_fragments::ActorStatus;
15838
15839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15840 formatter.write_str("struct meta.TableFragments.ActorStatus")
15841 }
15842
15843 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
15844 where
15845 V: serde::de::MapAccess<'de>,
15846 {
15847 let mut location__ = None;
15848 let mut state__ = None;
15849 while let Some(k) = map_.next_key()? {
15850 match k {
15851 GeneratedField::Location => {
15852 if location__.is_some() {
15853 return Err(serde::de::Error::duplicate_field("location"));
15854 }
15855 location__ = map_.next_value()?;
15856 }
15857 GeneratedField::State => {
15858 if state__.is_some() {
15859 return Err(serde::de::Error::duplicate_field("state"));
15860 }
15861 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
15862 }
15863 }
15864 }
15865 Ok(table_fragments::ActorStatus {
15866 location: location__,
15867 state: state__.unwrap_or_default(),
15868 })
15869 }
15870 }
15871 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
15872 }
15873}
15874impl serde::Serialize for table_fragments::actor_status::ActorState {
15875 #[allow(deprecated)]
15876 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15877 where
15878 S: serde::Serializer,
15879 {
15880 let variant = match self {
15881 Self::Unspecified => "UNSPECIFIED",
15882 Self::Inactive => "INACTIVE",
15883 Self::Running => "RUNNING",
15884 };
15885 serializer.serialize_str(variant)
15886 }
15887}
15888impl<'de> serde::Deserialize<'de> for table_fragments::actor_status::ActorState {
15889 #[allow(deprecated)]
15890 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15891 where
15892 D: serde::Deserializer<'de>,
15893 {
15894 const FIELDS: &[&str] = &[
15895 "UNSPECIFIED",
15896 "INACTIVE",
15897 "RUNNING",
15898 ];
15899
15900 struct GeneratedVisitor;
15901
15902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15903 type Value = table_fragments::actor_status::ActorState;
15904
15905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15906 write!(formatter, "expected one of: {:?}", &FIELDS)
15907 }
15908
15909 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15910 where
15911 E: serde::de::Error,
15912 {
15913 i32::try_from(v)
15914 .ok()
15915 .and_then(|x| x.try_into().ok())
15916 .ok_or_else(|| {
15917 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15918 })
15919 }
15920
15921 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15922 where
15923 E: serde::de::Error,
15924 {
15925 i32::try_from(v)
15926 .ok()
15927 .and_then(|x| x.try_into().ok())
15928 .ok_or_else(|| {
15929 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15930 })
15931 }
15932
15933 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15934 where
15935 E: serde::de::Error,
15936 {
15937 match value {
15938 "UNSPECIFIED" => Ok(table_fragments::actor_status::ActorState::Unspecified),
15939 "INACTIVE" => Ok(table_fragments::actor_status::ActorState::Inactive),
15940 "RUNNING" => Ok(table_fragments::actor_status::ActorState::Running),
15941 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15942 }
15943 }
15944 }
15945 deserializer.deserialize_any(GeneratedVisitor)
15946 }
15947}
15948impl serde::Serialize for table_fragments::Fragment {
15949 #[allow(deprecated)]
15950 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15951 where
15952 S: serde::Serializer,
15953 {
15954 use serde::ser::SerializeStruct;
15955 let mut len = 0;
15956 if self.fragment_id != 0 {
15957 len += 1;
15958 }
15959 if self.fragment_type_mask != 0 {
15960 len += 1;
15961 }
15962 if self.distribution_type != 0 {
15963 len += 1;
15964 }
15965 if !self.actors.is_empty() {
15966 len += 1;
15967 }
15968 if !self.state_table_ids.is_empty() {
15969 len += 1;
15970 }
15971 if !self.upstream_fragment_ids.is_empty() {
15972 len += 1;
15973 }
15974 if self.maybe_vnode_count.is_some() {
15975 len += 1;
15976 }
15977 if self.nodes.is_some() {
15978 len += 1;
15979 }
15980 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
15981 if self.fragment_id != 0 {
15982 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
15983 }
15984 if self.fragment_type_mask != 0 {
15985 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
15986 }
15987 if self.distribution_type != 0 {
15988 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
15989 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
15990 struct_ser.serialize_field("distributionType", &v)?;
15991 }
15992 if !self.actors.is_empty() {
15993 struct_ser.serialize_field("actors", &self.actors)?;
15994 }
15995 if !self.state_table_ids.is_empty() {
15996 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
15997 }
15998 if !self.upstream_fragment_ids.is_empty() {
15999 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
16000 }
16001 if let Some(v) = self.maybe_vnode_count.as_ref() {
16002 struct_ser.serialize_field("maybeVnodeCount", v)?;
16003 }
16004 if let Some(v) = self.nodes.as_ref() {
16005 struct_ser.serialize_field("nodes", v)?;
16006 }
16007 struct_ser.end()
16008 }
16009}
16010impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
16011 #[allow(deprecated)]
16012 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16013 where
16014 D: serde::Deserializer<'de>,
16015 {
16016 const FIELDS: &[&str] = &[
16017 "fragment_id",
16018 "fragmentId",
16019 "fragment_type_mask",
16020 "fragmentTypeMask",
16021 "distribution_type",
16022 "distributionType",
16023 "actors",
16024 "state_table_ids",
16025 "stateTableIds",
16026 "upstream_fragment_ids",
16027 "upstreamFragmentIds",
16028 "maybe_vnode_count",
16029 "maybeVnodeCount",
16030 "nodes",
16031 ];
16032
16033 #[allow(clippy::enum_variant_names)]
16034 enum GeneratedField {
16035 FragmentId,
16036 FragmentTypeMask,
16037 DistributionType,
16038 Actors,
16039 StateTableIds,
16040 UpstreamFragmentIds,
16041 MaybeVnodeCount,
16042 Nodes,
16043 }
16044 impl<'de> serde::Deserialize<'de> for GeneratedField {
16045 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16046 where
16047 D: serde::Deserializer<'de>,
16048 {
16049 struct GeneratedVisitor;
16050
16051 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16052 type Value = GeneratedField;
16053
16054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16055 write!(formatter, "expected one of: {:?}", &FIELDS)
16056 }
16057
16058 #[allow(unused_variables)]
16059 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16060 where
16061 E: serde::de::Error,
16062 {
16063 match value {
16064 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
16065 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
16066 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
16067 "actors" => Ok(GeneratedField::Actors),
16068 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
16069 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
16070 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
16071 "nodes" => Ok(GeneratedField::Nodes),
16072 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16073 }
16074 }
16075 }
16076 deserializer.deserialize_identifier(GeneratedVisitor)
16077 }
16078 }
16079 struct GeneratedVisitor;
16080 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16081 type Value = table_fragments::Fragment;
16082
16083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16084 formatter.write_str("struct meta.TableFragments.Fragment")
16085 }
16086
16087 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
16088 where
16089 V: serde::de::MapAccess<'de>,
16090 {
16091 let mut fragment_id__ = None;
16092 let mut fragment_type_mask__ = None;
16093 let mut distribution_type__ = None;
16094 let mut actors__ = None;
16095 let mut state_table_ids__ = None;
16096 let mut upstream_fragment_ids__ = None;
16097 let mut maybe_vnode_count__ = None;
16098 let mut nodes__ = None;
16099 while let Some(k) = map_.next_key()? {
16100 match k {
16101 GeneratedField::FragmentId => {
16102 if fragment_id__.is_some() {
16103 return Err(serde::de::Error::duplicate_field("fragmentId"));
16104 }
16105 fragment_id__ =
16106 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16107 ;
16108 }
16109 GeneratedField::FragmentTypeMask => {
16110 if fragment_type_mask__.is_some() {
16111 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
16112 }
16113 fragment_type_mask__ =
16114 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16115 ;
16116 }
16117 GeneratedField::DistributionType => {
16118 if distribution_type__.is_some() {
16119 return Err(serde::de::Error::duplicate_field("distributionType"));
16120 }
16121 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
16122 }
16123 GeneratedField::Actors => {
16124 if actors__.is_some() {
16125 return Err(serde::de::Error::duplicate_field("actors"));
16126 }
16127 actors__ = Some(map_.next_value()?);
16128 }
16129 GeneratedField::StateTableIds => {
16130 if state_table_ids__.is_some() {
16131 return Err(serde::de::Error::duplicate_field("stateTableIds"));
16132 }
16133 state_table_ids__ =
16134 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16135 .into_iter().map(|x| x.0).collect())
16136 ;
16137 }
16138 GeneratedField::UpstreamFragmentIds => {
16139 if upstream_fragment_ids__.is_some() {
16140 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
16141 }
16142 upstream_fragment_ids__ =
16143 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16144 .into_iter().map(|x| x.0).collect())
16145 ;
16146 }
16147 GeneratedField::MaybeVnodeCount => {
16148 if maybe_vnode_count__.is_some() {
16149 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
16150 }
16151 maybe_vnode_count__ =
16152 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16153 ;
16154 }
16155 GeneratedField::Nodes => {
16156 if nodes__.is_some() {
16157 return Err(serde::de::Error::duplicate_field("nodes"));
16158 }
16159 nodes__ = map_.next_value()?;
16160 }
16161 }
16162 }
16163 Ok(table_fragments::Fragment {
16164 fragment_id: fragment_id__.unwrap_or_default(),
16165 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
16166 distribution_type: distribution_type__.unwrap_or_default(),
16167 actors: actors__.unwrap_or_default(),
16168 state_table_ids: state_table_ids__.unwrap_or_default(),
16169 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
16170 maybe_vnode_count: maybe_vnode_count__,
16171 nodes: nodes__,
16172 })
16173 }
16174 }
16175 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
16176 }
16177}
16178impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
16179 #[allow(deprecated)]
16180 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16181 where
16182 S: serde::Serializer,
16183 {
16184 let variant = match self {
16185 Self::Unspecified => "UNSPECIFIED",
16186 Self::Single => "SINGLE",
16187 Self::Hash => "HASH",
16188 };
16189 serializer.serialize_str(variant)
16190 }
16191}
16192impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
16193 #[allow(deprecated)]
16194 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16195 where
16196 D: serde::Deserializer<'de>,
16197 {
16198 const FIELDS: &[&str] = &[
16199 "UNSPECIFIED",
16200 "SINGLE",
16201 "HASH",
16202 ];
16203
16204 struct GeneratedVisitor;
16205
16206 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16207 type Value = table_fragments::fragment::FragmentDistributionType;
16208
16209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16210 write!(formatter, "expected one of: {:?}", &FIELDS)
16211 }
16212
16213 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16214 where
16215 E: serde::de::Error,
16216 {
16217 i32::try_from(v)
16218 .ok()
16219 .and_then(|x| x.try_into().ok())
16220 .ok_or_else(|| {
16221 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16222 })
16223 }
16224
16225 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16226 where
16227 E: serde::de::Error,
16228 {
16229 i32::try_from(v)
16230 .ok()
16231 .and_then(|x| x.try_into().ok())
16232 .ok_or_else(|| {
16233 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16234 })
16235 }
16236
16237 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16238 where
16239 E: serde::de::Error,
16240 {
16241 match value {
16242 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
16243 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
16244 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
16245 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16246 }
16247 }
16248 }
16249 deserializer.deserialize_any(GeneratedVisitor)
16250 }
16251}
16252impl serde::Serialize for table_fragments::State {
16253 #[allow(deprecated)]
16254 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16255 where
16256 S: serde::Serializer,
16257 {
16258 let variant = match self {
16259 Self::Unspecified => "UNSPECIFIED",
16260 Self::Initial => "INITIAL",
16261 Self::Creating => "CREATING",
16262 Self::Created => "CREATED",
16263 };
16264 serializer.serialize_str(variant)
16265 }
16266}
16267impl<'de> serde::Deserialize<'de> for table_fragments::State {
16268 #[allow(deprecated)]
16269 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16270 where
16271 D: serde::Deserializer<'de>,
16272 {
16273 const FIELDS: &[&str] = &[
16274 "UNSPECIFIED",
16275 "INITIAL",
16276 "CREATING",
16277 "CREATED",
16278 ];
16279
16280 struct GeneratedVisitor;
16281
16282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16283 type Value = table_fragments::State;
16284
16285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16286 write!(formatter, "expected one of: {:?}", &FIELDS)
16287 }
16288
16289 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16290 where
16291 E: serde::de::Error,
16292 {
16293 i32::try_from(v)
16294 .ok()
16295 .and_then(|x| x.try_into().ok())
16296 .ok_or_else(|| {
16297 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16298 })
16299 }
16300
16301 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16302 where
16303 E: serde::de::Error,
16304 {
16305 i32::try_from(v)
16306 .ok()
16307 .and_then(|x| x.try_into().ok())
16308 .ok_or_else(|| {
16309 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16310 })
16311 }
16312
16313 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16314 where
16315 E: serde::de::Error,
16316 {
16317 match value {
16318 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
16319 "INITIAL" => Ok(table_fragments::State::Initial),
16320 "CREATING" => Ok(table_fragments::State::Creating),
16321 "CREATED" => Ok(table_fragments::State::Created),
16322 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16323 }
16324 }
16325 }
16326 deserializer.deserialize_any(GeneratedVisitor)
16327 }
16328}
16329impl serde::Serialize for TableParallelism {
16330 #[allow(deprecated)]
16331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16332 where
16333 S: serde::Serializer,
16334 {
16335 use serde::ser::SerializeStruct;
16336 let mut len = 0;
16337 if self.parallelism.is_some() {
16338 len += 1;
16339 }
16340 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
16341 if let Some(v) = self.parallelism.as_ref() {
16342 match v {
16343 table_parallelism::Parallelism::Fixed(v) => {
16344 struct_ser.serialize_field("fixed", v)?;
16345 }
16346 table_parallelism::Parallelism::Auto(v) => {
16347 struct_ser.serialize_field("auto", v)?;
16348 }
16349 table_parallelism::Parallelism::Custom(v) => {
16350 struct_ser.serialize_field("custom", v)?;
16351 }
16352 table_parallelism::Parallelism::Adaptive(v) => {
16353 struct_ser.serialize_field("adaptive", v)?;
16354 }
16355 }
16356 }
16357 struct_ser.end()
16358 }
16359}
16360impl<'de> serde::Deserialize<'de> for TableParallelism {
16361 #[allow(deprecated)]
16362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16363 where
16364 D: serde::Deserializer<'de>,
16365 {
16366 const FIELDS: &[&str] = &[
16367 "fixed",
16368 "auto",
16369 "custom",
16370 "adaptive",
16371 ];
16372
16373 #[allow(clippy::enum_variant_names)]
16374 enum GeneratedField {
16375 Fixed,
16376 Auto,
16377 Custom,
16378 Adaptive,
16379 }
16380 impl<'de> serde::Deserialize<'de> for GeneratedField {
16381 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16382 where
16383 D: serde::Deserializer<'de>,
16384 {
16385 struct GeneratedVisitor;
16386
16387 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16388 type Value = GeneratedField;
16389
16390 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16391 write!(formatter, "expected one of: {:?}", &FIELDS)
16392 }
16393
16394 #[allow(unused_variables)]
16395 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16396 where
16397 E: serde::de::Error,
16398 {
16399 match value {
16400 "fixed" => Ok(GeneratedField::Fixed),
16401 "auto" => Ok(GeneratedField::Auto),
16402 "custom" => Ok(GeneratedField::Custom),
16403 "adaptive" => Ok(GeneratedField::Adaptive),
16404 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16405 }
16406 }
16407 }
16408 deserializer.deserialize_identifier(GeneratedVisitor)
16409 }
16410 }
16411 struct GeneratedVisitor;
16412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16413 type Value = TableParallelism;
16414
16415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16416 formatter.write_str("struct meta.TableParallelism")
16417 }
16418
16419 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
16420 where
16421 V: serde::de::MapAccess<'de>,
16422 {
16423 let mut parallelism__ = None;
16424 while let Some(k) = map_.next_key()? {
16425 match k {
16426 GeneratedField::Fixed => {
16427 if parallelism__.is_some() {
16428 return Err(serde::de::Error::duplicate_field("fixed"));
16429 }
16430 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
16431;
16432 }
16433 GeneratedField::Auto => {
16434 if parallelism__.is_some() {
16435 return Err(serde::de::Error::duplicate_field("auto"));
16436 }
16437 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
16438;
16439 }
16440 GeneratedField::Custom => {
16441 if parallelism__.is_some() {
16442 return Err(serde::de::Error::duplicate_field("custom"));
16443 }
16444 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
16445;
16446 }
16447 GeneratedField::Adaptive => {
16448 if parallelism__.is_some() {
16449 return Err(serde::de::Error::duplicate_field("adaptive"));
16450 }
16451 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
16452;
16453 }
16454 }
16455 }
16456 Ok(TableParallelism {
16457 parallelism: parallelism__,
16458 })
16459 }
16460 }
16461 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
16462 }
16463}
16464impl serde::Serialize for table_parallelism::AdaptiveParallelism {
16465 #[allow(deprecated)]
16466 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16467 where
16468 S: serde::Serializer,
16469 {
16470 use serde::ser::SerializeStruct;
16471 let len = 0;
16472 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
16473 struct_ser.end()
16474 }
16475}
16476impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
16477 #[allow(deprecated)]
16478 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16479 where
16480 D: serde::Deserializer<'de>,
16481 {
16482 const FIELDS: &[&str] = &[
16483 ];
16484
16485 #[allow(clippy::enum_variant_names)]
16486 enum GeneratedField {
16487 }
16488 impl<'de> serde::Deserialize<'de> for GeneratedField {
16489 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16490 where
16491 D: serde::Deserializer<'de>,
16492 {
16493 struct GeneratedVisitor;
16494
16495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16496 type Value = GeneratedField;
16497
16498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16499 write!(formatter, "expected one of: {:?}", &FIELDS)
16500 }
16501
16502 #[allow(unused_variables)]
16503 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16504 where
16505 E: serde::de::Error,
16506 {
16507 Err(serde::de::Error::unknown_field(value, FIELDS))
16508 }
16509 }
16510 deserializer.deserialize_identifier(GeneratedVisitor)
16511 }
16512 }
16513 struct GeneratedVisitor;
16514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16515 type Value = table_parallelism::AdaptiveParallelism;
16516
16517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16518 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
16519 }
16520
16521 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
16522 where
16523 V: serde::de::MapAccess<'de>,
16524 {
16525 while map_.next_key::<GeneratedField>()?.is_some() {
16526 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16527 }
16528 Ok(table_parallelism::AdaptiveParallelism {
16529 })
16530 }
16531 }
16532 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
16533 }
16534}
16535impl serde::Serialize for table_parallelism::AutoParallelism {
16536 #[allow(deprecated)]
16537 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16538 where
16539 S: serde::Serializer,
16540 {
16541 use serde::ser::SerializeStruct;
16542 let len = 0;
16543 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
16544 struct_ser.end()
16545 }
16546}
16547impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
16548 #[allow(deprecated)]
16549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16550 where
16551 D: serde::Deserializer<'de>,
16552 {
16553 const FIELDS: &[&str] = &[
16554 ];
16555
16556 #[allow(clippy::enum_variant_names)]
16557 enum GeneratedField {
16558 }
16559 impl<'de> serde::Deserialize<'de> for GeneratedField {
16560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16561 where
16562 D: serde::Deserializer<'de>,
16563 {
16564 struct GeneratedVisitor;
16565
16566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16567 type Value = GeneratedField;
16568
16569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16570 write!(formatter, "expected one of: {:?}", &FIELDS)
16571 }
16572
16573 #[allow(unused_variables)]
16574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16575 where
16576 E: serde::de::Error,
16577 {
16578 Err(serde::de::Error::unknown_field(value, FIELDS))
16579 }
16580 }
16581 deserializer.deserialize_identifier(GeneratedVisitor)
16582 }
16583 }
16584 struct GeneratedVisitor;
16585 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16586 type Value = table_parallelism::AutoParallelism;
16587
16588 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16589 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
16590 }
16591
16592 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
16593 where
16594 V: serde::de::MapAccess<'de>,
16595 {
16596 while map_.next_key::<GeneratedField>()?.is_some() {
16597 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16598 }
16599 Ok(table_parallelism::AutoParallelism {
16600 })
16601 }
16602 }
16603 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
16604 }
16605}
16606impl serde::Serialize for table_parallelism::CustomParallelism {
16607 #[allow(deprecated)]
16608 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16609 where
16610 S: serde::Serializer,
16611 {
16612 use serde::ser::SerializeStruct;
16613 let len = 0;
16614 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
16615 struct_ser.end()
16616 }
16617}
16618impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
16619 #[allow(deprecated)]
16620 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16621 where
16622 D: serde::Deserializer<'de>,
16623 {
16624 const FIELDS: &[&str] = &[
16625 ];
16626
16627 #[allow(clippy::enum_variant_names)]
16628 enum GeneratedField {
16629 }
16630 impl<'de> serde::Deserialize<'de> for GeneratedField {
16631 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16632 where
16633 D: serde::Deserializer<'de>,
16634 {
16635 struct GeneratedVisitor;
16636
16637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16638 type Value = GeneratedField;
16639
16640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16641 write!(formatter, "expected one of: {:?}", &FIELDS)
16642 }
16643
16644 #[allow(unused_variables)]
16645 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16646 where
16647 E: serde::de::Error,
16648 {
16649 Err(serde::de::Error::unknown_field(value, FIELDS))
16650 }
16651 }
16652 deserializer.deserialize_identifier(GeneratedVisitor)
16653 }
16654 }
16655 struct GeneratedVisitor;
16656 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16657 type Value = table_parallelism::CustomParallelism;
16658
16659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16660 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
16661 }
16662
16663 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
16664 where
16665 V: serde::de::MapAccess<'de>,
16666 {
16667 while map_.next_key::<GeneratedField>()?.is_some() {
16668 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16669 }
16670 Ok(table_parallelism::CustomParallelism {
16671 })
16672 }
16673 }
16674 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
16675 }
16676}
16677impl serde::Serialize for table_parallelism::FixedParallelism {
16678 #[allow(deprecated)]
16679 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16680 where
16681 S: serde::Serializer,
16682 {
16683 use serde::ser::SerializeStruct;
16684 let mut len = 0;
16685 if self.parallelism != 0 {
16686 len += 1;
16687 }
16688 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
16689 if self.parallelism != 0 {
16690 struct_ser.serialize_field("parallelism", &self.parallelism)?;
16691 }
16692 struct_ser.end()
16693 }
16694}
16695impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
16696 #[allow(deprecated)]
16697 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16698 where
16699 D: serde::Deserializer<'de>,
16700 {
16701 const FIELDS: &[&str] = &[
16702 "parallelism",
16703 ];
16704
16705 #[allow(clippy::enum_variant_names)]
16706 enum GeneratedField {
16707 Parallelism,
16708 }
16709 impl<'de> serde::Deserialize<'de> for GeneratedField {
16710 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16711 where
16712 D: serde::Deserializer<'de>,
16713 {
16714 struct GeneratedVisitor;
16715
16716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16717 type Value = GeneratedField;
16718
16719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16720 write!(formatter, "expected one of: {:?}", &FIELDS)
16721 }
16722
16723 #[allow(unused_variables)]
16724 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16725 where
16726 E: serde::de::Error,
16727 {
16728 match value {
16729 "parallelism" => Ok(GeneratedField::Parallelism),
16730 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16731 }
16732 }
16733 }
16734 deserializer.deserialize_identifier(GeneratedVisitor)
16735 }
16736 }
16737 struct GeneratedVisitor;
16738 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16739 type Value = table_parallelism::FixedParallelism;
16740
16741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16742 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
16743 }
16744
16745 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
16746 where
16747 V: serde::de::MapAccess<'de>,
16748 {
16749 let mut parallelism__ = None;
16750 while let Some(k) = map_.next_key()? {
16751 match k {
16752 GeneratedField::Parallelism => {
16753 if parallelism__.is_some() {
16754 return Err(serde::de::Error::duplicate_field("parallelism"));
16755 }
16756 parallelism__ =
16757 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16758 ;
16759 }
16760 }
16761 }
16762 Ok(table_parallelism::FixedParallelism {
16763 parallelism: parallelism__.unwrap_or_default(),
16764 })
16765 }
16766 }
16767 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
16768 }
16769}
16770impl serde::Serialize for TelemetryInfoResponse {
16771 #[allow(deprecated)]
16772 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16773 where
16774 S: serde::Serializer,
16775 {
16776 use serde::ser::SerializeStruct;
16777 let mut len = 0;
16778 if self.tracking_id.is_some() {
16779 len += 1;
16780 }
16781 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
16782 if let Some(v) = self.tracking_id.as_ref() {
16783 struct_ser.serialize_field("trackingId", v)?;
16784 }
16785 struct_ser.end()
16786 }
16787}
16788impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
16789 #[allow(deprecated)]
16790 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16791 where
16792 D: serde::Deserializer<'de>,
16793 {
16794 const FIELDS: &[&str] = &[
16795 "tracking_id",
16796 "trackingId",
16797 ];
16798
16799 #[allow(clippy::enum_variant_names)]
16800 enum GeneratedField {
16801 TrackingId,
16802 }
16803 impl<'de> serde::Deserialize<'de> for GeneratedField {
16804 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16805 where
16806 D: serde::Deserializer<'de>,
16807 {
16808 struct GeneratedVisitor;
16809
16810 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16811 type Value = GeneratedField;
16812
16813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16814 write!(formatter, "expected one of: {:?}", &FIELDS)
16815 }
16816
16817 #[allow(unused_variables)]
16818 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16819 where
16820 E: serde::de::Error,
16821 {
16822 match value {
16823 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
16824 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16825 }
16826 }
16827 }
16828 deserializer.deserialize_identifier(GeneratedVisitor)
16829 }
16830 }
16831 struct GeneratedVisitor;
16832 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16833 type Value = TelemetryInfoResponse;
16834
16835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16836 formatter.write_str("struct meta.TelemetryInfoResponse")
16837 }
16838
16839 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
16840 where
16841 V: serde::de::MapAccess<'de>,
16842 {
16843 let mut tracking_id__ = None;
16844 while let Some(k) = map_.next_key()? {
16845 match k {
16846 GeneratedField::TrackingId => {
16847 if tracking_id__.is_some() {
16848 return Err(serde::de::Error::duplicate_field("trackingId"));
16849 }
16850 tracking_id__ = map_.next_value()?;
16851 }
16852 }
16853 }
16854 Ok(TelemetryInfoResponse {
16855 tracking_id: tracking_id__,
16856 })
16857 }
16858 }
16859 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
16860 }
16861}
16862impl serde::Serialize for ThrottleTarget {
16863 #[allow(deprecated)]
16864 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16865 where
16866 S: serde::Serializer,
16867 {
16868 let variant = match self {
16869 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
16870 Self::Source => "SOURCE",
16871 Self::Mv => "MV",
16872 Self::TableWithSource => "TABLE_WITH_SOURCE",
16873 Self::CdcTable => "CDC_TABLE",
16874 Self::TableDml => "TABLE_DML",
16875 Self::Sink => "SINK",
16876 Self::Fragment => "FRAGMENT",
16877 };
16878 serializer.serialize_str(variant)
16879 }
16880}
16881impl<'de> serde::Deserialize<'de> for ThrottleTarget {
16882 #[allow(deprecated)]
16883 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16884 where
16885 D: serde::Deserializer<'de>,
16886 {
16887 const FIELDS: &[&str] = &[
16888 "THROTTLE_TARGET_UNSPECIFIED",
16889 "SOURCE",
16890 "MV",
16891 "TABLE_WITH_SOURCE",
16892 "CDC_TABLE",
16893 "TABLE_DML",
16894 "SINK",
16895 "FRAGMENT",
16896 ];
16897
16898 struct GeneratedVisitor;
16899
16900 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16901 type Value = ThrottleTarget;
16902
16903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16904 write!(formatter, "expected one of: {:?}", &FIELDS)
16905 }
16906
16907 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16908 where
16909 E: serde::de::Error,
16910 {
16911 i32::try_from(v)
16912 .ok()
16913 .and_then(|x| x.try_into().ok())
16914 .ok_or_else(|| {
16915 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16916 })
16917 }
16918
16919 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16920 where
16921 E: serde::de::Error,
16922 {
16923 i32::try_from(v)
16924 .ok()
16925 .and_then(|x| x.try_into().ok())
16926 .ok_or_else(|| {
16927 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16928 })
16929 }
16930
16931 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16932 where
16933 E: serde::de::Error,
16934 {
16935 match value {
16936 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
16937 "SOURCE" => Ok(ThrottleTarget::Source),
16938 "MV" => Ok(ThrottleTarget::Mv),
16939 "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
16940 "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
16941 "TABLE_DML" => Ok(ThrottleTarget::TableDml),
16942 "SINK" => Ok(ThrottleTarget::Sink),
16943 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
16944 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16945 }
16946 }
16947 }
16948 deserializer.deserialize_any(GeneratedVisitor)
16949 }
16950}
16951impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
16952 #[allow(deprecated)]
16953 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16954 where
16955 S: serde::Serializer,
16956 {
16957 use serde::ser::SerializeStruct;
16958 let mut len = 0;
16959 if self.id != 0 {
16960 len += 1;
16961 }
16962 if !self.node_label.is_empty() {
16963 len += 1;
16964 }
16965 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
16966 if self.id != 0 {
16967 struct_ser.serialize_field("id", &self.id)?;
16968 }
16969 if !self.node_label.is_empty() {
16970 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
16971 }
16972 struct_ser.end()
16973 }
16974}
16975impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
16976 #[allow(deprecated)]
16977 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16978 where
16979 D: serde::Deserializer<'de>,
16980 {
16981 const FIELDS: &[&str] = &[
16982 "id",
16983 "node_label",
16984 "nodeLabel",
16985 ];
16986
16987 #[allow(clippy::enum_variant_names)]
16988 enum GeneratedField {
16989 Id,
16990 NodeLabel,
16991 }
16992 impl<'de> serde::Deserialize<'de> for GeneratedField {
16993 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16994 where
16995 D: serde::Deserializer<'de>,
16996 {
16997 struct GeneratedVisitor;
16998
16999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17000 type Value = GeneratedField;
17001
17002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17003 write!(formatter, "expected one of: {:?}", &FIELDS)
17004 }
17005
17006 #[allow(unused_variables)]
17007 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17008 where
17009 E: serde::de::Error,
17010 {
17011 match value {
17012 "id" => Ok(GeneratedField::Id),
17013 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
17014 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17015 }
17016 }
17017 }
17018 deserializer.deserialize_identifier(GeneratedVisitor)
17019 }
17020 }
17021 struct GeneratedVisitor;
17022 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17023 type Value = UpdateStreamingJobNodeLabelsRequest;
17024
17025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17026 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
17027 }
17028
17029 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
17030 where
17031 V: serde::de::MapAccess<'de>,
17032 {
17033 let mut id__ = None;
17034 let mut node_label__ = None;
17035 while let Some(k) = map_.next_key()? {
17036 match k {
17037 GeneratedField::Id => {
17038 if id__.is_some() {
17039 return Err(serde::de::Error::duplicate_field("id"));
17040 }
17041 id__ =
17042 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17043 ;
17044 }
17045 GeneratedField::NodeLabel => {
17046 if node_label__.is_some() {
17047 return Err(serde::de::Error::duplicate_field("nodeLabel"));
17048 }
17049 node_label__ = Some(map_.next_value()?);
17050 }
17051 }
17052 }
17053 Ok(UpdateStreamingJobNodeLabelsRequest {
17054 id: id__.unwrap_or_default(),
17055 node_label: node_label__.unwrap_or_default(),
17056 })
17057 }
17058 }
17059 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
17060 }
17061}
17062impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
17063 #[allow(deprecated)]
17064 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17065 where
17066 S: serde::Serializer,
17067 {
17068 use serde::ser::SerializeStruct;
17069 let len = 0;
17070 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
17071 struct_ser.end()
17072 }
17073}
17074impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
17075 #[allow(deprecated)]
17076 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17077 where
17078 D: serde::Deserializer<'de>,
17079 {
17080 const FIELDS: &[&str] = &[
17081 ];
17082
17083 #[allow(clippy::enum_variant_names)]
17084 enum GeneratedField {
17085 }
17086 impl<'de> serde::Deserialize<'de> for GeneratedField {
17087 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17088 where
17089 D: serde::Deserializer<'de>,
17090 {
17091 struct GeneratedVisitor;
17092
17093 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17094 type Value = GeneratedField;
17095
17096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17097 write!(formatter, "expected one of: {:?}", &FIELDS)
17098 }
17099
17100 #[allow(unused_variables)]
17101 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17102 where
17103 E: serde::de::Error,
17104 {
17105 Err(serde::de::Error::unknown_field(value, FIELDS))
17106 }
17107 }
17108 deserializer.deserialize_identifier(GeneratedVisitor)
17109 }
17110 }
17111 struct GeneratedVisitor;
17112 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17113 type Value = UpdateStreamingJobNodeLabelsResponse;
17114
17115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17116 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
17117 }
17118
17119 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
17120 where
17121 V: serde::de::MapAccess<'de>,
17122 {
17123 while map_.next_key::<GeneratedField>()?.is_some() {
17124 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17125 }
17126 Ok(UpdateStreamingJobNodeLabelsResponse {
17127 })
17128 }
17129 }
17130 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
17131 }
17132}
17133impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
17134 #[allow(deprecated)]
17135 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17136 where
17137 S: serde::Serializer,
17138 {
17139 use serde::ser::SerializeStruct;
17140 let mut len = 0;
17141 if !self.worker_ids.is_empty() {
17142 len += 1;
17143 }
17144 if self.schedulability != 0 {
17145 len += 1;
17146 }
17147 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
17148 if !self.worker_ids.is_empty() {
17149 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
17150 }
17151 if self.schedulability != 0 {
17152 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
17153 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
17154 struct_ser.serialize_field("schedulability", &v)?;
17155 }
17156 struct_ser.end()
17157 }
17158}
17159impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
17160 #[allow(deprecated)]
17161 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17162 where
17163 D: serde::Deserializer<'de>,
17164 {
17165 const FIELDS: &[&str] = &[
17166 "worker_ids",
17167 "workerIds",
17168 "schedulability",
17169 ];
17170
17171 #[allow(clippy::enum_variant_names)]
17172 enum GeneratedField {
17173 WorkerIds,
17174 Schedulability,
17175 }
17176 impl<'de> serde::Deserialize<'de> for GeneratedField {
17177 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17178 where
17179 D: serde::Deserializer<'de>,
17180 {
17181 struct GeneratedVisitor;
17182
17183 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17184 type Value = GeneratedField;
17185
17186 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17187 write!(formatter, "expected one of: {:?}", &FIELDS)
17188 }
17189
17190 #[allow(unused_variables)]
17191 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17192 where
17193 E: serde::de::Error,
17194 {
17195 match value {
17196 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
17197 "schedulability" => Ok(GeneratedField::Schedulability),
17198 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17199 }
17200 }
17201 }
17202 deserializer.deserialize_identifier(GeneratedVisitor)
17203 }
17204 }
17205 struct GeneratedVisitor;
17206 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17207 type Value = UpdateWorkerNodeSchedulabilityRequest;
17208
17209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17210 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
17211 }
17212
17213 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
17214 where
17215 V: serde::de::MapAccess<'de>,
17216 {
17217 let mut worker_ids__ = None;
17218 let mut schedulability__ = None;
17219 while let Some(k) = map_.next_key()? {
17220 match k {
17221 GeneratedField::WorkerIds => {
17222 if worker_ids__.is_some() {
17223 return Err(serde::de::Error::duplicate_field("workerIds"));
17224 }
17225 worker_ids__ =
17226 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17227 .into_iter().map(|x| x.0).collect())
17228 ;
17229 }
17230 GeneratedField::Schedulability => {
17231 if schedulability__.is_some() {
17232 return Err(serde::de::Error::duplicate_field("schedulability"));
17233 }
17234 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
17235 }
17236 }
17237 }
17238 Ok(UpdateWorkerNodeSchedulabilityRequest {
17239 worker_ids: worker_ids__.unwrap_or_default(),
17240 schedulability: schedulability__.unwrap_or_default(),
17241 })
17242 }
17243 }
17244 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
17245 }
17246}
17247impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
17248 #[allow(deprecated)]
17249 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17250 where
17251 S: serde::Serializer,
17252 {
17253 let variant = match self {
17254 Self::Unspecified => "UNSPECIFIED",
17255 Self::Schedulable => "SCHEDULABLE",
17256 Self::Unschedulable => "UNSCHEDULABLE",
17257 };
17258 serializer.serialize_str(variant)
17259 }
17260}
17261impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
17262 #[allow(deprecated)]
17263 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17264 where
17265 D: serde::Deserializer<'de>,
17266 {
17267 const FIELDS: &[&str] = &[
17268 "UNSPECIFIED",
17269 "SCHEDULABLE",
17270 "UNSCHEDULABLE",
17271 ];
17272
17273 struct GeneratedVisitor;
17274
17275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17276 type Value = update_worker_node_schedulability_request::Schedulability;
17277
17278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17279 write!(formatter, "expected one of: {:?}", &FIELDS)
17280 }
17281
17282 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17283 where
17284 E: serde::de::Error,
17285 {
17286 i32::try_from(v)
17287 .ok()
17288 .and_then(|x| x.try_into().ok())
17289 .ok_or_else(|| {
17290 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17291 })
17292 }
17293
17294 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17295 where
17296 E: serde::de::Error,
17297 {
17298 i32::try_from(v)
17299 .ok()
17300 .and_then(|x| x.try_into().ok())
17301 .ok_or_else(|| {
17302 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17303 })
17304 }
17305
17306 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17307 where
17308 E: serde::de::Error,
17309 {
17310 match value {
17311 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
17312 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
17313 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
17314 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17315 }
17316 }
17317 }
17318 deserializer.deserialize_any(GeneratedVisitor)
17319 }
17320}
17321impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
17322 #[allow(deprecated)]
17323 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17324 where
17325 S: serde::Serializer,
17326 {
17327 use serde::ser::SerializeStruct;
17328 let mut len = 0;
17329 if self.status.is_some() {
17330 len += 1;
17331 }
17332 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
17333 if let Some(v) = self.status.as_ref() {
17334 struct_ser.serialize_field("status", v)?;
17335 }
17336 struct_ser.end()
17337 }
17338}
17339impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
17340 #[allow(deprecated)]
17341 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17342 where
17343 D: serde::Deserializer<'de>,
17344 {
17345 const FIELDS: &[&str] = &[
17346 "status",
17347 ];
17348
17349 #[allow(clippy::enum_variant_names)]
17350 enum GeneratedField {
17351 Status,
17352 }
17353 impl<'de> serde::Deserialize<'de> for GeneratedField {
17354 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17355 where
17356 D: serde::Deserializer<'de>,
17357 {
17358 struct GeneratedVisitor;
17359
17360 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17361 type Value = GeneratedField;
17362
17363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17364 write!(formatter, "expected one of: {:?}", &FIELDS)
17365 }
17366
17367 #[allow(unused_variables)]
17368 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17369 where
17370 E: serde::de::Error,
17371 {
17372 match value {
17373 "status" => Ok(GeneratedField::Status),
17374 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17375 }
17376 }
17377 }
17378 deserializer.deserialize_identifier(GeneratedVisitor)
17379 }
17380 }
17381 struct GeneratedVisitor;
17382 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17383 type Value = UpdateWorkerNodeSchedulabilityResponse;
17384
17385 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17386 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
17387 }
17388
17389 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
17390 where
17391 V: serde::de::MapAccess<'de>,
17392 {
17393 let mut status__ = None;
17394 while let Some(k) = map_.next_key()? {
17395 match k {
17396 GeneratedField::Status => {
17397 if status__.is_some() {
17398 return Err(serde::de::Error::duplicate_field("status"));
17399 }
17400 status__ = map_.next_value()?;
17401 }
17402 }
17403 }
17404 Ok(UpdateWorkerNodeSchedulabilityResponse {
17405 status: status__,
17406 })
17407 }
17408 }
17409 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
17410 }
17411}
17412impl serde::Serialize for WorkerReschedule {
17413 #[allow(deprecated)]
17414 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17415 where
17416 S: serde::Serializer,
17417 {
17418 use serde::ser::SerializeStruct;
17419 let mut len = 0;
17420 if !self.worker_actor_diff.is_empty() {
17421 len += 1;
17422 }
17423 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
17424 if !self.worker_actor_diff.is_empty() {
17425 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
17426 }
17427 struct_ser.end()
17428 }
17429}
17430impl<'de> serde::Deserialize<'de> for WorkerReschedule {
17431 #[allow(deprecated)]
17432 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17433 where
17434 D: serde::Deserializer<'de>,
17435 {
17436 const FIELDS: &[&str] = &[
17437 "worker_actor_diff",
17438 "workerActorDiff",
17439 ];
17440
17441 #[allow(clippy::enum_variant_names)]
17442 enum GeneratedField {
17443 WorkerActorDiff,
17444 }
17445 impl<'de> serde::Deserialize<'de> for GeneratedField {
17446 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17447 where
17448 D: serde::Deserializer<'de>,
17449 {
17450 struct GeneratedVisitor;
17451
17452 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17453 type Value = GeneratedField;
17454
17455 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17456 write!(formatter, "expected one of: {:?}", &FIELDS)
17457 }
17458
17459 #[allow(unused_variables)]
17460 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17461 where
17462 E: serde::de::Error,
17463 {
17464 match value {
17465 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
17466 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17467 }
17468 }
17469 }
17470 deserializer.deserialize_identifier(GeneratedVisitor)
17471 }
17472 }
17473 struct GeneratedVisitor;
17474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17475 type Value = WorkerReschedule;
17476
17477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17478 formatter.write_str("struct meta.WorkerReschedule")
17479 }
17480
17481 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
17482 where
17483 V: serde::de::MapAccess<'de>,
17484 {
17485 let mut worker_actor_diff__ = None;
17486 while let Some(k) = map_.next_key()? {
17487 match k {
17488 GeneratedField::WorkerActorDiff => {
17489 if worker_actor_diff__.is_some() {
17490 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
17491 }
17492 worker_actor_diff__ = Some(
17493 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
17494 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
17495 );
17496 }
17497 }
17498 }
17499 Ok(WorkerReschedule {
17500 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
17501 })
17502 }
17503 }
17504 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
17505 }
17506}