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