1#![allow(clippy::useless_conversion)]
2use crate::connector_service::*;
3impl serde::Serialize for CdcMessage {
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.payload.is_empty() {
12 len += 1;
13 }
14 if !self.partition.is_empty() {
15 len += 1;
16 }
17 if !self.offset.is_empty() {
18 len += 1;
19 }
20 if !self.full_table_name.is_empty() {
21 len += 1;
22 }
23 if self.source_ts_ms != 0 {
24 len += 1;
25 }
26 if self.msg_type != 0 {
27 len += 1;
28 }
29 if !self.key.is_empty() {
30 len += 1;
31 }
32 let mut struct_ser = serializer.serialize_struct("connector_service.CdcMessage", len)?;
33 if !self.payload.is_empty() {
34 struct_ser.serialize_field("payload", &self.payload)?;
35 }
36 if !self.partition.is_empty() {
37 struct_ser.serialize_field("partition", &self.partition)?;
38 }
39 if !self.offset.is_empty() {
40 struct_ser.serialize_field("offset", &self.offset)?;
41 }
42 if !self.full_table_name.is_empty() {
43 struct_ser.serialize_field("fullTableName", &self.full_table_name)?;
44 }
45 if self.source_ts_ms != 0 {
46 #[allow(clippy::needless_borrow)]
47 #[allow(clippy::needless_borrows_for_generic_args)]
48 struct_ser.serialize_field("sourceTsMs", ToString::to_string(&self.source_ts_ms).as_str())?;
49 }
50 if self.msg_type != 0 {
51 let v = cdc_message::CdcMessageType::try_from(self.msg_type)
52 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.msg_type)))?;
53 struct_ser.serialize_field("msgType", &v)?;
54 }
55 if !self.key.is_empty() {
56 struct_ser.serialize_field("key", &self.key)?;
57 }
58 struct_ser.end()
59 }
60}
61impl<'de> serde::Deserialize<'de> for CdcMessage {
62 #[allow(deprecated)]
63 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
64 where
65 D: serde::Deserializer<'de>,
66 {
67 const FIELDS: &[&str] = &[
68 "payload",
69 "partition",
70 "offset",
71 "full_table_name",
72 "fullTableName",
73 "source_ts_ms",
74 "sourceTsMs",
75 "msg_type",
76 "msgType",
77 "key",
78 ];
79
80 #[allow(clippy::enum_variant_names)]
81 enum GeneratedField {
82 Payload,
83 Partition,
84 Offset,
85 FullTableName,
86 SourceTsMs,
87 MsgType,
88 Key,
89 }
90 impl<'de> serde::Deserialize<'de> for GeneratedField {
91 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
92 where
93 D: serde::Deserializer<'de>,
94 {
95 struct GeneratedVisitor;
96
97 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
98 type Value = GeneratedField;
99
100 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
101 write!(formatter, "expected one of: {:?}", &FIELDS)
102 }
103
104 #[allow(unused_variables)]
105 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
106 where
107 E: serde::de::Error,
108 {
109 match value {
110 "payload" => Ok(GeneratedField::Payload),
111 "partition" => Ok(GeneratedField::Partition),
112 "offset" => Ok(GeneratedField::Offset),
113 "fullTableName" | "full_table_name" => Ok(GeneratedField::FullTableName),
114 "sourceTsMs" | "source_ts_ms" => Ok(GeneratedField::SourceTsMs),
115 "msgType" | "msg_type" => Ok(GeneratedField::MsgType),
116 "key" => Ok(GeneratedField::Key),
117 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
118 }
119 }
120 }
121 deserializer.deserialize_identifier(GeneratedVisitor)
122 }
123 }
124 struct GeneratedVisitor;
125 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
126 type Value = CdcMessage;
127
128 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
129 formatter.write_str("struct connector_service.CdcMessage")
130 }
131
132 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcMessage, V::Error>
133 where
134 V: serde::de::MapAccess<'de>,
135 {
136 let mut payload__ = None;
137 let mut partition__ = None;
138 let mut offset__ = None;
139 let mut full_table_name__ = None;
140 let mut source_ts_ms__ = None;
141 let mut msg_type__ = None;
142 let mut key__ = None;
143 while let Some(k) = map_.next_key()? {
144 match k {
145 GeneratedField::Payload => {
146 if payload__.is_some() {
147 return Err(serde::de::Error::duplicate_field("payload"));
148 }
149 payload__ = Some(map_.next_value()?);
150 }
151 GeneratedField::Partition => {
152 if partition__.is_some() {
153 return Err(serde::de::Error::duplicate_field("partition"));
154 }
155 partition__ = Some(map_.next_value()?);
156 }
157 GeneratedField::Offset => {
158 if offset__.is_some() {
159 return Err(serde::de::Error::duplicate_field("offset"));
160 }
161 offset__ = Some(map_.next_value()?);
162 }
163 GeneratedField::FullTableName => {
164 if full_table_name__.is_some() {
165 return Err(serde::de::Error::duplicate_field("fullTableName"));
166 }
167 full_table_name__ = Some(map_.next_value()?);
168 }
169 GeneratedField::SourceTsMs => {
170 if source_ts_ms__.is_some() {
171 return Err(serde::de::Error::duplicate_field("sourceTsMs"));
172 }
173 source_ts_ms__ =
174 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
175 ;
176 }
177 GeneratedField::MsgType => {
178 if msg_type__.is_some() {
179 return Err(serde::de::Error::duplicate_field("msgType"));
180 }
181 msg_type__ = Some(map_.next_value::<cdc_message::CdcMessageType>()? as i32);
182 }
183 GeneratedField::Key => {
184 if key__.is_some() {
185 return Err(serde::de::Error::duplicate_field("key"));
186 }
187 key__ = Some(map_.next_value()?);
188 }
189 }
190 }
191 Ok(CdcMessage {
192 payload: payload__.unwrap_or_default(),
193 partition: partition__.unwrap_or_default(),
194 offset: offset__.unwrap_or_default(),
195 full_table_name: full_table_name__.unwrap_or_default(),
196 source_ts_ms: source_ts_ms__.unwrap_or_default(),
197 msg_type: msg_type__.unwrap_or_default(),
198 key: key__.unwrap_or_default(),
199 })
200 }
201 }
202 deserializer.deserialize_struct("connector_service.CdcMessage", FIELDS, GeneratedVisitor)
203 }
204}
205impl serde::Serialize for cdc_message::CdcMessageType {
206 #[allow(deprecated)]
207 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
208 where
209 S: serde::Serializer,
210 {
211 let variant = match self {
212 Self::Unspecified => "UNSPECIFIED",
213 Self::Heartbeat => "HEARTBEAT",
214 Self::Data => "DATA",
215 Self::TransactionMeta => "TRANSACTION_META",
216 Self::SchemaChange => "SCHEMA_CHANGE",
217 };
218 serializer.serialize_str(variant)
219 }
220}
221impl<'de> serde::Deserialize<'de> for cdc_message::CdcMessageType {
222 #[allow(deprecated)]
223 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
224 where
225 D: serde::Deserializer<'de>,
226 {
227 const FIELDS: &[&str] = &[
228 "UNSPECIFIED",
229 "HEARTBEAT",
230 "DATA",
231 "TRANSACTION_META",
232 "SCHEMA_CHANGE",
233 ];
234
235 struct GeneratedVisitor;
236
237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
238 type Value = cdc_message::CdcMessageType;
239
240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
241 write!(formatter, "expected one of: {:?}", &FIELDS)
242 }
243
244 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
245 where
246 E: serde::de::Error,
247 {
248 i32::try_from(v)
249 .ok()
250 .and_then(|x| x.try_into().ok())
251 .ok_or_else(|| {
252 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
253 })
254 }
255
256 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
257 where
258 E: serde::de::Error,
259 {
260 i32::try_from(v)
261 .ok()
262 .and_then(|x| x.try_into().ok())
263 .ok_or_else(|| {
264 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
265 })
266 }
267
268 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
269 where
270 E: serde::de::Error,
271 {
272 match value {
273 "UNSPECIFIED" => Ok(cdc_message::CdcMessageType::Unspecified),
274 "HEARTBEAT" => Ok(cdc_message::CdcMessageType::Heartbeat),
275 "DATA" => Ok(cdc_message::CdcMessageType::Data),
276 "TRANSACTION_META" => Ok(cdc_message::CdcMessageType::TransactionMeta),
277 "SCHEMA_CHANGE" => Ok(cdc_message::CdcMessageType::SchemaChange),
278 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
279 }
280 }
281 }
282 deserializer.deserialize_any(GeneratedVisitor)
283 }
284}
285impl serde::Serialize for CoordinateRequest {
286 #[allow(deprecated)]
287 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
288 where
289 S: serde::Serializer,
290 {
291 use serde::ser::SerializeStruct;
292 let mut len = 0;
293 if self.msg.is_some() {
294 len += 1;
295 }
296 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateRequest", len)?;
297 if let Some(v) = self.msg.as_ref() {
298 match v {
299 coordinate_request::Msg::StartRequest(v) => {
300 struct_ser.serialize_field("startRequest", v)?;
301 }
302 coordinate_request::Msg::CommitRequest(v) => {
303 struct_ser.serialize_field("commitRequest", v)?;
304 }
305 coordinate_request::Msg::UpdateVnodeRequest(v) => {
306 struct_ser.serialize_field("updateVnodeRequest", v)?;
307 }
308 coordinate_request::Msg::Stop(v) => {
309 struct_ser.serialize_field("stop", v)?;
310 }
311 coordinate_request::Msg::AlignInitialEpochRequest(v) => {
312 #[allow(clippy::needless_borrow)]
313 #[allow(clippy::needless_borrows_for_generic_args)]
314 struct_ser.serialize_field("alignInitialEpochRequest", ToString::to_string(&v).as_str())?;
315 }
316 }
317 }
318 struct_ser.end()
319 }
320}
321impl<'de> serde::Deserialize<'de> for CoordinateRequest {
322 #[allow(deprecated)]
323 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
324 where
325 D: serde::Deserializer<'de>,
326 {
327 const FIELDS: &[&str] = &[
328 "start_request",
329 "startRequest",
330 "commit_request",
331 "commitRequest",
332 "update_vnode_request",
333 "updateVnodeRequest",
334 "stop",
335 "align_initial_epoch_request",
336 "alignInitialEpochRequest",
337 ];
338
339 #[allow(clippy::enum_variant_names)]
340 enum GeneratedField {
341 StartRequest,
342 CommitRequest,
343 UpdateVnodeRequest,
344 Stop,
345 AlignInitialEpochRequest,
346 }
347 impl<'de> serde::Deserialize<'de> for GeneratedField {
348 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
349 where
350 D: serde::Deserializer<'de>,
351 {
352 struct GeneratedVisitor;
353
354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
355 type Value = GeneratedField;
356
357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
358 write!(formatter, "expected one of: {:?}", &FIELDS)
359 }
360
361 #[allow(unused_variables)]
362 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
363 where
364 E: serde::de::Error,
365 {
366 match value {
367 "startRequest" | "start_request" => Ok(GeneratedField::StartRequest),
368 "commitRequest" | "commit_request" => Ok(GeneratedField::CommitRequest),
369 "updateVnodeRequest" | "update_vnode_request" => Ok(GeneratedField::UpdateVnodeRequest),
370 "stop" => Ok(GeneratedField::Stop),
371 "alignInitialEpochRequest" | "align_initial_epoch_request" => Ok(GeneratedField::AlignInitialEpochRequest),
372 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
373 }
374 }
375 }
376 deserializer.deserialize_identifier(GeneratedVisitor)
377 }
378 }
379 struct GeneratedVisitor;
380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
381 type Value = CoordinateRequest;
382
383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
384 formatter.write_str("struct connector_service.CoordinateRequest")
385 }
386
387 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CoordinateRequest, V::Error>
388 where
389 V: serde::de::MapAccess<'de>,
390 {
391 let mut msg__ = None;
392 while let Some(k) = map_.next_key()? {
393 match k {
394 GeneratedField::StartRequest => {
395 if msg__.is_some() {
396 return Err(serde::de::Error::duplicate_field("startRequest"));
397 }
398 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_request::Msg::StartRequest)
399;
400 }
401 GeneratedField::CommitRequest => {
402 if msg__.is_some() {
403 return Err(serde::de::Error::duplicate_field("commitRequest"));
404 }
405 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_request::Msg::CommitRequest)
406;
407 }
408 GeneratedField::UpdateVnodeRequest => {
409 if msg__.is_some() {
410 return Err(serde::de::Error::duplicate_field("updateVnodeRequest"));
411 }
412 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_request::Msg::UpdateVnodeRequest)
413;
414 }
415 GeneratedField::Stop => {
416 if msg__.is_some() {
417 return Err(serde::de::Error::duplicate_field("stop"));
418 }
419 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_request::Msg::Stop);
420 }
421 GeneratedField::AlignInitialEpochRequest => {
422 if msg__.is_some() {
423 return Err(serde::de::Error::duplicate_field("alignInitialEpochRequest"));
424 }
425 msg__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| coordinate_request::Msg::AlignInitialEpochRequest(x.0));
426 }
427 }
428 }
429 Ok(CoordinateRequest {
430 msg: msg__,
431 })
432 }
433 }
434 deserializer.deserialize_struct("connector_service.CoordinateRequest", FIELDS, GeneratedVisitor)
435 }
436}
437impl serde::Serialize for coordinate_request::CommitRequest {
438 #[allow(deprecated)]
439 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
440 where
441 S: serde::Serializer,
442 {
443 use serde::ser::SerializeStruct;
444 let mut len = 0;
445 if self.epoch != 0 {
446 len += 1;
447 }
448 if self.metadata.is_some() {
449 len += 1;
450 }
451 if self.schema_change.is_some() {
452 len += 1;
453 }
454 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateRequest.CommitRequest", len)?;
455 if self.epoch != 0 {
456 #[allow(clippy::needless_borrow)]
457 #[allow(clippy::needless_borrows_for_generic_args)]
458 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
459 }
460 if let Some(v) = self.metadata.as_ref() {
461 struct_ser.serialize_field("metadata", v)?;
462 }
463 if let Some(v) = self.schema_change.as_ref() {
464 struct_ser.serialize_field("schemaChange", v)?;
465 }
466 struct_ser.end()
467 }
468}
469impl<'de> serde::Deserialize<'de> for coordinate_request::CommitRequest {
470 #[allow(deprecated)]
471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
472 where
473 D: serde::Deserializer<'de>,
474 {
475 const FIELDS: &[&str] = &[
476 "epoch",
477 "metadata",
478 "schema_change",
479 "schemaChange",
480 ];
481
482 #[allow(clippy::enum_variant_names)]
483 enum GeneratedField {
484 Epoch,
485 Metadata,
486 SchemaChange,
487 }
488 impl<'de> serde::Deserialize<'de> for GeneratedField {
489 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
490 where
491 D: serde::Deserializer<'de>,
492 {
493 struct GeneratedVisitor;
494
495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
496 type Value = GeneratedField;
497
498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
499 write!(formatter, "expected one of: {:?}", &FIELDS)
500 }
501
502 #[allow(unused_variables)]
503 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
504 where
505 E: serde::de::Error,
506 {
507 match value {
508 "epoch" => Ok(GeneratedField::Epoch),
509 "metadata" => Ok(GeneratedField::Metadata),
510 "schemaChange" | "schema_change" => Ok(GeneratedField::SchemaChange),
511 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
512 }
513 }
514 }
515 deserializer.deserialize_identifier(GeneratedVisitor)
516 }
517 }
518 struct GeneratedVisitor;
519 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
520 type Value = coordinate_request::CommitRequest;
521
522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
523 formatter.write_str("struct connector_service.CoordinateRequest.CommitRequest")
524 }
525
526 fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_request::CommitRequest, V::Error>
527 where
528 V: serde::de::MapAccess<'de>,
529 {
530 let mut epoch__ = None;
531 let mut metadata__ = None;
532 let mut schema_change__ = None;
533 while let Some(k) = map_.next_key()? {
534 match k {
535 GeneratedField::Epoch => {
536 if epoch__.is_some() {
537 return Err(serde::de::Error::duplicate_field("epoch"));
538 }
539 epoch__ =
540 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
541 ;
542 }
543 GeneratedField::Metadata => {
544 if metadata__.is_some() {
545 return Err(serde::de::Error::duplicate_field("metadata"));
546 }
547 metadata__ = map_.next_value()?;
548 }
549 GeneratedField::SchemaChange => {
550 if schema_change__.is_some() {
551 return Err(serde::de::Error::duplicate_field("schemaChange"));
552 }
553 schema_change__ = map_.next_value()?;
554 }
555 }
556 }
557 Ok(coordinate_request::CommitRequest {
558 epoch: epoch__.unwrap_or_default(),
559 metadata: metadata__,
560 schema_change: schema_change__,
561 })
562 }
563 }
564 deserializer.deserialize_struct("connector_service.CoordinateRequest.CommitRequest", FIELDS, GeneratedVisitor)
565 }
566}
567impl serde::Serialize for coordinate_request::StartCoordinationRequest {
568 #[allow(deprecated)]
569 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
570 where
571 S: serde::Serializer,
572 {
573 use serde::ser::SerializeStruct;
574 let mut len = 0;
575 if self.vnode_bitmap.is_some() {
576 len += 1;
577 }
578 if self.param.is_some() {
579 len += 1;
580 }
581 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateRequest.StartCoordinationRequest", len)?;
582 if let Some(v) = self.vnode_bitmap.as_ref() {
583 struct_ser.serialize_field("vnodeBitmap", v)?;
584 }
585 if let Some(v) = self.param.as_ref() {
586 struct_ser.serialize_field("param", v)?;
587 }
588 struct_ser.end()
589 }
590}
591impl<'de> serde::Deserialize<'de> for coordinate_request::StartCoordinationRequest {
592 #[allow(deprecated)]
593 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
594 where
595 D: serde::Deserializer<'de>,
596 {
597 const FIELDS: &[&str] = &[
598 "vnode_bitmap",
599 "vnodeBitmap",
600 "param",
601 ];
602
603 #[allow(clippy::enum_variant_names)]
604 enum GeneratedField {
605 VnodeBitmap,
606 Param,
607 }
608 impl<'de> serde::Deserialize<'de> for GeneratedField {
609 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
610 where
611 D: serde::Deserializer<'de>,
612 {
613 struct GeneratedVisitor;
614
615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
616 type Value = GeneratedField;
617
618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
619 write!(formatter, "expected one of: {:?}", &FIELDS)
620 }
621
622 #[allow(unused_variables)]
623 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
624 where
625 E: serde::de::Error,
626 {
627 match value {
628 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
629 "param" => Ok(GeneratedField::Param),
630 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
631 }
632 }
633 }
634 deserializer.deserialize_identifier(GeneratedVisitor)
635 }
636 }
637 struct GeneratedVisitor;
638 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
639 type Value = coordinate_request::StartCoordinationRequest;
640
641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
642 formatter.write_str("struct connector_service.CoordinateRequest.StartCoordinationRequest")
643 }
644
645 fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_request::StartCoordinationRequest, V::Error>
646 where
647 V: serde::de::MapAccess<'de>,
648 {
649 let mut vnode_bitmap__ = None;
650 let mut param__ = None;
651 while let Some(k) = map_.next_key()? {
652 match k {
653 GeneratedField::VnodeBitmap => {
654 if vnode_bitmap__.is_some() {
655 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
656 }
657 vnode_bitmap__ = map_.next_value()?;
658 }
659 GeneratedField::Param => {
660 if param__.is_some() {
661 return Err(serde::de::Error::duplicate_field("param"));
662 }
663 param__ = map_.next_value()?;
664 }
665 }
666 }
667 Ok(coordinate_request::StartCoordinationRequest {
668 vnode_bitmap: vnode_bitmap__,
669 param: param__,
670 })
671 }
672 }
673 deserializer.deserialize_struct("connector_service.CoordinateRequest.StartCoordinationRequest", FIELDS, GeneratedVisitor)
674 }
675}
676impl serde::Serialize for coordinate_request::UpdateVnodeBitmapRequest {
677 #[allow(deprecated)]
678 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
679 where
680 S: serde::Serializer,
681 {
682 use serde::ser::SerializeStruct;
683 let mut len = 0;
684 if self.vnode_bitmap.is_some() {
685 len += 1;
686 }
687 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateRequest.UpdateVnodeBitmapRequest", len)?;
688 if let Some(v) = self.vnode_bitmap.as_ref() {
689 struct_ser.serialize_field("vnodeBitmap", v)?;
690 }
691 struct_ser.end()
692 }
693}
694impl<'de> serde::Deserialize<'de> for coordinate_request::UpdateVnodeBitmapRequest {
695 #[allow(deprecated)]
696 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
697 where
698 D: serde::Deserializer<'de>,
699 {
700 const FIELDS: &[&str] = &[
701 "vnode_bitmap",
702 "vnodeBitmap",
703 ];
704
705 #[allow(clippy::enum_variant_names)]
706 enum GeneratedField {
707 VnodeBitmap,
708 }
709 impl<'de> serde::Deserialize<'de> for GeneratedField {
710 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
711 where
712 D: serde::Deserializer<'de>,
713 {
714 struct GeneratedVisitor;
715
716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
717 type Value = GeneratedField;
718
719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
720 write!(formatter, "expected one of: {:?}", &FIELDS)
721 }
722
723 #[allow(unused_variables)]
724 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
725 where
726 E: serde::de::Error,
727 {
728 match value {
729 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
730 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
731 }
732 }
733 }
734 deserializer.deserialize_identifier(GeneratedVisitor)
735 }
736 }
737 struct GeneratedVisitor;
738 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
739 type Value = coordinate_request::UpdateVnodeBitmapRequest;
740
741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
742 formatter.write_str("struct connector_service.CoordinateRequest.UpdateVnodeBitmapRequest")
743 }
744
745 fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_request::UpdateVnodeBitmapRequest, V::Error>
746 where
747 V: serde::de::MapAccess<'de>,
748 {
749 let mut vnode_bitmap__ = None;
750 while let Some(k) = map_.next_key()? {
751 match k {
752 GeneratedField::VnodeBitmap => {
753 if vnode_bitmap__.is_some() {
754 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
755 }
756 vnode_bitmap__ = map_.next_value()?;
757 }
758 }
759 }
760 Ok(coordinate_request::UpdateVnodeBitmapRequest {
761 vnode_bitmap: vnode_bitmap__,
762 })
763 }
764 }
765 deserializer.deserialize_struct("connector_service.CoordinateRequest.UpdateVnodeBitmapRequest", FIELDS, GeneratedVisitor)
766 }
767}
768impl serde::Serialize for CoordinateResponse {
769 #[allow(deprecated)]
770 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
771 where
772 S: serde::Serializer,
773 {
774 use serde::ser::SerializeStruct;
775 let mut len = 0;
776 if self.msg.is_some() {
777 len += 1;
778 }
779 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateResponse", len)?;
780 if let Some(v) = self.msg.as_ref() {
781 match v {
782 coordinate_response::Msg::StartResponse(v) => {
783 struct_ser.serialize_field("startResponse", v)?;
784 }
785 coordinate_response::Msg::CommitResponse(v) => {
786 struct_ser.serialize_field("commitResponse", v)?;
787 }
788 coordinate_response::Msg::Stopped(v) => {
789 struct_ser.serialize_field("stopped", v)?;
790 }
791 coordinate_response::Msg::AlignInitialEpochResponse(v) => {
792 #[allow(clippy::needless_borrow)]
793 #[allow(clippy::needless_borrows_for_generic_args)]
794 struct_ser.serialize_field("alignInitialEpochResponse", ToString::to_string(&v).as_str())?;
795 }
796 }
797 }
798 struct_ser.end()
799 }
800}
801impl<'de> serde::Deserialize<'de> for CoordinateResponse {
802 #[allow(deprecated)]
803 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
804 where
805 D: serde::Deserializer<'de>,
806 {
807 const FIELDS: &[&str] = &[
808 "start_response",
809 "startResponse",
810 "commit_response",
811 "commitResponse",
812 "stopped",
813 "align_initial_epoch_response",
814 "alignInitialEpochResponse",
815 ];
816
817 #[allow(clippy::enum_variant_names)]
818 enum GeneratedField {
819 StartResponse,
820 CommitResponse,
821 Stopped,
822 AlignInitialEpochResponse,
823 }
824 impl<'de> serde::Deserialize<'de> for GeneratedField {
825 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
826 where
827 D: serde::Deserializer<'de>,
828 {
829 struct GeneratedVisitor;
830
831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
832 type Value = GeneratedField;
833
834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
835 write!(formatter, "expected one of: {:?}", &FIELDS)
836 }
837
838 #[allow(unused_variables)]
839 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
840 where
841 E: serde::de::Error,
842 {
843 match value {
844 "startResponse" | "start_response" => Ok(GeneratedField::StartResponse),
845 "commitResponse" | "commit_response" => Ok(GeneratedField::CommitResponse),
846 "stopped" => Ok(GeneratedField::Stopped),
847 "alignInitialEpochResponse" | "align_initial_epoch_response" => Ok(GeneratedField::AlignInitialEpochResponse),
848 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
849 }
850 }
851 }
852 deserializer.deserialize_identifier(GeneratedVisitor)
853 }
854 }
855 struct GeneratedVisitor;
856 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
857 type Value = CoordinateResponse;
858
859 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
860 formatter.write_str("struct connector_service.CoordinateResponse")
861 }
862
863 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CoordinateResponse, V::Error>
864 where
865 V: serde::de::MapAccess<'de>,
866 {
867 let mut msg__ = None;
868 while let Some(k) = map_.next_key()? {
869 match k {
870 GeneratedField::StartResponse => {
871 if msg__.is_some() {
872 return Err(serde::de::Error::duplicate_field("startResponse"));
873 }
874 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_response::Msg::StartResponse)
875;
876 }
877 GeneratedField::CommitResponse => {
878 if msg__.is_some() {
879 return Err(serde::de::Error::duplicate_field("commitResponse"));
880 }
881 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_response::Msg::CommitResponse)
882;
883 }
884 GeneratedField::Stopped => {
885 if msg__.is_some() {
886 return Err(serde::de::Error::duplicate_field("stopped"));
887 }
888 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_response::Msg::Stopped);
889 }
890 GeneratedField::AlignInitialEpochResponse => {
891 if msg__.is_some() {
892 return Err(serde::de::Error::duplicate_field("alignInitialEpochResponse"));
893 }
894 msg__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| coordinate_response::Msg::AlignInitialEpochResponse(x.0));
895 }
896 }
897 }
898 Ok(CoordinateResponse {
899 msg: msg__,
900 })
901 }
902 }
903 deserializer.deserialize_struct("connector_service.CoordinateResponse", FIELDS, GeneratedVisitor)
904 }
905}
906impl serde::Serialize for coordinate_response::CommitResponse {
907 #[allow(deprecated)]
908 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
909 where
910 S: serde::Serializer,
911 {
912 use serde::ser::SerializeStruct;
913 let mut len = 0;
914 if self.epoch != 0 {
915 len += 1;
916 }
917 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateResponse.CommitResponse", len)?;
918 if self.epoch != 0 {
919 #[allow(clippy::needless_borrow)]
920 #[allow(clippy::needless_borrows_for_generic_args)]
921 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
922 }
923 struct_ser.end()
924 }
925}
926impl<'de> serde::Deserialize<'de> for coordinate_response::CommitResponse {
927 #[allow(deprecated)]
928 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
929 where
930 D: serde::Deserializer<'de>,
931 {
932 const FIELDS: &[&str] = &[
933 "epoch",
934 ];
935
936 #[allow(clippy::enum_variant_names)]
937 enum GeneratedField {
938 Epoch,
939 }
940 impl<'de> serde::Deserialize<'de> for GeneratedField {
941 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
942 where
943 D: serde::Deserializer<'de>,
944 {
945 struct GeneratedVisitor;
946
947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
948 type Value = GeneratedField;
949
950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
951 write!(formatter, "expected one of: {:?}", &FIELDS)
952 }
953
954 #[allow(unused_variables)]
955 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
956 where
957 E: serde::de::Error,
958 {
959 match value {
960 "epoch" => Ok(GeneratedField::Epoch),
961 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
962 }
963 }
964 }
965 deserializer.deserialize_identifier(GeneratedVisitor)
966 }
967 }
968 struct GeneratedVisitor;
969 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
970 type Value = coordinate_response::CommitResponse;
971
972 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
973 formatter.write_str("struct connector_service.CoordinateResponse.CommitResponse")
974 }
975
976 fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_response::CommitResponse, V::Error>
977 where
978 V: serde::de::MapAccess<'de>,
979 {
980 let mut epoch__ = None;
981 while let Some(k) = map_.next_key()? {
982 match k {
983 GeneratedField::Epoch => {
984 if epoch__.is_some() {
985 return Err(serde::de::Error::duplicate_field("epoch"));
986 }
987 epoch__ =
988 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
989 ;
990 }
991 }
992 }
993 Ok(coordinate_response::CommitResponse {
994 epoch: epoch__.unwrap_or_default(),
995 })
996 }
997 }
998 deserializer.deserialize_struct("connector_service.CoordinateResponse.CommitResponse", FIELDS, GeneratedVisitor)
999 }
1000}
1001impl serde::Serialize for coordinate_response::StartCoordinationResponse {
1002 #[allow(deprecated)]
1003 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1004 where
1005 S: serde::Serializer,
1006 {
1007 use serde::ser::SerializeStruct;
1008 let mut len = 0;
1009 if self.log_store_rewind_start_epoch.is_some() {
1010 len += 1;
1011 }
1012 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateResponse.StartCoordinationResponse", len)?;
1013 if let Some(v) = self.log_store_rewind_start_epoch.as_ref() {
1014 #[allow(clippy::needless_borrow)]
1015 #[allow(clippy::needless_borrows_for_generic_args)]
1016 struct_ser.serialize_field("logStoreRewindStartEpoch", ToString::to_string(&v).as_str())?;
1017 }
1018 struct_ser.end()
1019 }
1020}
1021impl<'de> serde::Deserialize<'de> for coordinate_response::StartCoordinationResponse {
1022 #[allow(deprecated)]
1023 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1024 where
1025 D: serde::Deserializer<'de>,
1026 {
1027 const FIELDS: &[&str] = &[
1028 "log_store_rewind_start_epoch",
1029 "logStoreRewindStartEpoch",
1030 ];
1031
1032 #[allow(clippy::enum_variant_names)]
1033 enum GeneratedField {
1034 LogStoreRewindStartEpoch,
1035 }
1036 impl<'de> serde::Deserialize<'de> for GeneratedField {
1037 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1038 where
1039 D: serde::Deserializer<'de>,
1040 {
1041 struct GeneratedVisitor;
1042
1043 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1044 type Value = GeneratedField;
1045
1046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1047 write!(formatter, "expected one of: {:?}", &FIELDS)
1048 }
1049
1050 #[allow(unused_variables)]
1051 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1052 where
1053 E: serde::de::Error,
1054 {
1055 match value {
1056 "logStoreRewindStartEpoch" | "log_store_rewind_start_epoch" => Ok(GeneratedField::LogStoreRewindStartEpoch),
1057 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1058 }
1059 }
1060 }
1061 deserializer.deserialize_identifier(GeneratedVisitor)
1062 }
1063 }
1064 struct GeneratedVisitor;
1065 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1066 type Value = coordinate_response::StartCoordinationResponse;
1067
1068 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1069 formatter.write_str("struct connector_service.CoordinateResponse.StartCoordinationResponse")
1070 }
1071
1072 fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_response::StartCoordinationResponse, V::Error>
1073 where
1074 V: serde::de::MapAccess<'de>,
1075 {
1076 let mut log_store_rewind_start_epoch__ = None;
1077 while let Some(k) = map_.next_key()? {
1078 match k {
1079 GeneratedField::LogStoreRewindStartEpoch => {
1080 if log_store_rewind_start_epoch__.is_some() {
1081 return Err(serde::de::Error::duplicate_field("logStoreRewindStartEpoch"));
1082 }
1083 log_store_rewind_start_epoch__ =
1084 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1085 ;
1086 }
1087 }
1088 }
1089 Ok(coordinate_response::StartCoordinationResponse {
1090 log_store_rewind_start_epoch: log_store_rewind_start_epoch__,
1091 })
1092 }
1093 }
1094 deserializer.deserialize_struct("connector_service.CoordinateResponse.StartCoordinationResponse", FIELDS, GeneratedVisitor)
1095 }
1096}
1097impl serde::Serialize for GetEventStreamRequest {
1098 #[allow(deprecated)]
1099 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1100 where
1101 S: serde::Serializer,
1102 {
1103 use serde::ser::SerializeStruct;
1104 let mut len = 0;
1105 if self.source_id != 0 {
1106 len += 1;
1107 }
1108 if self.source_type != 0 {
1109 len += 1;
1110 }
1111 if !self.start_offset.is_empty() {
1112 len += 1;
1113 }
1114 if !self.properties.is_empty() {
1115 len += 1;
1116 }
1117 if self.snapshot_done {
1118 len += 1;
1119 }
1120 if self.is_source_job {
1121 len += 1;
1122 }
1123 let mut struct_ser = serializer.serialize_struct("connector_service.GetEventStreamRequest", len)?;
1124 if self.source_id != 0 {
1125 #[allow(clippy::needless_borrow)]
1126 #[allow(clippy::needless_borrows_for_generic_args)]
1127 struct_ser.serialize_field("sourceId", ToString::to_string(&self.source_id).as_str())?;
1128 }
1129 if self.source_type != 0 {
1130 let v = SourceType::try_from(self.source_type)
1131 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.source_type)))?;
1132 struct_ser.serialize_field("sourceType", &v)?;
1133 }
1134 if !self.start_offset.is_empty() {
1135 struct_ser.serialize_field("startOffset", &self.start_offset)?;
1136 }
1137 if !self.properties.is_empty() {
1138 struct_ser.serialize_field("properties", &self.properties)?;
1139 }
1140 if self.snapshot_done {
1141 struct_ser.serialize_field("snapshotDone", &self.snapshot_done)?;
1142 }
1143 if self.is_source_job {
1144 struct_ser.serialize_field("isSourceJob", &self.is_source_job)?;
1145 }
1146 struct_ser.end()
1147 }
1148}
1149impl<'de> serde::Deserialize<'de> for GetEventStreamRequest {
1150 #[allow(deprecated)]
1151 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1152 where
1153 D: serde::Deserializer<'de>,
1154 {
1155 const FIELDS: &[&str] = &[
1156 "source_id",
1157 "sourceId",
1158 "source_type",
1159 "sourceType",
1160 "start_offset",
1161 "startOffset",
1162 "properties",
1163 "snapshot_done",
1164 "snapshotDone",
1165 "is_source_job",
1166 "isSourceJob",
1167 ];
1168
1169 #[allow(clippy::enum_variant_names)]
1170 enum GeneratedField {
1171 SourceId,
1172 SourceType,
1173 StartOffset,
1174 Properties,
1175 SnapshotDone,
1176 IsSourceJob,
1177 }
1178 impl<'de> serde::Deserialize<'de> for GeneratedField {
1179 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1180 where
1181 D: serde::Deserializer<'de>,
1182 {
1183 struct GeneratedVisitor;
1184
1185 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1186 type Value = GeneratedField;
1187
1188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1189 write!(formatter, "expected one of: {:?}", &FIELDS)
1190 }
1191
1192 #[allow(unused_variables)]
1193 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1194 where
1195 E: serde::de::Error,
1196 {
1197 match value {
1198 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1199 "sourceType" | "source_type" => Ok(GeneratedField::SourceType),
1200 "startOffset" | "start_offset" => Ok(GeneratedField::StartOffset),
1201 "properties" => Ok(GeneratedField::Properties),
1202 "snapshotDone" | "snapshot_done" => Ok(GeneratedField::SnapshotDone),
1203 "isSourceJob" | "is_source_job" => Ok(GeneratedField::IsSourceJob),
1204 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1205 }
1206 }
1207 }
1208 deserializer.deserialize_identifier(GeneratedVisitor)
1209 }
1210 }
1211 struct GeneratedVisitor;
1212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1213 type Value = GetEventStreamRequest;
1214
1215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1216 formatter.write_str("struct connector_service.GetEventStreamRequest")
1217 }
1218
1219 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetEventStreamRequest, V::Error>
1220 where
1221 V: serde::de::MapAccess<'de>,
1222 {
1223 let mut source_id__ = None;
1224 let mut source_type__ = None;
1225 let mut start_offset__ = None;
1226 let mut properties__ = None;
1227 let mut snapshot_done__ = None;
1228 let mut is_source_job__ = None;
1229 while let Some(k) = map_.next_key()? {
1230 match k {
1231 GeneratedField::SourceId => {
1232 if source_id__.is_some() {
1233 return Err(serde::de::Error::duplicate_field("sourceId"));
1234 }
1235 source_id__ =
1236 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1237 ;
1238 }
1239 GeneratedField::SourceType => {
1240 if source_type__.is_some() {
1241 return Err(serde::de::Error::duplicate_field("sourceType"));
1242 }
1243 source_type__ = Some(map_.next_value::<SourceType>()? as i32);
1244 }
1245 GeneratedField::StartOffset => {
1246 if start_offset__.is_some() {
1247 return Err(serde::de::Error::duplicate_field("startOffset"));
1248 }
1249 start_offset__ = Some(map_.next_value()?);
1250 }
1251 GeneratedField::Properties => {
1252 if properties__.is_some() {
1253 return Err(serde::de::Error::duplicate_field("properties"));
1254 }
1255 properties__ = Some(
1256 map_.next_value::<std::collections::BTreeMap<_, _>>()?
1257 );
1258 }
1259 GeneratedField::SnapshotDone => {
1260 if snapshot_done__.is_some() {
1261 return Err(serde::de::Error::duplicate_field("snapshotDone"));
1262 }
1263 snapshot_done__ = Some(map_.next_value()?);
1264 }
1265 GeneratedField::IsSourceJob => {
1266 if is_source_job__.is_some() {
1267 return Err(serde::de::Error::duplicate_field("isSourceJob"));
1268 }
1269 is_source_job__ = Some(map_.next_value()?);
1270 }
1271 }
1272 }
1273 Ok(GetEventStreamRequest {
1274 source_id: source_id__.unwrap_or_default(),
1275 source_type: source_type__.unwrap_or_default(),
1276 start_offset: start_offset__.unwrap_or_default(),
1277 properties: properties__.unwrap_or_default(),
1278 snapshot_done: snapshot_done__.unwrap_or_default(),
1279 is_source_job: is_source_job__.unwrap_or_default(),
1280 })
1281 }
1282 }
1283 deserializer.deserialize_struct("connector_service.GetEventStreamRequest", FIELDS, GeneratedVisitor)
1284 }
1285}
1286impl serde::Serialize for GetEventStreamResponse {
1287 #[allow(deprecated)]
1288 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1289 where
1290 S: serde::Serializer,
1291 {
1292 use serde::ser::SerializeStruct;
1293 let mut len = 0;
1294 if self.source_id != 0 {
1295 len += 1;
1296 }
1297 if !self.events.is_empty() {
1298 len += 1;
1299 }
1300 if self.control.is_some() {
1301 len += 1;
1302 }
1303 let mut struct_ser = serializer.serialize_struct("connector_service.GetEventStreamResponse", len)?;
1304 if self.source_id != 0 {
1305 #[allow(clippy::needless_borrow)]
1306 #[allow(clippy::needless_borrows_for_generic_args)]
1307 struct_ser.serialize_field("sourceId", ToString::to_string(&self.source_id).as_str())?;
1308 }
1309 if !self.events.is_empty() {
1310 struct_ser.serialize_field("events", &self.events)?;
1311 }
1312 if let Some(v) = self.control.as_ref() {
1313 struct_ser.serialize_field("control", v)?;
1314 }
1315 struct_ser.end()
1316 }
1317}
1318impl<'de> serde::Deserialize<'de> for GetEventStreamResponse {
1319 #[allow(deprecated)]
1320 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1321 where
1322 D: serde::Deserializer<'de>,
1323 {
1324 const FIELDS: &[&str] = &[
1325 "source_id",
1326 "sourceId",
1327 "events",
1328 "control",
1329 ];
1330
1331 #[allow(clippy::enum_variant_names)]
1332 enum GeneratedField {
1333 SourceId,
1334 Events,
1335 Control,
1336 }
1337 impl<'de> serde::Deserialize<'de> for GeneratedField {
1338 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1339 where
1340 D: serde::Deserializer<'de>,
1341 {
1342 struct GeneratedVisitor;
1343
1344 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1345 type Value = GeneratedField;
1346
1347 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1348 write!(formatter, "expected one of: {:?}", &FIELDS)
1349 }
1350
1351 #[allow(unused_variables)]
1352 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1353 where
1354 E: serde::de::Error,
1355 {
1356 match value {
1357 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1358 "events" => Ok(GeneratedField::Events),
1359 "control" => Ok(GeneratedField::Control),
1360 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1361 }
1362 }
1363 }
1364 deserializer.deserialize_identifier(GeneratedVisitor)
1365 }
1366 }
1367 struct GeneratedVisitor;
1368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1369 type Value = GetEventStreamResponse;
1370
1371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1372 formatter.write_str("struct connector_service.GetEventStreamResponse")
1373 }
1374
1375 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetEventStreamResponse, V::Error>
1376 where
1377 V: serde::de::MapAccess<'de>,
1378 {
1379 let mut source_id__ = None;
1380 let mut events__ = None;
1381 let mut control__ = None;
1382 while let Some(k) = map_.next_key()? {
1383 match k {
1384 GeneratedField::SourceId => {
1385 if source_id__.is_some() {
1386 return Err(serde::de::Error::duplicate_field("sourceId"));
1387 }
1388 source_id__ =
1389 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1390 ;
1391 }
1392 GeneratedField::Events => {
1393 if events__.is_some() {
1394 return Err(serde::de::Error::duplicate_field("events"));
1395 }
1396 events__ = Some(map_.next_value()?);
1397 }
1398 GeneratedField::Control => {
1399 if control__.is_some() {
1400 return Err(serde::de::Error::duplicate_field("control"));
1401 }
1402 control__ = map_.next_value()?;
1403 }
1404 }
1405 }
1406 Ok(GetEventStreamResponse {
1407 source_id: source_id__.unwrap_or_default(),
1408 events: events__.unwrap_or_default(),
1409 control: control__,
1410 })
1411 }
1412 }
1413 deserializer.deserialize_struct("connector_service.GetEventStreamResponse", FIELDS, GeneratedVisitor)
1414 }
1415}
1416impl serde::Serialize for get_event_stream_response::ControlInfo {
1417 #[allow(deprecated)]
1418 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1419 where
1420 S: serde::Serializer,
1421 {
1422 use serde::ser::SerializeStruct;
1423 let mut len = 0;
1424 if self.handshake_ok {
1425 len += 1;
1426 }
1427 let mut struct_ser = serializer.serialize_struct("connector_service.GetEventStreamResponse.ControlInfo", len)?;
1428 if self.handshake_ok {
1429 struct_ser.serialize_field("handshakeOk", &self.handshake_ok)?;
1430 }
1431 struct_ser.end()
1432 }
1433}
1434impl<'de> serde::Deserialize<'de> for get_event_stream_response::ControlInfo {
1435 #[allow(deprecated)]
1436 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1437 where
1438 D: serde::Deserializer<'de>,
1439 {
1440 const FIELDS: &[&str] = &[
1441 "handshake_ok",
1442 "handshakeOk",
1443 ];
1444
1445 #[allow(clippy::enum_variant_names)]
1446 enum GeneratedField {
1447 HandshakeOk,
1448 }
1449 impl<'de> serde::Deserialize<'de> for GeneratedField {
1450 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1451 where
1452 D: serde::Deserializer<'de>,
1453 {
1454 struct GeneratedVisitor;
1455
1456 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1457 type Value = GeneratedField;
1458
1459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1460 write!(formatter, "expected one of: {:?}", &FIELDS)
1461 }
1462
1463 #[allow(unused_variables)]
1464 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1465 where
1466 E: serde::de::Error,
1467 {
1468 match value {
1469 "handshakeOk" | "handshake_ok" => Ok(GeneratedField::HandshakeOk),
1470 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1471 }
1472 }
1473 }
1474 deserializer.deserialize_identifier(GeneratedVisitor)
1475 }
1476 }
1477 struct GeneratedVisitor;
1478 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1479 type Value = get_event_stream_response::ControlInfo;
1480
1481 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1482 formatter.write_str("struct connector_service.GetEventStreamResponse.ControlInfo")
1483 }
1484
1485 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_event_stream_response::ControlInfo, V::Error>
1486 where
1487 V: serde::de::MapAccess<'de>,
1488 {
1489 let mut handshake_ok__ = None;
1490 while let Some(k) = map_.next_key()? {
1491 match k {
1492 GeneratedField::HandshakeOk => {
1493 if handshake_ok__.is_some() {
1494 return Err(serde::de::Error::duplicate_field("handshakeOk"));
1495 }
1496 handshake_ok__ = Some(map_.next_value()?);
1497 }
1498 }
1499 }
1500 Ok(get_event_stream_response::ControlInfo {
1501 handshake_ok: handshake_ok__.unwrap_or_default(),
1502 })
1503 }
1504 }
1505 deserializer.deserialize_struct("connector_service.GetEventStreamResponse.ControlInfo", FIELDS, GeneratedVisitor)
1506 }
1507}
1508impl serde::Serialize for SinkCoordinatorStreamRequest {
1509 #[allow(deprecated)]
1510 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1511 where
1512 S: serde::Serializer,
1513 {
1514 use serde::ser::SerializeStruct;
1515 let mut len = 0;
1516 if self.request.is_some() {
1517 len += 1;
1518 }
1519 let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamRequest", len)?;
1520 if let Some(v) = self.request.as_ref() {
1521 match v {
1522 sink_coordinator_stream_request::Request::Start(v) => {
1523 struct_ser.serialize_field("start", v)?;
1524 }
1525 sink_coordinator_stream_request::Request::Commit(v) => {
1526 struct_ser.serialize_field("commit", v)?;
1527 }
1528 }
1529 }
1530 struct_ser.end()
1531 }
1532}
1533impl<'de> serde::Deserialize<'de> for SinkCoordinatorStreamRequest {
1534 #[allow(deprecated)]
1535 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1536 where
1537 D: serde::Deserializer<'de>,
1538 {
1539 const FIELDS: &[&str] = &[
1540 "start",
1541 "commit",
1542 ];
1543
1544 #[allow(clippy::enum_variant_names)]
1545 enum GeneratedField {
1546 Start,
1547 Commit,
1548 }
1549 impl<'de> serde::Deserialize<'de> for GeneratedField {
1550 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1551 where
1552 D: serde::Deserializer<'de>,
1553 {
1554 struct GeneratedVisitor;
1555
1556 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1557 type Value = GeneratedField;
1558
1559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1560 write!(formatter, "expected one of: {:?}", &FIELDS)
1561 }
1562
1563 #[allow(unused_variables)]
1564 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1565 where
1566 E: serde::de::Error,
1567 {
1568 match value {
1569 "start" => Ok(GeneratedField::Start),
1570 "commit" => Ok(GeneratedField::Commit),
1571 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1572 }
1573 }
1574 }
1575 deserializer.deserialize_identifier(GeneratedVisitor)
1576 }
1577 }
1578 struct GeneratedVisitor;
1579 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1580 type Value = SinkCoordinatorStreamRequest;
1581
1582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1583 formatter.write_str("struct connector_service.SinkCoordinatorStreamRequest")
1584 }
1585
1586 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkCoordinatorStreamRequest, V::Error>
1587 where
1588 V: serde::de::MapAccess<'de>,
1589 {
1590 let mut request__ = None;
1591 while let Some(k) = map_.next_key()? {
1592 match k {
1593 GeneratedField::Start => {
1594 if request__.is_some() {
1595 return Err(serde::de::Error::duplicate_field("start"));
1596 }
1597 request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_coordinator_stream_request::Request::Start)
1598;
1599 }
1600 GeneratedField::Commit => {
1601 if request__.is_some() {
1602 return Err(serde::de::Error::duplicate_field("commit"));
1603 }
1604 request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_coordinator_stream_request::Request::Commit)
1605;
1606 }
1607 }
1608 }
1609 Ok(SinkCoordinatorStreamRequest {
1610 request: request__,
1611 })
1612 }
1613 }
1614 deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamRequest", FIELDS, GeneratedVisitor)
1615 }
1616}
1617impl serde::Serialize for sink_coordinator_stream_request::CommitMetadata {
1618 #[allow(deprecated)]
1619 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1620 where
1621 S: serde::Serializer,
1622 {
1623 use serde::ser::SerializeStruct;
1624 let mut len = 0;
1625 if self.epoch != 0 {
1626 len += 1;
1627 }
1628 if !self.metadata.is_empty() {
1629 len += 1;
1630 }
1631 let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamRequest.CommitMetadata", len)?;
1632 if self.epoch != 0 {
1633 #[allow(clippy::needless_borrow)]
1634 #[allow(clippy::needless_borrows_for_generic_args)]
1635 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
1636 }
1637 if !self.metadata.is_empty() {
1638 struct_ser.serialize_field("metadata", &self.metadata)?;
1639 }
1640 struct_ser.end()
1641 }
1642}
1643impl<'de> serde::Deserialize<'de> for sink_coordinator_stream_request::CommitMetadata {
1644 #[allow(deprecated)]
1645 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1646 where
1647 D: serde::Deserializer<'de>,
1648 {
1649 const FIELDS: &[&str] = &[
1650 "epoch",
1651 "metadata",
1652 ];
1653
1654 #[allow(clippy::enum_variant_names)]
1655 enum GeneratedField {
1656 Epoch,
1657 Metadata,
1658 }
1659 impl<'de> serde::Deserialize<'de> for GeneratedField {
1660 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1661 where
1662 D: serde::Deserializer<'de>,
1663 {
1664 struct GeneratedVisitor;
1665
1666 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1667 type Value = GeneratedField;
1668
1669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1670 write!(formatter, "expected one of: {:?}", &FIELDS)
1671 }
1672
1673 #[allow(unused_variables)]
1674 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1675 where
1676 E: serde::de::Error,
1677 {
1678 match value {
1679 "epoch" => Ok(GeneratedField::Epoch),
1680 "metadata" => Ok(GeneratedField::Metadata),
1681 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1682 }
1683 }
1684 }
1685 deserializer.deserialize_identifier(GeneratedVisitor)
1686 }
1687 }
1688 struct GeneratedVisitor;
1689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1690 type Value = sink_coordinator_stream_request::CommitMetadata;
1691
1692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1693 formatter.write_str("struct connector_service.SinkCoordinatorStreamRequest.CommitMetadata")
1694 }
1695
1696 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_coordinator_stream_request::CommitMetadata, V::Error>
1697 where
1698 V: serde::de::MapAccess<'de>,
1699 {
1700 let mut epoch__ = None;
1701 let mut metadata__ = None;
1702 while let Some(k) = map_.next_key()? {
1703 match k {
1704 GeneratedField::Epoch => {
1705 if epoch__.is_some() {
1706 return Err(serde::de::Error::duplicate_field("epoch"));
1707 }
1708 epoch__ =
1709 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1710 ;
1711 }
1712 GeneratedField::Metadata => {
1713 if metadata__.is_some() {
1714 return Err(serde::de::Error::duplicate_field("metadata"));
1715 }
1716 metadata__ = Some(map_.next_value()?);
1717 }
1718 }
1719 }
1720 Ok(sink_coordinator_stream_request::CommitMetadata {
1721 epoch: epoch__.unwrap_or_default(),
1722 metadata: metadata__.unwrap_or_default(),
1723 })
1724 }
1725 }
1726 deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamRequest.CommitMetadata", FIELDS, GeneratedVisitor)
1727 }
1728}
1729impl serde::Serialize for sink_coordinator_stream_request::StartCoordinator {
1730 #[allow(deprecated)]
1731 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1732 where
1733 S: serde::Serializer,
1734 {
1735 use serde::ser::SerializeStruct;
1736 let mut len = 0;
1737 if self.param.is_some() {
1738 len += 1;
1739 }
1740 let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamRequest.StartCoordinator", len)?;
1741 if let Some(v) = self.param.as_ref() {
1742 struct_ser.serialize_field("param", v)?;
1743 }
1744 struct_ser.end()
1745 }
1746}
1747impl<'de> serde::Deserialize<'de> for sink_coordinator_stream_request::StartCoordinator {
1748 #[allow(deprecated)]
1749 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1750 where
1751 D: serde::Deserializer<'de>,
1752 {
1753 const FIELDS: &[&str] = &[
1754 "param",
1755 ];
1756
1757 #[allow(clippy::enum_variant_names)]
1758 enum GeneratedField {
1759 Param,
1760 }
1761 impl<'de> serde::Deserialize<'de> for GeneratedField {
1762 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1763 where
1764 D: serde::Deserializer<'de>,
1765 {
1766 struct GeneratedVisitor;
1767
1768 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1769 type Value = GeneratedField;
1770
1771 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1772 write!(formatter, "expected one of: {:?}", &FIELDS)
1773 }
1774
1775 #[allow(unused_variables)]
1776 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1777 where
1778 E: serde::de::Error,
1779 {
1780 match value {
1781 "param" => Ok(GeneratedField::Param),
1782 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1783 }
1784 }
1785 }
1786 deserializer.deserialize_identifier(GeneratedVisitor)
1787 }
1788 }
1789 struct GeneratedVisitor;
1790 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1791 type Value = sink_coordinator_stream_request::StartCoordinator;
1792
1793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1794 formatter.write_str("struct connector_service.SinkCoordinatorStreamRequest.StartCoordinator")
1795 }
1796
1797 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_coordinator_stream_request::StartCoordinator, V::Error>
1798 where
1799 V: serde::de::MapAccess<'de>,
1800 {
1801 let mut param__ = None;
1802 while let Some(k) = map_.next_key()? {
1803 match k {
1804 GeneratedField::Param => {
1805 if param__.is_some() {
1806 return Err(serde::de::Error::duplicate_field("param"));
1807 }
1808 param__ = map_.next_value()?;
1809 }
1810 }
1811 }
1812 Ok(sink_coordinator_stream_request::StartCoordinator {
1813 param: param__,
1814 })
1815 }
1816 }
1817 deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamRequest.StartCoordinator", FIELDS, GeneratedVisitor)
1818 }
1819}
1820impl serde::Serialize for SinkCoordinatorStreamResponse {
1821 #[allow(deprecated)]
1822 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1823 where
1824 S: serde::Serializer,
1825 {
1826 use serde::ser::SerializeStruct;
1827 let mut len = 0;
1828 if self.response.is_some() {
1829 len += 1;
1830 }
1831 let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamResponse", len)?;
1832 if let Some(v) = self.response.as_ref() {
1833 match v {
1834 sink_coordinator_stream_response::Response::Start(v) => {
1835 struct_ser.serialize_field("start", v)?;
1836 }
1837 sink_coordinator_stream_response::Response::Commit(v) => {
1838 struct_ser.serialize_field("commit", v)?;
1839 }
1840 }
1841 }
1842 struct_ser.end()
1843 }
1844}
1845impl<'de> serde::Deserialize<'de> for SinkCoordinatorStreamResponse {
1846 #[allow(deprecated)]
1847 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1848 where
1849 D: serde::Deserializer<'de>,
1850 {
1851 const FIELDS: &[&str] = &[
1852 "start",
1853 "commit",
1854 ];
1855
1856 #[allow(clippy::enum_variant_names)]
1857 enum GeneratedField {
1858 Start,
1859 Commit,
1860 }
1861 impl<'de> serde::Deserialize<'de> for GeneratedField {
1862 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1863 where
1864 D: serde::Deserializer<'de>,
1865 {
1866 struct GeneratedVisitor;
1867
1868 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1869 type Value = GeneratedField;
1870
1871 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1872 write!(formatter, "expected one of: {:?}", &FIELDS)
1873 }
1874
1875 #[allow(unused_variables)]
1876 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1877 where
1878 E: serde::de::Error,
1879 {
1880 match value {
1881 "start" => Ok(GeneratedField::Start),
1882 "commit" => Ok(GeneratedField::Commit),
1883 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1884 }
1885 }
1886 }
1887 deserializer.deserialize_identifier(GeneratedVisitor)
1888 }
1889 }
1890 struct GeneratedVisitor;
1891 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1892 type Value = SinkCoordinatorStreamResponse;
1893
1894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1895 formatter.write_str("struct connector_service.SinkCoordinatorStreamResponse")
1896 }
1897
1898 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkCoordinatorStreamResponse, V::Error>
1899 where
1900 V: serde::de::MapAccess<'de>,
1901 {
1902 let mut response__ = None;
1903 while let Some(k) = map_.next_key()? {
1904 match k {
1905 GeneratedField::Start => {
1906 if response__.is_some() {
1907 return Err(serde::de::Error::duplicate_field("start"));
1908 }
1909 response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_coordinator_stream_response::Response::Start)
1910;
1911 }
1912 GeneratedField::Commit => {
1913 if response__.is_some() {
1914 return Err(serde::de::Error::duplicate_field("commit"));
1915 }
1916 response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_coordinator_stream_response::Response::Commit)
1917;
1918 }
1919 }
1920 }
1921 Ok(SinkCoordinatorStreamResponse {
1922 response: response__,
1923 })
1924 }
1925 }
1926 deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamResponse", FIELDS, GeneratedVisitor)
1927 }
1928}
1929impl serde::Serialize for sink_coordinator_stream_response::CommitResponse {
1930 #[allow(deprecated)]
1931 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1932 where
1933 S: serde::Serializer,
1934 {
1935 use serde::ser::SerializeStruct;
1936 let mut len = 0;
1937 if self.epoch != 0 {
1938 len += 1;
1939 }
1940 let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamResponse.CommitResponse", len)?;
1941 if self.epoch != 0 {
1942 #[allow(clippy::needless_borrow)]
1943 #[allow(clippy::needless_borrows_for_generic_args)]
1944 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
1945 }
1946 struct_ser.end()
1947 }
1948}
1949impl<'de> serde::Deserialize<'de> for sink_coordinator_stream_response::CommitResponse {
1950 #[allow(deprecated)]
1951 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1952 where
1953 D: serde::Deserializer<'de>,
1954 {
1955 const FIELDS: &[&str] = &[
1956 "epoch",
1957 ];
1958
1959 #[allow(clippy::enum_variant_names)]
1960 enum GeneratedField {
1961 Epoch,
1962 }
1963 impl<'de> serde::Deserialize<'de> for GeneratedField {
1964 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1965 where
1966 D: serde::Deserializer<'de>,
1967 {
1968 struct GeneratedVisitor;
1969
1970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1971 type Value = GeneratedField;
1972
1973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1974 write!(formatter, "expected one of: {:?}", &FIELDS)
1975 }
1976
1977 #[allow(unused_variables)]
1978 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1979 where
1980 E: serde::de::Error,
1981 {
1982 match value {
1983 "epoch" => Ok(GeneratedField::Epoch),
1984 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1985 }
1986 }
1987 }
1988 deserializer.deserialize_identifier(GeneratedVisitor)
1989 }
1990 }
1991 struct GeneratedVisitor;
1992 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1993 type Value = sink_coordinator_stream_response::CommitResponse;
1994
1995 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1996 formatter.write_str("struct connector_service.SinkCoordinatorStreamResponse.CommitResponse")
1997 }
1998
1999 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_coordinator_stream_response::CommitResponse, V::Error>
2000 where
2001 V: serde::de::MapAccess<'de>,
2002 {
2003 let mut epoch__ = None;
2004 while let Some(k) = map_.next_key()? {
2005 match k {
2006 GeneratedField::Epoch => {
2007 if epoch__.is_some() {
2008 return Err(serde::de::Error::duplicate_field("epoch"));
2009 }
2010 epoch__ =
2011 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2012 ;
2013 }
2014 }
2015 }
2016 Ok(sink_coordinator_stream_response::CommitResponse {
2017 epoch: epoch__.unwrap_or_default(),
2018 })
2019 }
2020 }
2021 deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamResponse.CommitResponse", FIELDS, GeneratedVisitor)
2022 }
2023}
2024impl serde::Serialize for sink_coordinator_stream_response::StartResponse {
2025 #[allow(deprecated)]
2026 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2027 where
2028 S: serde::Serializer,
2029 {
2030 use serde::ser::SerializeStruct;
2031 let len = 0;
2032 let struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamResponse.StartResponse", len)?;
2033 struct_ser.end()
2034 }
2035}
2036impl<'de> serde::Deserialize<'de> for sink_coordinator_stream_response::StartResponse {
2037 #[allow(deprecated)]
2038 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2039 where
2040 D: serde::Deserializer<'de>,
2041 {
2042 const FIELDS: &[&str] = &[
2043 ];
2044
2045 #[allow(clippy::enum_variant_names)]
2046 enum GeneratedField {
2047 }
2048 impl<'de> serde::Deserialize<'de> for GeneratedField {
2049 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2050 where
2051 D: serde::Deserializer<'de>,
2052 {
2053 struct GeneratedVisitor;
2054
2055 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2056 type Value = GeneratedField;
2057
2058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2059 write!(formatter, "expected one of: {:?}", &FIELDS)
2060 }
2061
2062 #[allow(unused_variables)]
2063 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2064 where
2065 E: serde::de::Error,
2066 {
2067 Err(serde::de::Error::unknown_field(value, FIELDS))
2068 }
2069 }
2070 deserializer.deserialize_identifier(GeneratedVisitor)
2071 }
2072 }
2073 struct GeneratedVisitor;
2074 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2075 type Value = sink_coordinator_stream_response::StartResponse;
2076
2077 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2078 formatter.write_str("struct connector_service.SinkCoordinatorStreamResponse.StartResponse")
2079 }
2080
2081 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_coordinator_stream_response::StartResponse, V::Error>
2082 where
2083 V: serde::de::MapAccess<'de>,
2084 {
2085 while map_.next_key::<GeneratedField>()?.is_some() {
2086 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2087 }
2088 Ok(sink_coordinator_stream_response::StartResponse {
2089 })
2090 }
2091 }
2092 deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamResponse.StartResponse", FIELDS, GeneratedVisitor)
2093 }
2094}
2095impl serde::Serialize for SinkMetadata {
2096 #[allow(deprecated)]
2097 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2098 where
2099 S: serde::Serializer,
2100 {
2101 use serde::ser::SerializeStruct;
2102 let mut len = 0;
2103 if self.metadata.is_some() {
2104 len += 1;
2105 }
2106 let mut struct_ser = serializer.serialize_struct("connector_service.SinkMetadata", len)?;
2107 if let Some(v) = self.metadata.as_ref() {
2108 match v {
2109 sink_metadata::Metadata::Serialized(v) => {
2110 struct_ser.serialize_field("serialized", v)?;
2111 }
2112 }
2113 }
2114 struct_ser.end()
2115 }
2116}
2117impl<'de> serde::Deserialize<'de> for SinkMetadata {
2118 #[allow(deprecated)]
2119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2120 where
2121 D: serde::Deserializer<'de>,
2122 {
2123 const FIELDS: &[&str] = &[
2124 "serialized",
2125 ];
2126
2127 #[allow(clippy::enum_variant_names)]
2128 enum GeneratedField {
2129 Serialized,
2130 }
2131 impl<'de> serde::Deserialize<'de> for GeneratedField {
2132 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2133 where
2134 D: serde::Deserializer<'de>,
2135 {
2136 struct GeneratedVisitor;
2137
2138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2139 type Value = GeneratedField;
2140
2141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2142 write!(formatter, "expected one of: {:?}", &FIELDS)
2143 }
2144
2145 #[allow(unused_variables)]
2146 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2147 where
2148 E: serde::de::Error,
2149 {
2150 match value {
2151 "serialized" => Ok(GeneratedField::Serialized),
2152 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2153 }
2154 }
2155 }
2156 deserializer.deserialize_identifier(GeneratedVisitor)
2157 }
2158 }
2159 struct GeneratedVisitor;
2160 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2161 type Value = SinkMetadata;
2162
2163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2164 formatter.write_str("struct connector_service.SinkMetadata")
2165 }
2166
2167 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkMetadata, V::Error>
2168 where
2169 V: serde::de::MapAccess<'de>,
2170 {
2171 let mut metadata__ = None;
2172 while let Some(k) = map_.next_key()? {
2173 match k {
2174 GeneratedField::Serialized => {
2175 if metadata__.is_some() {
2176 return Err(serde::de::Error::duplicate_field("serialized"));
2177 }
2178 metadata__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_metadata::Metadata::Serialized)
2179;
2180 }
2181 }
2182 }
2183 Ok(SinkMetadata {
2184 metadata: metadata__,
2185 })
2186 }
2187 }
2188 deserializer.deserialize_struct("connector_service.SinkMetadata", FIELDS, GeneratedVisitor)
2189 }
2190}
2191impl serde::Serialize for sink_metadata::SerializedMetadata {
2192 #[allow(deprecated)]
2193 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2194 where
2195 S: serde::Serializer,
2196 {
2197 use serde::ser::SerializeStruct;
2198 let mut len = 0;
2199 if !self.metadata.is_empty() {
2200 len += 1;
2201 }
2202 let mut struct_ser = serializer.serialize_struct("connector_service.SinkMetadata.SerializedMetadata", len)?;
2203 if !self.metadata.is_empty() {
2204 #[allow(clippy::needless_borrow)]
2205 #[allow(clippy::needless_borrows_for_generic_args)]
2206 struct_ser.serialize_field("metadata", pbjson::private::base64::encode(&self.metadata).as_str())?;
2207 }
2208 struct_ser.end()
2209 }
2210}
2211impl<'de> serde::Deserialize<'de> for sink_metadata::SerializedMetadata {
2212 #[allow(deprecated)]
2213 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2214 where
2215 D: serde::Deserializer<'de>,
2216 {
2217 const FIELDS: &[&str] = &[
2218 "metadata",
2219 ];
2220
2221 #[allow(clippy::enum_variant_names)]
2222 enum GeneratedField {
2223 Metadata,
2224 }
2225 impl<'de> serde::Deserialize<'de> for GeneratedField {
2226 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2227 where
2228 D: serde::Deserializer<'de>,
2229 {
2230 struct GeneratedVisitor;
2231
2232 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2233 type Value = GeneratedField;
2234
2235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2236 write!(formatter, "expected one of: {:?}", &FIELDS)
2237 }
2238
2239 #[allow(unused_variables)]
2240 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2241 where
2242 E: serde::de::Error,
2243 {
2244 match value {
2245 "metadata" => Ok(GeneratedField::Metadata),
2246 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2247 }
2248 }
2249 }
2250 deserializer.deserialize_identifier(GeneratedVisitor)
2251 }
2252 }
2253 struct GeneratedVisitor;
2254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2255 type Value = sink_metadata::SerializedMetadata;
2256
2257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2258 formatter.write_str("struct connector_service.SinkMetadata.SerializedMetadata")
2259 }
2260
2261 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_metadata::SerializedMetadata, V::Error>
2262 where
2263 V: serde::de::MapAccess<'de>,
2264 {
2265 let mut metadata__ = None;
2266 while let Some(k) = map_.next_key()? {
2267 match k {
2268 GeneratedField::Metadata => {
2269 if metadata__.is_some() {
2270 return Err(serde::de::Error::duplicate_field("metadata"));
2271 }
2272 metadata__ =
2273 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
2274 ;
2275 }
2276 }
2277 }
2278 Ok(sink_metadata::SerializedMetadata {
2279 metadata: metadata__.unwrap_or_default(),
2280 })
2281 }
2282 }
2283 deserializer.deserialize_struct("connector_service.SinkMetadata.SerializedMetadata", FIELDS, GeneratedVisitor)
2284 }
2285}
2286impl serde::Serialize for SinkParam {
2287 #[allow(deprecated)]
2288 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2289 where
2290 S: serde::Serializer,
2291 {
2292 use serde::ser::SerializeStruct;
2293 let mut len = 0;
2294 if self.sink_id != 0 {
2295 len += 1;
2296 }
2297 if !self.properties.is_empty() {
2298 len += 1;
2299 }
2300 if self.table_schema.is_some() {
2301 len += 1;
2302 }
2303 if self.sink_type != 0 {
2304 len += 1;
2305 }
2306 if !self.db_name.is_empty() {
2307 len += 1;
2308 }
2309 if !self.sink_from_name.is_empty() {
2310 len += 1;
2311 }
2312 if self.format_desc.is_some() {
2313 len += 1;
2314 }
2315 if !self.sink_name.is_empty() {
2316 len += 1;
2317 }
2318 if self.raw_ignore_delete {
2319 len += 1;
2320 }
2321 let mut struct_ser = serializer.serialize_struct("connector_service.SinkParam", len)?;
2322 if self.sink_id != 0 {
2323 struct_ser.serialize_field("sinkId", &self.sink_id)?;
2324 }
2325 if !self.properties.is_empty() {
2326 struct_ser.serialize_field("properties", &self.properties)?;
2327 }
2328 if let Some(v) = self.table_schema.as_ref() {
2329 struct_ser.serialize_field("tableSchema", v)?;
2330 }
2331 if self.sink_type != 0 {
2332 let v = super::catalog::SinkType::try_from(self.sink_type)
2333 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
2334 struct_ser.serialize_field("sinkType", &v)?;
2335 }
2336 if !self.db_name.is_empty() {
2337 struct_ser.serialize_field("dbName", &self.db_name)?;
2338 }
2339 if !self.sink_from_name.is_empty() {
2340 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
2341 }
2342 if let Some(v) = self.format_desc.as_ref() {
2343 struct_ser.serialize_field("formatDesc", v)?;
2344 }
2345 if !self.sink_name.is_empty() {
2346 struct_ser.serialize_field("sinkName", &self.sink_name)?;
2347 }
2348 if self.raw_ignore_delete {
2349 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
2350 }
2351 struct_ser.end()
2352 }
2353}
2354impl<'de> serde::Deserialize<'de> for SinkParam {
2355 #[allow(deprecated)]
2356 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2357 where
2358 D: serde::Deserializer<'de>,
2359 {
2360 const FIELDS: &[&str] = &[
2361 "sink_id",
2362 "sinkId",
2363 "properties",
2364 "table_schema",
2365 "tableSchema",
2366 "sink_type",
2367 "sinkType",
2368 "db_name",
2369 "dbName",
2370 "sink_from_name",
2371 "sinkFromName",
2372 "format_desc",
2373 "formatDesc",
2374 "sink_name",
2375 "sinkName",
2376 "raw_ignore_delete",
2377 "rawIgnoreDelete",
2378 ];
2379
2380 #[allow(clippy::enum_variant_names)]
2381 enum GeneratedField {
2382 SinkId,
2383 Properties,
2384 TableSchema,
2385 SinkType,
2386 DbName,
2387 SinkFromName,
2388 FormatDesc,
2389 SinkName,
2390 RawIgnoreDelete,
2391 }
2392 impl<'de> serde::Deserialize<'de> for GeneratedField {
2393 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2394 where
2395 D: serde::Deserializer<'de>,
2396 {
2397 struct GeneratedVisitor;
2398
2399 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2400 type Value = GeneratedField;
2401
2402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2403 write!(formatter, "expected one of: {:?}", &FIELDS)
2404 }
2405
2406 #[allow(unused_variables)]
2407 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2408 where
2409 E: serde::de::Error,
2410 {
2411 match value {
2412 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2413 "properties" => Ok(GeneratedField::Properties),
2414 "tableSchema" | "table_schema" => Ok(GeneratedField::TableSchema),
2415 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
2416 "dbName" | "db_name" => Ok(GeneratedField::DbName),
2417 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
2418 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
2419 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
2420 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
2421 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2422 }
2423 }
2424 }
2425 deserializer.deserialize_identifier(GeneratedVisitor)
2426 }
2427 }
2428 struct GeneratedVisitor;
2429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2430 type Value = SinkParam;
2431
2432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2433 formatter.write_str("struct connector_service.SinkParam")
2434 }
2435
2436 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkParam, V::Error>
2437 where
2438 V: serde::de::MapAccess<'de>,
2439 {
2440 let mut sink_id__ = None;
2441 let mut properties__ = None;
2442 let mut table_schema__ = None;
2443 let mut sink_type__ = None;
2444 let mut db_name__ = None;
2445 let mut sink_from_name__ = None;
2446 let mut format_desc__ = None;
2447 let mut sink_name__ = None;
2448 let mut raw_ignore_delete__ = None;
2449 while let Some(k) = map_.next_key()? {
2450 match k {
2451 GeneratedField::SinkId => {
2452 if sink_id__.is_some() {
2453 return Err(serde::de::Error::duplicate_field("sinkId"));
2454 }
2455 sink_id__ =
2456 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2457 ;
2458 }
2459 GeneratedField::Properties => {
2460 if properties__.is_some() {
2461 return Err(serde::de::Error::duplicate_field("properties"));
2462 }
2463 properties__ = Some(
2464 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2465 );
2466 }
2467 GeneratedField::TableSchema => {
2468 if table_schema__.is_some() {
2469 return Err(serde::de::Error::duplicate_field("tableSchema"));
2470 }
2471 table_schema__ = map_.next_value()?;
2472 }
2473 GeneratedField::SinkType => {
2474 if sink_type__.is_some() {
2475 return Err(serde::de::Error::duplicate_field("sinkType"));
2476 }
2477 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
2478 }
2479 GeneratedField::DbName => {
2480 if db_name__.is_some() {
2481 return Err(serde::de::Error::duplicate_field("dbName"));
2482 }
2483 db_name__ = Some(map_.next_value()?);
2484 }
2485 GeneratedField::SinkFromName => {
2486 if sink_from_name__.is_some() {
2487 return Err(serde::de::Error::duplicate_field("sinkFromName"));
2488 }
2489 sink_from_name__ = Some(map_.next_value()?);
2490 }
2491 GeneratedField::FormatDesc => {
2492 if format_desc__.is_some() {
2493 return Err(serde::de::Error::duplicate_field("formatDesc"));
2494 }
2495 format_desc__ = map_.next_value()?;
2496 }
2497 GeneratedField::SinkName => {
2498 if sink_name__.is_some() {
2499 return Err(serde::de::Error::duplicate_field("sinkName"));
2500 }
2501 sink_name__ = Some(map_.next_value()?);
2502 }
2503 GeneratedField::RawIgnoreDelete => {
2504 if raw_ignore_delete__.is_some() {
2505 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
2506 }
2507 raw_ignore_delete__ = Some(map_.next_value()?);
2508 }
2509 }
2510 }
2511 Ok(SinkParam {
2512 sink_id: sink_id__.unwrap_or_default(),
2513 properties: properties__.unwrap_or_default(),
2514 table_schema: table_schema__,
2515 sink_type: sink_type__.unwrap_or_default(),
2516 db_name: db_name__.unwrap_or_default(),
2517 sink_from_name: sink_from_name__.unwrap_or_default(),
2518 format_desc: format_desc__,
2519 sink_name: sink_name__.unwrap_or_default(),
2520 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
2521 })
2522 }
2523 }
2524 deserializer.deserialize_struct("connector_service.SinkParam", FIELDS, GeneratedVisitor)
2525 }
2526}
2527impl serde::Serialize for SinkWriterStreamRequest {
2528 #[allow(deprecated)]
2529 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2530 where
2531 S: serde::Serializer,
2532 {
2533 use serde::ser::SerializeStruct;
2534 let mut len = 0;
2535 if self.request.is_some() {
2536 len += 1;
2537 }
2538 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest", len)?;
2539 if let Some(v) = self.request.as_ref() {
2540 match v {
2541 sink_writer_stream_request::Request::Start(v) => {
2542 struct_ser.serialize_field("start", v)?;
2543 }
2544 sink_writer_stream_request::Request::WriteBatch(v) => {
2545 struct_ser.serialize_field("writeBatch", v)?;
2546 }
2547 sink_writer_stream_request::Request::Barrier(v) => {
2548 struct_ser.serialize_field("barrier", v)?;
2549 }
2550 }
2551 }
2552 struct_ser.end()
2553 }
2554}
2555impl<'de> serde::Deserialize<'de> for SinkWriterStreamRequest {
2556 #[allow(deprecated)]
2557 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2558 where
2559 D: serde::Deserializer<'de>,
2560 {
2561 const FIELDS: &[&str] = &[
2562 "start",
2563 "write_batch",
2564 "writeBatch",
2565 "barrier",
2566 ];
2567
2568 #[allow(clippy::enum_variant_names)]
2569 enum GeneratedField {
2570 Start,
2571 WriteBatch,
2572 Barrier,
2573 }
2574 impl<'de> serde::Deserialize<'de> for GeneratedField {
2575 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2576 where
2577 D: serde::Deserializer<'de>,
2578 {
2579 struct GeneratedVisitor;
2580
2581 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2582 type Value = GeneratedField;
2583
2584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2585 write!(formatter, "expected one of: {:?}", &FIELDS)
2586 }
2587
2588 #[allow(unused_variables)]
2589 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2590 where
2591 E: serde::de::Error,
2592 {
2593 match value {
2594 "start" => Ok(GeneratedField::Start),
2595 "writeBatch" | "write_batch" => Ok(GeneratedField::WriteBatch),
2596 "barrier" => Ok(GeneratedField::Barrier),
2597 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2598 }
2599 }
2600 }
2601 deserializer.deserialize_identifier(GeneratedVisitor)
2602 }
2603 }
2604 struct GeneratedVisitor;
2605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2606 type Value = SinkWriterStreamRequest;
2607
2608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2609 formatter.write_str("struct connector_service.SinkWriterStreamRequest")
2610 }
2611
2612 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkWriterStreamRequest, V::Error>
2613 where
2614 V: serde::de::MapAccess<'de>,
2615 {
2616 let mut request__ = None;
2617 while let Some(k) = map_.next_key()? {
2618 match k {
2619 GeneratedField::Start => {
2620 if request__.is_some() {
2621 return Err(serde::de::Error::duplicate_field("start"));
2622 }
2623 request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_request::Request::Start)
2624;
2625 }
2626 GeneratedField::WriteBatch => {
2627 if request__.is_some() {
2628 return Err(serde::de::Error::duplicate_field("writeBatch"));
2629 }
2630 request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_request::Request::WriteBatch)
2631;
2632 }
2633 GeneratedField::Barrier => {
2634 if request__.is_some() {
2635 return Err(serde::de::Error::duplicate_field("barrier"));
2636 }
2637 request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_request::Request::Barrier)
2638;
2639 }
2640 }
2641 }
2642 Ok(SinkWriterStreamRequest {
2643 request: request__,
2644 })
2645 }
2646 }
2647 deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest", FIELDS, GeneratedVisitor)
2648 }
2649}
2650impl serde::Serialize for sink_writer_stream_request::Barrier {
2651 #[allow(deprecated)]
2652 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2653 where
2654 S: serde::Serializer,
2655 {
2656 use serde::ser::SerializeStruct;
2657 let mut len = 0;
2658 if self.epoch != 0 {
2659 len += 1;
2660 }
2661 if self.is_checkpoint {
2662 len += 1;
2663 }
2664 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest.Barrier", len)?;
2665 if self.epoch != 0 {
2666 #[allow(clippy::needless_borrow)]
2667 #[allow(clippy::needless_borrows_for_generic_args)]
2668 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
2669 }
2670 if self.is_checkpoint {
2671 struct_ser.serialize_field("isCheckpoint", &self.is_checkpoint)?;
2672 }
2673 struct_ser.end()
2674 }
2675}
2676impl<'de> serde::Deserialize<'de> for sink_writer_stream_request::Barrier {
2677 #[allow(deprecated)]
2678 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2679 where
2680 D: serde::Deserializer<'de>,
2681 {
2682 const FIELDS: &[&str] = &[
2683 "epoch",
2684 "is_checkpoint",
2685 "isCheckpoint",
2686 ];
2687
2688 #[allow(clippy::enum_variant_names)]
2689 enum GeneratedField {
2690 Epoch,
2691 IsCheckpoint,
2692 }
2693 impl<'de> serde::Deserialize<'de> for GeneratedField {
2694 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2695 where
2696 D: serde::Deserializer<'de>,
2697 {
2698 struct GeneratedVisitor;
2699
2700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2701 type Value = GeneratedField;
2702
2703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2704 write!(formatter, "expected one of: {:?}", &FIELDS)
2705 }
2706
2707 #[allow(unused_variables)]
2708 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2709 where
2710 E: serde::de::Error,
2711 {
2712 match value {
2713 "epoch" => Ok(GeneratedField::Epoch),
2714 "isCheckpoint" | "is_checkpoint" => Ok(GeneratedField::IsCheckpoint),
2715 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2716 }
2717 }
2718 }
2719 deserializer.deserialize_identifier(GeneratedVisitor)
2720 }
2721 }
2722 struct GeneratedVisitor;
2723 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2724 type Value = sink_writer_stream_request::Barrier;
2725
2726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2727 formatter.write_str("struct connector_service.SinkWriterStreamRequest.Barrier")
2728 }
2729
2730 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_request::Barrier, V::Error>
2731 where
2732 V: serde::de::MapAccess<'de>,
2733 {
2734 let mut epoch__ = None;
2735 let mut is_checkpoint__ = None;
2736 while let Some(k) = map_.next_key()? {
2737 match k {
2738 GeneratedField::Epoch => {
2739 if epoch__.is_some() {
2740 return Err(serde::de::Error::duplicate_field("epoch"));
2741 }
2742 epoch__ =
2743 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2744 ;
2745 }
2746 GeneratedField::IsCheckpoint => {
2747 if is_checkpoint__.is_some() {
2748 return Err(serde::de::Error::duplicate_field("isCheckpoint"));
2749 }
2750 is_checkpoint__ = Some(map_.next_value()?);
2751 }
2752 }
2753 }
2754 Ok(sink_writer_stream_request::Barrier {
2755 epoch: epoch__.unwrap_or_default(),
2756 is_checkpoint: is_checkpoint__.unwrap_or_default(),
2757 })
2758 }
2759 }
2760 deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest.Barrier", FIELDS, GeneratedVisitor)
2761 }
2762}
2763impl serde::Serialize for sink_writer_stream_request::StartSink {
2764 #[allow(deprecated)]
2765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2766 where
2767 S: serde::Serializer,
2768 {
2769 use serde::ser::SerializeStruct;
2770 let mut len = 0;
2771 if self.sink_param.is_some() {
2772 len += 1;
2773 }
2774 if self.payload_schema.is_some() {
2775 len += 1;
2776 }
2777 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest.StartSink", len)?;
2778 if let Some(v) = self.sink_param.as_ref() {
2779 struct_ser.serialize_field("sinkParam", v)?;
2780 }
2781 if let Some(v) = self.payload_schema.as_ref() {
2782 struct_ser.serialize_field("payloadSchema", v)?;
2783 }
2784 struct_ser.end()
2785 }
2786}
2787impl<'de> serde::Deserialize<'de> for sink_writer_stream_request::StartSink {
2788 #[allow(deprecated)]
2789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2790 where
2791 D: serde::Deserializer<'de>,
2792 {
2793 const FIELDS: &[&str] = &[
2794 "sink_param",
2795 "sinkParam",
2796 "payload_schema",
2797 "payloadSchema",
2798 ];
2799
2800 #[allow(clippy::enum_variant_names)]
2801 enum GeneratedField {
2802 SinkParam,
2803 PayloadSchema,
2804 }
2805 impl<'de> serde::Deserialize<'de> for GeneratedField {
2806 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2807 where
2808 D: serde::Deserializer<'de>,
2809 {
2810 struct GeneratedVisitor;
2811
2812 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2813 type Value = GeneratedField;
2814
2815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2816 write!(formatter, "expected one of: {:?}", &FIELDS)
2817 }
2818
2819 #[allow(unused_variables)]
2820 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2821 where
2822 E: serde::de::Error,
2823 {
2824 match value {
2825 "sinkParam" | "sink_param" => Ok(GeneratedField::SinkParam),
2826 "payloadSchema" | "payload_schema" => Ok(GeneratedField::PayloadSchema),
2827 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2828 }
2829 }
2830 }
2831 deserializer.deserialize_identifier(GeneratedVisitor)
2832 }
2833 }
2834 struct GeneratedVisitor;
2835 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2836 type Value = sink_writer_stream_request::StartSink;
2837
2838 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2839 formatter.write_str("struct connector_service.SinkWriterStreamRequest.StartSink")
2840 }
2841
2842 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_request::StartSink, V::Error>
2843 where
2844 V: serde::de::MapAccess<'de>,
2845 {
2846 let mut sink_param__ = None;
2847 let mut payload_schema__ = None;
2848 while let Some(k) = map_.next_key()? {
2849 match k {
2850 GeneratedField::SinkParam => {
2851 if sink_param__.is_some() {
2852 return Err(serde::de::Error::duplicate_field("sinkParam"));
2853 }
2854 sink_param__ = map_.next_value()?;
2855 }
2856 GeneratedField::PayloadSchema => {
2857 if payload_schema__.is_some() {
2858 return Err(serde::de::Error::duplicate_field("payloadSchema"));
2859 }
2860 payload_schema__ = map_.next_value()?;
2861 }
2862 }
2863 }
2864 Ok(sink_writer_stream_request::StartSink {
2865 sink_param: sink_param__,
2866 payload_schema: payload_schema__,
2867 })
2868 }
2869 }
2870 deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest.StartSink", FIELDS, GeneratedVisitor)
2871 }
2872}
2873impl serde::Serialize for sink_writer_stream_request::WriteBatch {
2874 #[allow(deprecated)]
2875 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2876 where
2877 S: serde::Serializer,
2878 {
2879 use serde::ser::SerializeStruct;
2880 let mut len = 0;
2881 if self.batch_id != 0 {
2882 len += 1;
2883 }
2884 if self.epoch != 0 {
2885 len += 1;
2886 }
2887 if self.payload.is_some() {
2888 len += 1;
2889 }
2890 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest.WriteBatch", len)?;
2891 if self.batch_id != 0 {
2892 #[allow(clippy::needless_borrow)]
2893 #[allow(clippy::needless_borrows_for_generic_args)]
2894 struct_ser.serialize_field("batchId", ToString::to_string(&self.batch_id).as_str())?;
2895 }
2896 if self.epoch != 0 {
2897 #[allow(clippy::needless_borrow)]
2898 #[allow(clippy::needless_borrows_for_generic_args)]
2899 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
2900 }
2901 if let Some(v) = self.payload.as_ref() {
2902 match v {
2903 sink_writer_stream_request::write_batch::Payload::StreamChunkPayload(v) => {
2904 struct_ser.serialize_field("streamChunkPayload", v)?;
2905 }
2906 sink_writer_stream_request::write_batch::Payload::StreamChunkRefPointer(v) => {
2907 #[allow(clippy::needless_borrow)]
2908 #[allow(clippy::needless_borrows_for_generic_args)]
2909 struct_ser.serialize_field("streamChunkRefPointer", ToString::to_string(&v).as_str())?;
2910 }
2911 }
2912 }
2913 struct_ser.end()
2914 }
2915}
2916impl<'de> serde::Deserialize<'de> for sink_writer_stream_request::WriteBatch {
2917 #[allow(deprecated)]
2918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2919 where
2920 D: serde::Deserializer<'de>,
2921 {
2922 const FIELDS: &[&str] = &[
2923 "batch_id",
2924 "batchId",
2925 "epoch",
2926 "stream_chunk_payload",
2927 "streamChunkPayload",
2928 "stream_chunk_ref_pointer",
2929 "streamChunkRefPointer",
2930 ];
2931
2932 #[allow(clippy::enum_variant_names)]
2933 enum GeneratedField {
2934 BatchId,
2935 Epoch,
2936 StreamChunkPayload,
2937 StreamChunkRefPointer,
2938 }
2939 impl<'de> serde::Deserialize<'de> for GeneratedField {
2940 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2941 where
2942 D: serde::Deserializer<'de>,
2943 {
2944 struct GeneratedVisitor;
2945
2946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2947 type Value = GeneratedField;
2948
2949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2950 write!(formatter, "expected one of: {:?}", &FIELDS)
2951 }
2952
2953 #[allow(unused_variables)]
2954 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2955 where
2956 E: serde::de::Error,
2957 {
2958 match value {
2959 "batchId" | "batch_id" => Ok(GeneratedField::BatchId),
2960 "epoch" => Ok(GeneratedField::Epoch),
2961 "streamChunkPayload" | "stream_chunk_payload" => Ok(GeneratedField::StreamChunkPayload),
2962 "streamChunkRefPointer" | "stream_chunk_ref_pointer" => Ok(GeneratedField::StreamChunkRefPointer),
2963 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2964 }
2965 }
2966 }
2967 deserializer.deserialize_identifier(GeneratedVisitor)
2968 }
2969 }
2970 struct GeneratedVisitor;
2971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2972 type Value = sink_writer_stream_request::WriteBatch;
2973
2974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2975 formatter.write_str("struct connector_service.SinkWriterStreamRequest.WriteBatch")
2976 }
2977
2978 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_request::WriteBatch, V::Error>
2979 where
2980 V: serde::de::MapAccess<'de>,
2981 {
2982 let mut batch_id__ = None;
2983 let mut epoch__ = None;
2984 let mut payload__ = None;
2985 while let Some(k) = map_.next_key()? {
2986 match k {
2987 GeneratedField::BatchId => {
2988 if batch_id__.is_some() {
2989 return Err(serde::de::Error::duplicate_field("batchId"));
2990 }
2991 batch_id__ =
2992 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2993 ;
2994 }
2995 GeneratedField::Epoch => {
2996 if epoch__.is_some() {
2997 return Err(serde::de::Error::duplicate_field("epoch"));
2998 }
2999 epoch__ =
3000 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3001 ;
3002 }
3003 GeneratedField::StreamChunkPayload => {
3004 if payload__.is_some() {
3005 return Err(serde::de::Error::duplicate_field("streamChunkPayload"));
3006 }
3007 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_request::write_batch::Payload::StreamChunkPayload)
3008;
3009 }
3010 GeneratedField::StreamChunkRefPointer => {
3011 if payload__.is_some() {
3012 return Err(serde::de::Error::duplicate_field("streamChunkRefPointer"));
3013 }
3014 payload__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| sink_writer_stream_request::write_batch::Payload::StreamChunkRefPointer(x.0));
3015 }
3016 }
3017 }
3018 Ok(sink_writer_stream_request::WriteBatch {
3019 batch_id: batch_id__.unwrap_or_default(),
3020 epoch: epoch__.unwrap_or_default(),
3021 payload: payload__,
3022 })
3023 }
3024 }
3025 deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest.WriteBatch", FIELDS, GeneratedVisitor)
3026 }
3027}
3028impl serde::Serialize for sink_writer_stream_request::write_batch::StreamChunkPayload {
3029 #[allow(deprecated)]
3030 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3031 where
3032 S: serde::Serializer,
3033 {
3034 use serde::ser::SerializeStruct;
3035 let mut len = 0;
3036 if !self.binary_data.is_empty() {
3037 len += 1;
3038 }
3039 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest.WriteBatch.StreamChunkPayload", len)?;
3040 if !self.binary_data.is_empty() {
3041 #[allow(clippy::needless_borrow)]
3042 #[allow(clippy::needless_borrows_for_generic_args)]
3043 struct_ser.serialize_field("binaryData", pbjson::private::base64::encode(&self.binary_data).as_str())?;
3044 }
3045 struct_ser.end()
3046 }
3047}
3048impl<'de> serde::Deserialize<'de> for sink_writer_stream_request::write_batch::StreamChunkPayload {
3049 #[allow(deprecated)]
3050 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3051 where
3052 D: serde::Deserializer<'de>,
3053 {
3054 const FIELDS: &[&str] = &[
3055 "binary_data",
3056 "binaryData",
3057 ];
3058
3059 #[allow(clippy::enum_variant_names)]
3060 enum GeneratedField {
3061 BinaryData,
3062 }
3063 impl<'de> serde::Deserialize<'de> for GeneratedField {
3064 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3065 where
3066 D: serde::Deserializer<'de>,
3067 {
3068 struct GeneratedVisitor;
3069
3070 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3071 type Value = GeneratedField;
3072
3073 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3074 write!(formatter, "expected one of: {:?}", &FIELDS)
3075 }
3076
3077 #[allow(unused_variables)]
3078 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3079 where
3080 E: serde::de::Error,
3081 {
3082 match value {
3083 "binaryData" | "binary_data" => Ok(GeneratedField::BinaryData),
3084 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3085 }
3086 }
3087 }
3088 deserializer.deserialize_identifier(GeneratedVisitor)
3089 }
3090 }
3091 struct GeneratedVisitor;
3092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3093 type Value = sink_writer_stream_request::write_batch::StreamChunkPayload;
3094
3095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3096 formatter.write_str("struct connector_service.SinkWriterStreamRequest.WriteBatch.StreamChunkPayload")
3097 }
3098
3099 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_request::write_batch::StreamChunkPayload, V::Error>
3100 where
3101 V: serde::de::MapAccess<'de>,
3102 {
3103 let mut binary_data__ = None;
3104 while let Some(k) = map_.next_key()? {
3105 match k {
3106 GeneratedField::BinaryData => {
3107 if binary_data__.is_some() {
3108 return Err(serde::de::Error::duplicate_field("binaryData"));
3109 }
3110 binary_data__ =
3111 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
3112 ;
3113 }
3114 }
3115 }
3116 Ok(sink_writer_stream_request::write_batch::StreamChunkPayload {
3117 binary_data: binary_data__.unwrap_or_default(),
3118 })
3119 }
3120 }
3121 deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest.WriteBatch.StreamChunkPayload", FIELDS, GeneratedVisitor)
3122 }
3123}
3124impl serde::Serialize for SinkWriterStreamResponse {
3125 #[allow(deprecated)]
3126 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3127 where
3128 S: serde::Serializer,
3129 {
3130 use serde::ser::SerializeStruct;
3131 let mut len = 0;
3132 if self.response.is_some() {
3133 len += 1;
3134 }
3135 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamResponse", len)?;
3136 if let Some(v) = self.response.as_ref() {
3137 match v {
3138 sink_writer_stream_response::Response::Start(v) => {
3139 struct_ser.serialize_field("start", v)?;
3140 }
3141 sink_writer_stream_response::Response::Commit(v) => {
3142 struct_ser.serialize_field("commit", v)?;
3143 }
3144 sink_writer_stream_response::Response::Batch(v) => {
3145 struct_ser.serialize_field("batch", v)?;
3146 }
3147 }
3148 }
3149 struct_ser.end()
3150 }
3151}
3152impl<'de> serde::Deserialize<'de> for SinkWriterStreamResponse {
3153 #[allow(deprecated)]
3154 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3155 where
3156 D: serde::Deserializer<'de>,
3157 {
3158 const FIELDS: &[&str] = &[
3159 "start",
3160 "commit",
3161 "batch",
3162 ];
3163
3164 #[allow(clippy::enum_variant_names)]
3165 enum GeneratedField {
3166 Start,
3167 Commit,
3168 Batch,
3169 }
3170 impl<'de> serde::Deserialize<'de> for GeneratedField {
3171 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3172 where
3173 D: serde::Deserializer<'de>,
3174 {
3175 struct GeneratedVisitor;
3176
3177 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3178 type Value = GeneratedField;
3179
3180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3181 write!(formatter, "expected one of: {:?}", &FIELDS)
3182 }
3183
3184 #[allow(unused_variables)]
3185 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3186 where
3187 E: serde::de::Error,
3188 {
3189 match value {
3190 "start" => Ok(GeneratedField::Start),
3191 "commit" => Ok(GeneratedField::Commit),
3192 "batch" => Ok(GeneratedField::Batch),
3193 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3194 }
3195 }
3196 }
3197 deserializer.deserialize_identifier(GeneratedVisitor)
3198 }
3199 }
3200 struct GeneratedVisitor;
3201 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3202 type Value = SinkWriterStreamResponse;
3203
3204 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3205 formatter.write_str("struct connector_service.SinkWriterStreamResponse")
3206 }
3207
3208 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkWriterStreamResponse, V::Error>
3209 where
3210 V: serde::de::MapAccess<'de>,
3211 {
3212 let mut response__ = None;
3213 while let Some(k) = map_.next_key()? {
3214 match k {
3215 GeneratedField::Start => {
3216 if response__.is_some() {
3217 return Err(serde::de::Error::duplicate_field("start"));
3218 }
3219 response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_response::Response::Start)
3220;
3221 }
3222 GeneratedField::Commit => {
3223 if response__.is_some() {
3224 return Err(serde::de::Error::duplicate_field("commit"));
3225 }
3226 response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_response::Response::Commit)
3227;
3228 }
3229 GeneratedField::Batch => {
3230 if response__.is_some() {
3231 return Err(serde::de::Error::duplicate_field("batch"));
3232 }
3233 response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_response::Response::Batch)
3234;
3235 }
3236 }
3237 }
3238 Ok(SinkWriterStreamResponse {
3239 response: response__,
3240 })
3241 }
3242 }
3243 deserializer.deserialize_struct("connector_service.SinkWriterStreamResponse", FIELDS, GeneratedVisitor)
3244 }
3245}
3246impl serde::Serialize for sink_writer_stream_response::BatchWrittenResponse {
3247 #[allow(deprecated)]
3248 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3249 where
3250 S: serde::Serializer,
3251 {
3252 use serde::ser::SerializeStruct;
3253 let mut len = 0;
3254 if self.epoch != 0 {
3255 len += 1;
3256 }
3257 if self.batch_id != 0 {
3258 len += 1;
3259 }
3260 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamResponse.BatchWrittenResponse", len)?;
3261 if self.epoch != 0 {
3262 #[allow(clippy::needless_borrow)]
3263 #[allow(clippy::needless_borrows_for_generic_args)]
3264 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
3265 }
3266 if self.batch_id != 0 {
3267 #[allow(clippy::needless_borrow)]
3268 #[allow(clippy::needless_borrows_for_generic_args)]
3269 struct_ser.serialize_field("batchId", ToString::to_string(&self.batch_id).as_str())?;
3270 }
3271 struct_ser.end()
3272 }
3273}
3274impl<'de> serde::Deserialize<'de> for sink_writer_stream_response::BatchWrittenResponse {
3275 #[allow(deprecated)]
3276 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3277 where
3278 D: serde::Deserializer<'de>,
3279 {
3280 const FIELDS: &[&str] = &[
3281 "epoch",
3282 "batch_id",
3283 "batchId",
3284 ];
3285
3286 #[allow(clippy::enum_variant_names)]
3287 enum GeneratedField {
3288 Epoch,
3289 BatchId,
3290 }
3291 impl<'de> serde::Deserialize<'de> for GeneratedField {
3292 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3293 where
3294 D: serde::Deserializer<'de>,
3295 {
3296 struct GeneratedVisitor;
3297
3298 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3299 type Value = GeneratedField;
3300
3301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3302 write!(formatter, "expected one of: {:?}", &FIELDS)
3303 }
3304
3305 #[allow(unused_variables)]
3306 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3307 where
3308 E: serde::de::Error,
3309 {
3310 match value {
3311 "epoch" => Ok(GeneratedField::Epoch),
3312 "batchId" | "batch_id" => Ok(GeneratedField::BatchId),
3313 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3314 }
3315 }
3316 }
3317 deserializer.deserialize_identifier(GeneratedVisitor)
3318 }
3319 }
3320 struct GeneratedVisitor;
3321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3322 type Value = sink_writer_stream_response::BatchWrittenResponse;
3323
3324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3325 formatter.write_str("struct connector_service.SinkWriterStreamResponse.BatchWrittenResponse")
3326 }
3327
3328 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_response::BatchWrittenResponse, V::Error>
3329 where
3330 V: serde::de::MapAccess<'de>,
3331 {
3332 let mut epoch__ = None;
3333 let mut batch_id__ = None;
3334 while let Some(k) = map_.next_key()? {
3335 match k {
3336 GeneratedField::Epoch => {
3337 if epoch__.is_some() {
3338 return Err(serde::de::Error::duplicate_field("epoch"));
3339 }
3340 epoch__ =
3341 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3342 ;
3343 }
3344 GeneratedField::BatchId => {
3345 if batch_id__.is_some() {
3346 return Err(serde::de::Error::duplicate_field("batchId"));
3347 }
3348 batch_id__ =
3349 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3350 ;
3351 }
3352 }
3353 }
3354 Ok(sink_writer_stream_response::BatchWrittenResponse {
3355 epoch: epoch__.unwrap_or_default(),
3356 batch_id: batch_id__.unwrap_or_default(),
3357 })
3358 }
3359 }
3360 deserializer.deserialize_struct("connector_service.SinkWriterStreamResponse.BatchWrittenResponse", FIELDS, GeneratedVisitor)
3361 }
3362}
3363impl serde::Serialize for sink_writer_stream_response::CommitResponse {
3364 #[allow(deprecated)]
3365 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3366 where
3367 S: serde::Serializer,
3368 {
3369 use serde::ser::SerializeStruct;
3370 let mut len = 0;
3371 if self.epoch != 0 {
3372 len += 1;
3373 }
3374 if self.metadata.is_some() {
3375 len += 1;
3376 }
3377 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamResponse.CommitResponse", len)?;
3378 if self.epoch != 0 {
3379 #[allow(clippy::needless_borrow)]
3380 #[allow(clippy::needless_borrows_for_generic_args)]
3381 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
3382 }
3383 if let Some(v) = self.metadata.as_ref() {
3384 struct_ser.serialize_field("metadata", v)?;
3385 }
3386 struct_ser.end()
3387 }
3388}
3389impl<'de> serde::Deserialize<'de> for sink_writer_stream_response::CommitResponse {
3390 #[allow(deprecated)]
3391 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3392 where
3393 D: serde::Deserializer<'de>,
3394 {
3395 const FIELDS: &[&str] = &[
3396 "epoch",
3397 "metadata",
3398 ];
3399
3400 #[allow(clippy::enum_variant_names)]
3401 enum GeneratedField {
3402 Epoch,
3403 Metadata,
3404 }
3405 impl<'de> serde::Deserialize<'de> for GeneratedField {
3406 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3407 where
3408 D: serde::Deserializer<'de>,
3409 {
3410 struct GeneratedVisitor;
3411
3412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3413 type Value = GeneratedField;
3414
3415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3416 write!(formatter, "expected one of: {:?}", &FIELDS)
3417 }
3418
3419 #[allow(unused_variables)]
3420 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3421 where
3422 E: serde::de::Error,
3423 {
3424 match value {
3425 "epoch" => Ok(GeneratedField::Epoch),
3426 "metadata" => Ok(GeneratedField::Metadata),
3427 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3428 }
3429 }
3430 }
3431 deserializer.deserialize_identifier(GeneratedVisitor)
3432 }
3433 }
3434 struct GeneratedVisitor;
3435 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3436 type Value = sink_writer_stream_response::CommitResponse;
3437
3438 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3439 formatter.write_str("struct connector_service.SinkWriterStreamResponse.CommitResponse")
3440 }
3441
3442 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_response::CommitResponse, V::Error>
3443 where
3444 V: serde::de::MapAccess<'de>,
3445 {
3446 let mut epoch__ = None;
3447 let mut metadata__ = None;
3448 while let Some(k) = map_.next_key()? {
3449 match k {
3450 GeneratedField::Epoch => {
3451 if epoch__.is_some() {
3452 return Err(serde::de::Error::duplicate_field("epoch"));
3453 }
3454 epoch__ =
3455 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3456 ;
3457 }
3458 GeneratedField::Metadata => {
3459 if metadata__.is_some() {
3460 return Err(serde::de::Error::duplicate_field("metadata"));
3461 }
3462 metadata__ = map_.next_value()?;
3463 }
3464 }
3465 }
3466 Ok(sink_writer_stream_response::CommitResponse {
3467 epoch: epoch__.unwrap_or_default(),
3468 metadata: metadata__,
3469 })
3470 }
3471 }
3472 deserializer.deserialize_struct("connector_service.SinkWriterStreamResponse.CommitResponse", FIELDS, GeneratedVisitor)
3473 }
3474}
3475impl serde::Serialize for sink_writer_stream_response::StartResponse {
3476 #[allow(deprecated)]
3477 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3478 where
3479 S: serde::Serializer,
3480 {
3481 use serde::ser::SerializeStruct;
3482 let len = 0;
3483 let struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamResponse.StartResponse", len)?;
3484 struct_ser.end()
3485 }
3486}
3487impl<'de> serde::Deserialize<'de> for sink_writer_stream_response::StartResponse {
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 ];
3495
3496 #[allow(clippy::enum_variant_names)]
3497 enum GeneratedField {
3498 }
3499 impl<'de> serde::Deserialize<'de> for GeneratedField {
3500 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3501 where
3502 D: serde::Deserializer<'de>,
3503 {
3504 struct GeneratedVisitor;
3505
3506 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3507 type Value = GeneratedField;
3508
3509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3510 write!(formatter, "expected one of: {:?}", &FIELDS)
3511 }
3512
3513 #[allow(unused_variables)]
3514 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3515 where
3516 E: serde::de::Error,
3517 {
3518 Err(serde::de::Error::unknown_field(value, FIELDS))
3519 }
3520 }
3521 deserializer.deserialize_identifier(GeneratedVisitor)
3522 }
3523 }
3524 struct GeneratedVisitor;
3525 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3526 type Value = sink_writer_stream_response::StartResponse;
3527
3528 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3529 formatter.write_str("struct connector_service.SinkWriterStreamResponse.StartResponse")
3530 }
3531
3532 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_response::StartResponse, V::Error>
3533 where
3534 V: serde::de::MapAccess<'de>,
3535 {
3536 while map_.next_key::<GeneratedField>()?.is_some() {
3537 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3538 }
3539 Ok(sink_writer_stream_response::StartResponse {
3540 })
3541 }
3542 }
3543 deserializer.deserialize_struct("connector_service.SinkWriterStreamResponse.StartResponse", FIELDS, GeneratedVisitor)
3544 }
3545}
3546impl serde::Serialize for SourceType {
3547 #[allow(deprecated)]
3548 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3549 where
3550 S: serde::Serializer,
3551 {
3552 let variant = match self {
3553 Self::Unspecified => "UNSPECIFIED",
3554 Self::Mysql => "MYSQL",
3555 Self::Postgres => "POSTGRES",
3556 Self::Citus => "CITUS",
3557 Self::Mongodb => "MONGODB",
3558 Self::SqlServer => "SQL_SERVER",
3559 };
3560 serializer.serialize_str(variant)
3561 }
3562}
3563impl<'de> serde::Deserialize<'de> for SourceType {
3564 #[allow(deprecated)]
3565 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3566 where
3567 D: serde::Deserializer<'de>,
3568 {
3569 const FIELDS: &[&str] = &[
3570 "UNSPECIFIED",
3571 "MYSQL",
3572 "POSTGRES",
3573 "CITUS",
3574 "MONGODB",
3575 "SQL_SERVER",
3576 ];
3577
3578 struct GeneratedVisitor;
3579
3580 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3581 type Value = SourceType;
3582
3583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3584 write!(formatter, "expected one of: {:?}", &FIELDS)
3585 }
3586
3587 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3588 where
3589 E: serde::de::Error,
3590 {
3591 i32::try_from(v)
3592 .ok()
3593 .and_then(|x| x.try_into().ok())
3594 .ok_or_else(|| {
3595 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3596 })
3597 }
3598
3599 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3600 where
3601 E: serde::de::Error,
3602 {
3603 i32::try_from(v)
3604 .ok()
3605 .and_then(|x| x.try_into().ok())
3606 .ok_or_else(|| {
3607 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3608 })
3609 }
3610
3611 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3612 where
3613 E: serde::de::Error,
3614 {
3615 match value {
3616 "UNSPECIFIED" => Ok(SourceType::Unspecified),
3617 "MYSQL" => Ok(SourceType::Mysql),
3618 "POSTGRES" => Ok(SourceType::Postgres),
3619 "CITUS" => Ok(SourceType::Citus),
3620 "MONGODB" => Ok(SourceType::Mongodb),
3621 "SQL_SERVER" => Ok(SourceType::SqlServer),
3622 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3623 }
3624 }
3625 }
3626 deserializer.deserialize_any(GeneratedVisitor)
3627 }
3628}
3629impl serde::Serialize for TableSchema {
3630 #[allow(deprecated)]
3631 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3632 where
3633 S: serde::Serializer,
3634 {
3635 use serde::ser::SerializeStruct;
3636 let mut len = 0;
3637 if !self.columns.is_empty() {
3638 len += 1;
3639 }
3640 if !self.pk_indices.is_empty() {
3641 len += 1;
3642 }
3643 let mut struct_ser = serializer.serialize_struct("connector_service.TableSchema", len)?;
3644 if !self.columns.is_empty() {
3645 struct_ser.serialize_field("columns", &self.columns)?;
3646 }
3647 if !self.pk_indices.is_empty() {
3648 struct_ser.serialize_field("pkIndices", &self.pk_indices)?;
3649 }
3650 struct_ser.end()
3651 }
3652}
3653impl<'de> serde::Deserialize<'de> for TableSchema {
3654 #[allow(deprecated)]
3655 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3656 where
3657 D: serde::Deserializer<'de>,
3658 {
3659 const FIELDS: &[&str] = &[
3660 "columns",
3661 "pk_indices",
3662 "pkIndices",
3663 ];
3664
3665 #[allow(clippy::enum_variant_names)]
3666 enum GeneratedField {
3667 Columns,
3668 PkIndices,
3669 }
3670 impl<'de> serde::Deserialize<'de> for GeneratedField {
3671 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3672 where
3673 D: serde::Deserializer<'de>,
3674 {
3675 struct GeneratedVisitor;
3676
3677 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3678 type Value = GeneratedField;
3679
3680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3681 write!(formatter, "expected one of: {:?}", &FIELDS)
3682 }
3683
3684 #[allow(unused_variables)]
3685 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3686 where
3687 E: serde::de::Error,
3688 {
3689 match value {
3690 "columns" => Ok(GeneratedField::Columns),
3691 "pkIndices" | "pk_indices" => Ok(GeneratedField::PkIndices),
3692 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3693 }
3694 }
3695 }
3696 deserializer.deserialize_identifier(GeneratedVisitor)
3697 }
3698 }
3699 struct GeneratedVisitor;
3700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3701 type Value = TableSchema;
3702
3703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3704 formatter.write_str("struct connector_service.TableSchema")
3705 }
3706
3707 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
3708 where
3709 V: serde::de::MapAccess<'de>,
3710 {
3711 let mut columns__ = None;
3712 let mut pk_indices__ = None;
3713 while let Some(k) = map_.next_key()? {
3714 match k {
3715 GeneratedField::Columns => {
3716 if columns__.is_some() {
3717 return Err(serde::de::Error::duplicate_field("columns"));
3718 }
3719 columns__ = Some(map_.next_value()?);
3720 }
3721 GeneratedField::PkIndices => {
3722 if pk_indices__.is_some() {
3723 return Err(serde::de::Error::duplicate_field("pkIndices"));
3724 }
3725 pk_indices__ =
3726 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3727 .into_iter().map(|x| x.0).collect())
3728 ;
3729 }
3730 }
3731 }
3732 Ok(TableSchema {
3733 columns: columns__.unwrap_or_default(),
3734 pk_indices: pk_indices__.unwrap_or_default(),
3735 })
3736 }
3737 }
3738 deserializer.deserialize_struct("connector_service.TableSchema", FIELDS, GeneratedVisitor)
3739 }
3740}
3741impl serde::Serialize for ValidateSinkRequest {
3742 #[allow(deprecated)]
3743 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3744 where
3745 S: serde::Serializer,
3746 {
3747 use serde::ser::SerializeStruct;
3748 let mut len = 0;
3749 if self.sink_param.is_some() {
3750 len += 1;
3751 }
3752 let mut struct_ser = serializer.serialize_struct("connector_service.ValidateSinkRequest", len)?;
3753 if let Some(v) = self.sink_param.as_ref() {
3754 struct_ser.serialize_field("sinkParam", v)?;
3755 }
3756 struct_ser.end()
3757 }
3758}
3759impl<'de> serde::Deserialize<'de> for ValidateSinkRequest {
3760 #[allow(deprecated)]
3761 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3762 where
3763 D: serde::Deserializer<'de>,
3764 {
3765 const FIELDS: &[&str] = &[
3766 "sink_param",
3767 "sinkParam",
3768 ];
3769
3770 #[allow(clippy::enum_variant_names)]
3771 enum GeneratedField {
3772 SinkParam,
3773 }
3774 impl<'de> serde::Deserialize<'de> for GeneratedField {
3775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3776 where
3777 D: serde::Deserializer<'de>,
3778 {
3779 struct GeneratedVisitor;
3780
3781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3782 type Value = GeneratedField;
3783
3784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3785 write!(formatter, "expected one of: {:?}", &FIELDS)
3786 }
3787
3788 #[allow(unused_variables)]
3789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3790 where
3791 E: serde::de::Error,
3792 {
3793 match value {
3794 "sinkParam" | "sink_param" => Ok(GeneratedField::SinkParam),
3795 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3796 }
3797 }
3798 }
3799 deserializer.deserialize_identifier(GeneratedVisitor)
3800 }
3801 }
3802 struct GeneratedVisitor;
3803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3804 type Value = ValidateSinkRequest;
3805
3806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3807 formatter.write_str("struct connector_service.ValidateSinkRequest")
3808 }
3809
3810 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidateSinkRequest, V::Error>
3811 where
3812 V: serde::de::MapAccess<'de>,
3813 {
3814 let mut sink_param__ = None;
3815 while let Some(k) = map_.next_key()? {
3816 match k {
3817 GeneratedField::SinkParam => {
3818 if sink_param__.is_some() {
3819 return Err(serde::de::Error::duplicate_field("sinkParam"));
3820 }
3821 sink_param__ = map_.next_value()?;
3822 }
3823 }
3824 }
3825 Ok(ValidateSinkRequest {
3826 sink_param: sink_param__,
3827 })
3828 }
3829 }
3830 deserializer.deserialize_struct("connector_service.ValidateSinkRequest", FIELDS, GeneratedVisitor)
3831 }
3832}
3833impl serde::Serialize for ValidateSinkResponse {
3834 #[allow(deprecated)]
3835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3836 where
3837 S: serde::Serializer,
3838 {
3839 use serde::ser::SerializeStruct;
3840 let mut len = 0;
3841 if self.error.is_some() {
3842 len += 1;
3843 }
3844 let mut struct_ser = serializer.serialize_struct("connector_service.ValidateSinkResponse", len)?;
3845 if let Some(v) = self.error.as_ref() {
3846 struct_ser.serialize_field("error", v)?;
3847 }
3848 struct_ser.end()
3849 }
3850}
3851impl<'de> serde::Deserialize<'de> for ValidateSinkResponse {
3852 #[allow(deprecated)]
3853 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3854 where
3855 D: serde::Deserializer<'de>,
3856 {
3857 const FIELDS: &[&str] = &[
3858 "error",
3859 ];
3860
3861 #[allow(clippy::enum_variant_names)]
3862 enum GeneratedField {
3863 Error,
3864 }
3865 impl<'de> serde::Deserialize<'de> for GeneratedField {
3866 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3867 where
3868 D: serde::Deserializer<'de>,
3869 {
3870 struct GeneratedVisitor;
3871
3872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3873 type Value = GeneratedField;
3874
3875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3876 write!(formatter, "expected one of: {:?}", &FIELDS)
3877 }
3878
3879 #[allow(unused_variables)]
3880 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3881 where
3882 E: serde::de::Error,
3883 {
3884 match value {
3885 "error" => Ok(GeneratedField::Error),
3886 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3887 }
3888 }
3889 }
3890 deserializer.deserialize_identifier(GeneratedVisitor)
3891 }
3892 }
3893 struct GeneratedVisitor;
3894 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3895 type Value = ValidateSinkResponse;
3896
3897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3898 formatter.write_str("struct connector_service.ValidateSinkResponse")
3899 }
3900
3901 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidateSinkResponse, V::Error>
3902 where
3903 V: serde::de::MapAccess<'de>,
3904 {
3905 let mut error__ = None;
3906 while let Some(k) = map_.next_key()? {
3907 match k {
3908 GeneratedField::Error => {
3909 if error__.is_some() {
3910 return Err(serde::de::Error::duplicate_field("error"));
3911 }
3912 error__ = map_.next_value()?;
3913 }
3914 }
3915 }
3916 Ok(ValidateSinkResponse {
3917 error: error__,
3918 })
3919 }
3920 }
3921 deserializer.deserialize_struct("connector_service.ValidateSinkResponse", FIELDS, GeneratedVisitor)
3922 }
3923}
3924impl serde::Serialize for ValidateSourceRequest {
3925 #[allow(deprecated)]
3926 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3927 where
3928 S: serde::Serializer,
3929 {
3930 use serde::ser::SerializeStruct;
3931 let mut len = 0;
3932 if self.source_id != 0 {
3933 len += 1;
3934 }
3935 if self.source_type != 0 {
3936 len += 1;
3937 }
3938 if !self.properties.is_empty() {
3939 len += 1;
3940 }
3941 if self.table_schema.is_some() {
3942 len += 1;
3943 }
3944 if self.is_source_job {
3945 len += 1;
3946 }
3947 if self.is_backfill_table {
3948 len += 1;
3949 }
3950 let mut struct_ser = serializer.serialize_struct("connector_service.ValidateSourceRequest", len)?;
3951 if self.source_id != 0 {
3952 #[allow(clippy::needless_borrow)]
3953 #[allow(clippy::needless_borrows_for_generic_args)]
3954 struct_ser.serialize_field("sourceId", ToString::to_string(&self.source_id).as_str())?;
3955 }
3956 if self.source_type != 0 {
3957 let v = SourceType::try_from(self.source_type)
3958 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.source_type)))?;
3959 struct_ser.serialize_field("sourceType", &v)?;
3960 }
3961 if !self.properties.is_empty() {
3962 struct_ser.serialize_field("properties", &self.properties)?;
3963 }
3964 if let Some(v) = self.table_schema.as_ref() {
3965 struct_ser.serialize_field("tableSchema", v)?;
3966 }
3967 if self.is_source_job {
3968 struct_ser.serialize_field("isSourceJob", &self.is_source_job)?;
3969 }
3970 if self.is_backfill_table {
3971 struct_ser.serialize_field("isBackfillTable", &self.is_backfill_table)?;
3972 }
3973 struct_ser.end()
3974 }
3975}
3976impl<'de> serde::Deserialize<'de> for ValidateSourceRequest {
3977 #[allow(deprecated)]
3978 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3979 where
3980 D: serde::Deserializer<'de>,
3981 {
3982 const FIELDS: &[&str] = &[
3983 "source_id",
3984 "sourceId",
3985 "source_type",
3986 "sourceType",
3987 "properties",
3988 "table_schema",
3989 "tableSchema",
3990 "is_source_job",
3991 "isSourceJob",
3992 "is_backfill_table",
3993 "isBackfillTable",
3994 ];
3995
3996 #[allow(clippy::enum_variant_names)]
3997 enum GeneratedField {
3998 SourceId,
3999 SourceType,
4000 Properties,
4001 TableSchema,
4002 IsSourceJob,
4003 IsBackfillTable,
4004 }
4005 impl<'de> serde::Deserialize<'de> for GeneratedField {
4006 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4007 where
4008 D: serde::Deserializer<'de>,
4009 {
4010 struct GeneratedVisitor;
4011
4012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4013 type Value = GeneratedField;
4014
4015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4016 write!(formatter, "expected one of: {:?}", &FIELDS)
4017 }
4018
4019 #[allow(unused_variables)]
4020 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4021 where
4022 E: serde::de::Error,
4023 {
4024 match value {
4025 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
4026 "sourceType" | "source_type" => Ok(GeneratedField::SourceType),
4027 "properties" => Ok(GeneratedField::Properties),
4028 "tableSchema" | "table_schema" => Ok(GeneratedField::TableSchema),
4029 "isSourceJob" | "is_source_job" => Ok(GeneratedField::IsSourceJob),
4030 "isBackfillTable" | "is_backfill_table" => Ok(GeneratedField::IsBackfillTable),
4031 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4032 }
4033 }
4034 }
4035 deserializer.deserialize_identifier(GeneratedVisitor)
4036 }
4037 }
4038 struct GeneratedVisitor;
4039 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4040 type Value = ValidateSourceRequest;
4041
4042 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4043 formatter.write_str("struct connector_service.ValidateSourceRequest")
4044 }
4045
4046 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidateSourceRequest, V::Error>
4047 where
4048 V: serde::de::MapAccess<'de>,
4049 {
4050 let mut source_id__ = None;
4051 let mut source_type__ = None;
4052 let mut properties__ = None;
4053 let mut table_schema__ = None;
4054 let mut is_source_job__ = None;
4055 let mut is_backfill_table__ = None;
4056 while let Some(k) = map_.next_key()? {
4057 match k {
4058 GeneratedField::SourceId => {
4059 if source_id__.is_some() {
4060 return Err(serde::de::Error::duplicate_field("sourceId"));
4061 }
4062 source_id__ =
4063 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4064 ;
4065 }
4066 GeneratedField::SourceType => {
4067 if source_type__.is_some() {
4068 return Err(serde::de::Error::duplicate_field("sourceType"));
4069 }
4070 source_type__ = Some(map_.next_value::<SourceType>()? as i32);
4071 }
4072 GeneratedField::Properties => {
4073 if properties__.is_some() {
4074 return Err(serde::de::Error::duplicate_field("properties"));
4075 }
4076 properties__ = Some(
4077 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4078 );
4079 }
4080 GeneratedField::TableSchema => {
4081 if table_schema__.is_some() {
4082 return Err(serde::de::Error::duplicate_field("tableSchema"));
4083 }
4084 table_schema__ = map_.next_value()?;
4085 }
4086 GeneratedField::IsSourceJob => {
4087 if is_source_job__.is_some() {
4088 return Err(serde::de::Error::duplicate_field("isSourceJob"));
4089 }
4090 is_source_job__ = Some(map_.next_value()?);
4091 }
4092 GeneratedField::IsBackfillTable => {
4093 if is_backfill_table__.is_some() {
4094 return Err(serde::de::Error::duplicate_field("isBackfillTable"));
4095 }
4096 is_backfill_table__ = Some(map_.next_value()?);
4097 }
4098 }
4099 }
4100 Ok(ValidateSourceRequest {
4101 source_id: source_id__.unwrap_or_default(),
4102 source_type: source_type__.unwrap_or_default(),
4103 properties: properties__.unwrap_or_default(),
4104 table_schema: table_schema__,
4105 is_source_job: is_source_job__.unwrap_or_default(),
4106 is_backfill_table: is_backfill_table__.unwrap_or_default(),
4107 })
4108 }
4109 }
4110 deserializer.deserialize_struct("connector_service.ValidateSourceRequest", FIELDS, GeneratedVisitor)
4111 }
4112}
4113impl serde::Serialize for ValidateSourceResponse {
4114 #[allow(deprecated)]
4115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4116 where
4117 S: serde::Serializer,
4118 {
4119 use serde::ser::SerializeStruct;
4120 let mut len = 0;
4121 if self.error.is_some() {
4122 len += 1;
4123 }
4124 let mut struct_ser = serializer.serialize_struct("connector_service.ValidateSourceResponse", len)?;
4125 if let Some(v) = self.error.as_ref() {
4126 struct_ser.serialize_field("error", v)?;
4127 }
4128 struct_ser.end()
4129 }
4130}
4131impl<'de> serde::Deserialize<'de> for ValidateSourceResponse {
4132 #[allow(deprecated)]
4133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4134 where
4135 D: serde::Deserializer<'de>,
4136 {
4137 const FIELDS: &[&str] = &[
4138 "error",
4139 ];
4140
4141 #[allow(clippy::enum_variant_names)]
4142 enum GeneratedField {
4143 Error,
4144 }
4145 impl<'de> serde::Deserialize<'de> for GeneratedField {
4146 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4147 where
4148 D: serde::Deserializer<'de>,
4149 {
4150 struct GeneratedVisitor;
4151
4152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4153 type Value = GeneratedField;
4154
4155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4156 write!(formatter, "expected one of: {:?}", &FIELDS)
4157 }
4158
4159 #[allow(unused_variables)]
4160 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4161 where
4162 E: serde::de::Error,
4163 {
4164 match value {
4165 "error" => Ok(GeneratedField::Error),
4166 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4167 }
4168 }
4169 }
4170 deserializer.deserialize_identifier(GeneratedVisitor)
4171 }
4172 }
4173 struct GeneratedVisitor;
4174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4175 type Value = ValidateSourceResponse;
4176
4177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4178 formatter.write_str("struct connector_service.ValidateSourceResponse")
4179 }
4180
4181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidateSourceResponse, V::Error>
4182 where
4183 V: serde::de::MapAccess<'de>,
4184 {
4185 let mut error__ = None;
4186 while let Some(k) = map_.next_key()? {
4187 match k {
4188 GeneratedField::Error => {
4189 if error__.is_some() {
4190 return Err(serde::de::Error::duplicate_field("error"));
4191 }
4192 error__ = map_.next_value()?;
4193 }
4194 }
4195 }
4196 Ok(ValidateSourceResponse {
4197 error: error__,
4198 })
4199 }
4200 }
4201 deserializer.deserialize_struct("connector_service.ValidateSourceResponse", FIELDS, GeneratedVisitor)
4202 }
4203}
4204impl serde::Serialize for ValidationError {
4205 #[allow(deprecated)]
4206 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4207 where
4208 S: serde::Serializer,
4209 {
4210 use serde::ser::SerializeStruct;
4211 let mut len = 0;
4212 if !self.error_message.is_empty() {
4213 len += 1;
4214 }
4215 let mut struct_ser = serializer.serialize_struct("connector_service.ValidationError", len)?;
4216 if !self.error_message.is_empty() {
4217 struct_ser.serialize_field("errorMessage", &self.error_message)?;
4218 }
4219 struct_ser.end()
4220 }
4221}
4222impl<'de> serde::Deserialize<'de> for ValidationError {
4223 #[allow(deprecated)]
4224 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4225 where
4226 D: serde::Deserializer<'de>,
4227 {
4228 const FIELDS: &[&str] = &[
4229 "error_message",
4230 "errorMessage",
4231 ];
4232
4233 #[allow(clippy::enum_variant_names)]
4234 enum GeneratedField {
4235 ErrorMessage,
4236 }
4237 impl<'de> serde::Deserialize<'de> for GeneratedField {
4238 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4239 where
4240 D: serde::Deserializer<'de>,
4241 {
4242 struct GeneratedVisitor;
4243
4244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4245 type Value = GeneratedField;
4246
4247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4248 write!(formatter, "expected one of: {:?}", &FIELDS)
4249 }
4250
4251 #[allow(unused_variables)]
4252 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4253 where
4254 E: serde::de::Error,
4255 {
4256 match value {
4257 "errorMessage" | "error_message" => Ok(GeneratedField::ErrorMessage),
4258 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4259 }
4260 }
4261 }
4262 deserializer.deserialize_identifier(GeneratedVisitor)
4263 }
4264 }
4265 struct GeneratedVisitor;
4266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4267 type Value = ValidationError;
4268
4269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4270 formatter.write_str("struct connector_service.ValidationError")
4271 }
4272
4273 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationError, V::Error>
4274 where
4275 V: serde::de::MapAccess<'de>,
4276 {
4277 let mut error_message__ = None;
4278 while let Some(k) = map_.next_key()? {
4279 match k {
4280 GeneratedField::ErrorMessage => {
4281 if error_message__.is_some() {
4282 return Err(serde::de::Error::duplicate_field("errorMessage"));
4283 }
4284 error_message__ = Some(map_.next_value()?);
4285 }
4286 }
4287 }
4288 Ok(ValidationError {
4289 error_message: error_message__.unwrap_or_default(),
4290 })
4291 }
4292 }
4293 deserializer.deserialize_struct("connector_service.ValidationError", FIELDS, GeneratedVisitor)
4294 }
4295}