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