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