1#![allow(clippy::useless_conversion)]
2use crate::source::*;
3impl serde::Serialize for CdcTableSnapshotSplit {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if self.split_id != 0 {
12 len += 1;
13 }
14 if !self.left_bound_inclusive.is_empty() {
15 len += 1;
16 }
17 if !self.right_bound_exclusive.is_empty() {
18 len += 1;
19 }
20 let mut struct_ser = serializer.serialize_struct("source.CdcTableSnapshotSplit", len)?;
21 if self.split_id != 0 {
22 #[allow(clippy::needless_borrow)]
23 #[allow(clippy::needless_borrows_for_generic_args)]
24 struct_ser.serialize_field("splitId", ToString::to_string(&self.split_id).as_str())?;
25 }
26 if !self.left_bound_inclusive.is_empty() {
27 #[allow(clippy::needless_borrow)]
28 #[allow(clippy::needless_borrows_for_generic_args)]
29 struct_ser.serialize_field("leftBoundInclusive", pbjson::private::base64::encode(&self.left_bound_inclusive).as_str())?;
30 }
31 if !self.right_bound_exclusive.is_empty() {
32 #[allow(clippy::needless_borrow)]
33 #[allow(clippy::needless_borrows_for_generic_args)]
34 struct_ser.serialize_field("rightBoundExclusive", pbjson::private::base64::encode(&self.right_bound_exclusive).as_str())?;
35 }
36 struct_ser.end()
37 }
38}
39impl<'de> serde::Deserialize<'de> for CdcTableSnapshotSplit {
40 #[allow(deprecated)]
41 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
42 where
43 D: serde::Deserializer<'de>,
44 {
45 const FIELDS: &[&str] = &[
46 "split_id",
47 "splitId",
48 "left_bound_inclusive",
49 "leftBoundInclusive",
50 "right_bound_exclusive",
51 "rightBoundExclusive",
52 ];
53
54 #[allow(clippy::enum_variant_names)]
55 enum GeneratedField {
56 SplitId,
57 LeftBoundInclusive,
58 RightBoundExclusive,
59 }
60 impl<'de> serde::Deserialize<'de> for GeneratedField {
61 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
62 where
63 D: serde::Deserializer<'de>,
64 {
65 struct GeneratedVisitor;
66
67 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
68 type Value = GeneratedField;
69
70 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
71 write!(formatter, "expected one of: {:?}", &FIELDS)
72 }
73
74 #[allow(unused_variables)]
75 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
76 where
77 E: serde::de::Error,
78 {
79 match value {
80 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
81 "leftBoundInclusive" | "left_bound_inclusive" => Ok(GeneratedField::LeftBoundInclusive),
82 "rightBoundExclusive" | "right_bound_exclusive" => Ok(GeneratedField::RightBoundExclusive),
83 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
84 }
85 }
86 }
87 deserializer.deserialize_identifier(GeneratedVisitor)
88 }
89 }
90 struct GeneratedVisitor;
91 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
92 type Value = CdcTableSnapshotSplit;
93
94 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
95 formatter.write_str("struct source.CdcTableSnapshotSplit")
96 }
97
98 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcTableSnapshotSplit, V::Error>
99 where
100 V: serde::de::MapAccess<'de>,
101 {
102 let mut split_id__ = None;
103 let mut left_bound_inclusive__ = None;
104 let mut right_bound_exclusive__ = None;
105 while let Some(k) = map_.next_key()? {
106 match k {
107 GeneratedField::SplitId => {
108 if split_id__.is_some() {
109 return Err(serde::de::Error::duplicate_field("splitId"));
110 }
111 split_id__ =
112 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
113 ;
114 }
115 GeneratedField::LeftBoundInclusive => {
116 if left_bound_inclusive__.is_some() {
117 return Err(serde::de::Error::duplicate_field("leftBoundInclusive"));
118 }
119 left_bound_inclusive__ =
120 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
121 ;
122 }
123 GeneratedField::RightBoundExclusive => {
124 if right_bound_exclusive__.is_some() {
125 return Err(serde::de::Error::duplicate_field("rightBoundExclusive"));
126 }
127 right_bound_exclusive__ =
128 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
129 ;
130 }
131 }
132 }
133 Ok(CdcTableSnapshotSplit {
134 split_id: split_id__.unwrap_or_default(),
135 left_bound_inclusive: left_bound_inclusive__.unwrap_or_default(),
136 right_bound_exclusive: right_bound_exclusive__.unwrap_or_default(),
137 })
138 }
139 }
140 deserializer.deserialize_struct("source.CdcTableSnapshotSplit", FIELDS, GeneratedVisitor)
141 }
142}
143impl serde::Serialize for CdcTableSnapshotSplits {
144 #[allow(deprecated)]
145 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
146 where
147 S: serde::Serializer,
148 {
149 use serde::ser::SerializeStruct;
150 let mut len = 0;
151 if !self.splits.is_empty() {
152 len += 1;
153 }
154 let mut struct_ser = serializer.serialize_struct("source.CdcTableSnapshotSplits", len)?;
155 if !self.splits.is_empty() {
156 struct_ser.serialize_field("splits", &self.splits)?;
157 }
158 struct_ser.end()
159 }
160}
161impl<'de> serde::Deserialize<'de> for CdcTableSnapshotSplits {
162 #[allow(deprecated)]
163 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
164 where
165 D: serde::Deserializer<'de>,
166 {
167 const FIELDS: &[&str] = &[
168 "splits",
169 ];
170
171 #[allow(clippy::enum_variant_names)]
172 enum GeneratedField {
173 Splits,
174 }
175 impl<'de> serde::Deserialize<'de> for GeneratedField {
176 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
177 where
178 D: serde::Deserializer<'de>,
179 {
180 struct GeneratedVisitor;
181
182 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
183 type Value = GeneratedField;
184
185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
186 write!(formatter, "expected one of: {:?}", &FIELDS)
187 }
188
189 #[allow(unused_variables)]
190 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
191 where
192 E: serde::de::Error,
193 {
194 match value {
195 "splits" => Ok(GeneratedField::Splits),
196 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
197 }
198 }
199 }
200 deserializer.deserialize_identifier(GeneratedVisitor)
201 }
202 }
203 struct GeneratedVisitor;
204 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
205 type Value = CdcTableSnapshotSplits;
206
207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
208 formatter.write_str("struct source.CdcTableSnapshotSplits")
209 }
210
211 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcTableSnapshotSplits, V::Error>
212 where
213 V: serde::de::MapAccess<'de>,
214 {
215 let mut splits__ = None;
216 while let Some(k) = map_.next_key()? {
217 match k {
218 GeneratedField::Splits => {
219 if splits__.is_some() {
220 return Err(serde::de::Error::duplicate_field("splits"));
221 }
222 splits__ = Some(map_.next_value()?);
223 }
224 }
225 }
226 Ok(CdcTableSnapshotSplits {
227 splits: splits__.unwrap_or_default(),
228 })
229 }
230 }
231 deserializer.deserialize_struct("source.CdcTableSnapshotSplits", FIELDS, GeneratedVisitor)
232 }
233}
234impl serde::Serialize for CdcTableSnapshotSplitsWithGeneration {
235 #[allow(deprecated)]
236 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
237 where
238 S: serde::Serializer,
239 {
240 use serde::ser::SerializeStruct;
241 let mut len = 0;
242 if !self.splits.is_empty() {
243 len += 1;
244 }
245 if self.generation != 0 {
246 len += 1;
247 }
248 let mut struct_ser = serializer.serialize_struct("source.CdcTableSnapshotSplitsWithGeneration", len)?;
249 if !self.splits.is_empty() {
250 struct_ser.serialize_field("splits", &self.splits)?;
251 }
252 if self.generation != 0 {
253 #[allow(clippy::needless_borrow)]
254 #[allow(clippy::needless_borrows_for_generic_args)]
255 struct_ser.serialize_field("generation", ToString::to_string(&self.generation).as_str())?;
256 }
257 struct_ser.end()
258 }
259}
260impl<'de> serde::Deserialize<'de> for CdcTableSnapshotSplitsWithGeneration {
261 #[allow(deprecated)]
262 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
263 where
264 D: serde::Deserializer<'de>,
265 {
266 const FIELDS: &[&str] = &[
267 "splits",
268 "generation",
269 ];
270
271 #[allow(clippy::enum_variant_names)]
272 enum GeneratedField {
273 Splits,
274 Generation,
275 }
276 impl<'de> serde::Deserialize<'de> for GeneratedField {
277 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
278 where
279 D: serde::Deserializer<'de>,
280 {
281 struct GeneratedVisitor;
282
283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
284 type Value = GeneratedField;
285
286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
287 write!(formatter, "expected one of: {:?}", &FIELDS)
288 }
289
290 #[allow(unused_variables)]
291 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
292 where
293 E: serde::de::Error,
294 {
295 match value {
296 "splits" => Ok(GeneratedField::Splits),
297 "generation" => Ok(GeneratedField::Generation),
298 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
299 }
300 }
301 }
302 deserializer.deserialize_identifier(GeneratedVisitor)
303 }
304 }
305 struct GeneratedVisitor;
306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
307 type Value = CdcTableSnapshotSplitsWithGeneration;
308
309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
310 formatter.write_str("struct source.CdcTableSnapshotSplitsWithGeneration")
311 }
312
313 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcTableSnapshotSplitsWithGeneration, V::Error>
314 where
315 V: serde::de::MapAccess<'de>,
316 {
317 let mut splits__ = None;
318 let mut generation__ = None;
319 while let Some(k) = map_.next_key()? {
320 match k {
321 GeneratedField::Splits => {
322 if splits__.is_some() {
323 return Err(serde::de::Error::duplicate_field("splits"));
324 }
325 splits__ = Some(
326 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
327 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
328 );
329 }
330 GeneratedField::Generation => {
331 if generation__.is_some() {
332 return Err(serde::de::Error::duplicate_field("generation"));
333 }
334 generation__ =
335 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
336 ;
337 }
338 }
339 }
340 Ok(CdcTableSnapshotSplitsWithGeneration {
341 splits: splits__.unwrap_or_default(),
342 generation: generation__.unwrap_or_default(),
343 })
344 }
345 }
346 deserializer.deserialize_struct("source.CdcTableSnapshotSplitsWithGeneration", FIELDS, GeneratedVisitor)
347 }
348}
349impl serde::Serialize for ConnectorSplit {
350 #[allow(deprecated)]
351 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
352 where
353 S: serde::Serializer,
354 {
355 use serde::ser::SerializeStruct;
356 let mut len = 0;
357 if !self.split_type.is_empty() {
358 len += 1;
359 }
360 if !self.encoded_split.is_empty() {
361 len += 1;
362 }
363 let mut struct_ser = serializer.serialize_struct("source.ConnectorSplit", len)?;
364 if !self.split_type.is_empty() {
365 struct_ser.serialize_field("splitType", &self.split_type)?;
366 }
367 if !self.encoded_split.is_empty() {
368 #[allow(clippy::needless_borrow)]
369 #[allow(clippy::needless_borrows_for_generic_args)]
370 struct_ser.serialize_field("encodedSplit", pbjson::private::base64::encode(&self.encoded_split).as_str())?;
371 }
372 struct_ser.end()
373 }
374}
375impl<'de> serde::Deserialize<'de> for ConnectorSplit {
376 #[allow(deprecated)]
377 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
378 where
379 D: serde::Deserializer<'de>,
380 {
381 const FIELDS: &[&str] = &[
382 "split_type",
383 "splitType",
384 "encoded_split",
385 "encodedSplit",
386 ];
387
388 #[allow(clippy::enum_variant_names)]
389 enum GeneratedField {
390 SplitType,
391 EncodedSplit,
392 }
393 impl<'de> serde::Deserialize<'de> for GeneratedField {
394 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
395 where
396 D: serde::Deserializer<'de>,
397 {
398 struct GeneratedVisitor;
399
400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
401 type Value = GeneratedField;
402
403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
404 write!(formatter, "expected one of: {:?}", &FIELDS)
405 }
406
407 #[allow(unused_variables)]
408 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
409 where
410 E: serde::de::Error,
411 {
412 match value {
413 "splitType" | "split_type" => Ok(GeneratedField::SplitType),
414 "encodedSplit" | "encoded_split" => Ok(GeneratedField::EncodedSplit),
415 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
416 }
417 }
418 }
419 deserializer.deserialize_identifier(GeneratedVisitor)
420 }
421 }
422 struct GeneratedVisitor;
423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
424 type Value = ConnectorSplit;
425
426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
427 formatter.write_str("struct source.ConnectorSplit")
428 }
429
430 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorSplit, V::Error>
431 where
432 V: serde::de::MapAccess<'de>,
433 {
434 let mut split_type__ = None;
435 let mut encoded_split__ = None;
436 while let Some(k) = map_.next_key()? {
437 match k {
438 GeneratedField::SplitType => {
439 if split_type__.is_some() {
440 return Err(serde::de::Error::duplicate_field("splitType"));
441 }
442 split_type__ = Some(map_.next_value()?);
443 }
444 GeneratedField::EncodedSplit => {
445 if encoded_split__.is_some() {
446 return Err(serde::de::Error::duplicate_field("encodedSplit"));
447 }
448 encoded_split__ =
449 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
450 ;
451 }
452 }
453 }
454 Ok(ConnectorSplit {
455 split_type: split_type__.unwrap_or_default(),
456 encoded_split: encoded_split__.unwrap_or_default(),
457 })
458 }
459 }
460 deserializer.deserialize_struct("source.ConnectorSplit", FIELDS, GeneratedVisitor)
461 }
462}
463impl serde::Serialize for ConnectorSplits {
464 #[allow(deprecated)]
465 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
466 where
467 S: serde::Serializer,
468 {
469 use serde::ser::SerializeStruct;
470 let mut len = 0;
471 if !self.splits.is_empty() {
472 len += 1;
473 }
474 let mut struct_ser = serializer.serialize_struct("source.ConnectorSplits", len)?;
475 if !self.splits.is_empty() {
476 struct_ser.serialize_field("splits", &self.splits)?;
477 }
478 struct_ser.end()
479 }
480}
481impl<'de> serde::Deserialize<'de> for ConnectorSplits {
482 #[allow(deprecated)]
483 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
484 where
485 D: serde::Deserializer<'de>,
486 {
487 const FIELDS: &[&str] = &[
488 "splits",
489 ];
490
491 #[allow(clippy::enum_variant_names)]
492 enum GeneratedField {
493 Splits,
494 }
495 impl<'de> serde::Deserialize<'de> for GeneratedField {
496 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
497 where
498 D: serde::Deserializer<'de>,
499 {
500 struct GeneratedVisitor;
501
502 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
503 type Value = GeneratedField;
504
505 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
506 write!(formatter, "expected one of: {:?}", &FIELDS)
507 }
508
509 #[allow(unused_variables)]
510 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
511 where
512 E: serde::de::Error,
513 {
514 match value {
515 "splits" => Ok(GeneratedField::Splits),
516 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
517 }
518 }
519 }
520 deserializer.deserialize_identifier(GeneratedVisitor)
521 }
522 }
523 struct GeneratedVisitor;
524 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
525 type Value = ConnectorSplits;
526
527 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
528 formatter.write_str("struct source.ConnectorSplits")
529 }
530
531 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorSplits, V::Error>
532 where
533 V: serde::de::MapAccess<'de>,
534 {
535 let mut splits__ = None;
536 while let Some(k) = map_.next_key()? {
537 match k {
538 GeneratedField::Splits => {
539 if splits__.is_some() {
540 return Err(serde::de::Error::duplicate_field("splits"));
541 }
542 splits__ = Some(map_.next_value()?);
543 }
544 }
545 }
546 Ok(ConnectorSplits {
547 splits: splits__.unwrap_or_default(),
548 })
549 }
550 }
551 deserializer.deserialize_struct("source.ConnectorSplits", FIELDS, GeneratedVisitor)
552 }
553}
554impl serde::Serialize for SourceActorInfo {
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.actor_id != 0 {
563 len += 1;
564 }
565 if self.splits.is_some() {
566 len += 1;
567 }
568 let mut struct_ser = serializer.serialize_struct("source.SourceActorInfo", len)?;
569 if self.actor_id != 0 {
570 struct_ser.serialize_field("actorId", &self.actor_id)?;
571 }
572 if let Some(v) = self.splits.as_ref() {
573 struct_ser.serialize_field("splits", v)?;
574 }
575 struct_ser.end()
576 }
577}
578impl<'de> serde::Deserialize<'de> for SourceActorInfo {
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 "actor_id",
586 "actorId",
587 "splits",
588 ];
589
590 #[allow(clippy::enum_variant_names)]
591 enum GeneratedField {
592 ActorId,
593 Splits,
594 }
595 impl<'de> serde::Deserialize<'de> for GeneratedField {
596 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
597 where
598 D: serde::Deserializer<'de>,
599 {
600 struct GeneratedVisitor;
601
602 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
603 type Value = GeneratedField;
604
605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
606 write!(formatter, "expected one of: {:?}", &FIELDS)
607 }
608
609 #[allow(unused_variables)]
610 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
611 where
612 E: serde::de::Error,
613 {
614 match value {
615 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
616 "splits" => Ok(GeneratedField::Splits),
617 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
618 }
619 }
620 }
621 deserializer.deserialize_identifier(GeneratedVisitor)
622 }
623 }
624 struct GeneratedVisitor;
625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
626 type Value = SourceActorInfo;
627
628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
629 formatter.write_str("struct source.SourceActorInfo")
630 }
631
632 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceActorInfo, V::Error>
633 where
634 V: serde::de::MapAccess<'de>,
635 {
636 let mut actor_id__ = None;
637 let mut splits__ = None;
638 while let Some(k) = map_.next_key()? {
639 match k {
640 GeneratedField::ActorId => {
641 if actor_id__.is_some() {
642 return Err(serde::de::Error::duplicate_field("actorId"));
643 }
644 actor_id__ =
645 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
646 ;
647 }
648 GeneratedField::Splits => {
649 if splits__.is_some() {
650 return Err(serde::de::Error::duplicate_field("splits"));
651 }
652 splits__ = map_.next_value()?;
653 }
654 }
655 }
656 Ok(SourceActorInfo {
657 actor_id: actor_id__.unwrap_or_default(),
658 splits: splits__,
659 })
660 }
661 }
662 deserializer.deserialize_struct("source.SourceActorInfo", FIELDS, GeneratedVisitor)
663 }
664}