1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::stream_service::*;
4impl serde::Serialize for BarrierCompleteResponse {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 use serde::ser::SerializeStruct;
11 let mut len = 0;
12 if !self.request_id.is_empty() {
13 len += 1;
14 }
15 if self.status.is_some() {
16 len += 1;
17 }
18 if !self.create_mview_progress.is_empty() {
19 len += 1;
20 }
21 if !self.synced_sstables.is_empty() {
22 len += 1;
23 }
24 if self.worker_id != 0 {
25 len += 1;
26 }
27 if !self.table_watermarks.is_empty() {
28 len += 1;
29 }
30 if !self.old_value_sstables.is_empty() {
31 len += 1;
32 }
33 if self.partial_graph_id != 0 {
34 len += 1;
35 }
36 if self.epoch != 0 {
37 len += 1;
38 }
39 if !self.load_finished_sources.is_empty() {
40 len += 1;
41 }
42 if !self.vector_index_adds.is_empty() {
43 len += 1;
44 }
45 if !self.cdc_table_backfill_progress.is_empty() {
46 len += 1;
47 }
48 if !self.truncate_tables.is_empty() {
49 len += 1;
50 }
51 if !self.refresh_finished_tables.is_empty() {
52 len += 1;
53 }
54 if !self.list_finished_sources.is_empty() {
55 len += 1;
56 }
57 if !self.cdc_source_offset_updated.is_empty() {
58 len += 1;
59 }
60 if !self.iceberg_pk_index_sink_metadata.is_empty() {
61 len += 1;
62 }
63 let mut struct_ser = serializer.serialize_struct("stream_service.BarrierCompleteResponse", len)?;
64 if !self.request_id.is_empty() {
65 struct_ser.serialize_field("requestId", &self.request_id)?;
66 }
67 if let Some(v) = self.status.as_ref() {
68 struct_ser.serialize_field("status", v)?;
69 }
70 if !self.create_mview_progress.is_empty() {
71 struct_ser.serialize_field("createMviewProgress", &self.create_mview_progress)?;
72 }
73 if !self.synced_sstables.is_empty() {
74 struct_ser.serialize_field("syncedSstables", &self.synced_sstables)?;
75 }
76 if self.worker_id != 0 {
77 struct_ser.serialize_field("workerId", &self.worker_id)?;
78 }
79 if !self.table_watermarks.is_empty() {
80 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
81 }
82 if !self.old_value_sstables.is_empty() {
83 struct_ser.serialize_field("oldValueSstables", &self.old_value_sstables)?;
84 }
85 if self.partial_graph_id != 0 {
86 #[allow(clippy::needless_borrow)]
87 #[allow(clippy::needless_borrows_for_generic_args)]
88 struct_ser.serialize_field("partialGraphId", ToString::to_string(&self.partial_graph_id).as_str())?;
89 }
90 if self.epoch != 0 {
91 #[allow(clippy::needless_borrow)]
92 #[allow(clippy::needless_borrows_for_generic_args)]
93 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
94 }
95 if !self.load_finished_sources.is_empty() {
96 struct_ser.serialize_field("loadFinishedSources", &self.load_finished_sources)?;
97 }
98 if !self.vector_index_adds.is_empty() {
99 struct_ser.serialize_field("vectorIndexAdds", &self.vector_index_adds)?;
100 }
101 if !self.cdc_table_backfill_progress.is_empty() {
102 struct_ser.serialize_field("cdcTableBackfillProgress", &self.cdc_table_backfill_progress)?;
103 }
104 if !self.truncate_tables.is_empty() {
105 struct_ser.serialize_field("truncateTables", &self.truncate_tables)?;
106 }
107 if !self.refresh_finished_tables.is_empty() {
108 struct_ser.serialize_field("refreshFinishedTables", &self.refresh_finished_tables)?;
109 }
110 if !self.list_finished_sources.is_empty() {
111 struct_ser.serialize_field("listFinishedSources", &self.list_finished_sources)?;
112 }
113 if !self.cdc_source_offset_updated.is_empty() {
114 struct_ser.serialize_field("cdcSourceOffsetUpdated", &self.cdc_source_offset_updated)?;
115 }
116 if !self.iceberg_pk_index_sink_metadata.is_empty() {
117 struct_ser.serialize_field("icebergPkIndexSinkMetadata", &self.iceberg_pk_index_sink_metadata)?;
118 }
119 struct_ser.end()
120 }
121}
122impl<'de> serde::Deserialize<'de> for BarrierCompleteResponse {
123 #[allow(deprecated)]
124 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
125 where
126 D: serde::Deserializer<'de>,
127 {
128 const FIELDS: &[&str] = &[
129 "request_id",
130 "requestId",
131 "status",
132 "create_mview_progress",
133 "createMviewProgress",
134 "synced_sstables",
135 "syncedSstables",
136 "worker_id",
137 "workerId",
138 "table_watermarks",
139 "tableWatermarks",
140 "old_value_sstables",
141 "oldValueSstables",
142 "partial_graph_id",
143 "partialGraphId",
144 "epoch",
145 "load_finished_sources",
146 "loadFinishedSources",
147 "vector_index_adds",
148 "vectorIndexAdds",
149 "cdc_table_backfill_progress",
150 "cdcTableBackfillProgress",
151 "truncate_tables",
152 "truncateTables",
153 "refresh_finished_tables",
154 "refreshFinishedTables",
155 "list_finished_sources",
156 "listFinishedSources",
157 "cdc_source_offset_updated",
158 "cdcSourceOffsetUpdated",
159 "iceberg_pk_index_sink_metadata",
160 "icebergPkIndexSinkMetadata",
161 ];
162
163 #[allow(clippy::enum_variant_names)]
164 enum GeneratedField {
165 RequestId,
166 Status,
167 CreateMviewProgress,
168 SyncedSstables,
169 WorkerId,
170 TableWatermarks,
171 OldValueSstables,
172 PartialGraphId,
173 Epoch,
174 LoadFinishedSources,
175 VectorIndexAdds,
176 CdcTableBackfillProgress,
177 TruncateTables,
178 RefreshFinishedTables,
179 ListFinishedSources,
180 CdcSourceOffsetUpdated,
181 IcebergPkIndexSinkMetadata,
182 }
183 impl<'de> serde::Deserialize<'de> for GeneratedField {
184 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
185 where
186 D: serde::Deserializer<'de>,
187 {
188 struct GeneratedVisitor;
189
190 impl serde::de::Visitor<'_> for GeneratedVisitor {
191 type Value = GeneratedField;
192
193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
194 write!(formatter, "expected one of: {:?}", &FIELDS)
195 }
196
197 #[allow(unused_variables)]
198 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
199 where
200 E: serde::de::Error,
201 {
202 match value {
203 "requestId" | "request_id" => Ok(GeneratedField::RequestId),
204 "status" => Ok(GeneratedField::Status),
205 "createMviewProgress" | "create_mview_progress" => Ok(GeneratedField::CreateMviewProgress),
206 "syncedSstables" | "synced_sstables" => Ok(GeneratedField::SyncedSstables),
207 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
208 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
209 "oldValueSstables" | "old_value_sstables" => Ok(GeneratedField::OldValueSstables),
210 "partialGraphId" | "partial_graph_id" => Ok(GeneratedField::PartialGraphId),
211 "epoch" => Ok(GeneratedField::Epoch),
212 "loadFinishedSources" | "load_finished_sources" => Ok(GeneratedField::LoadFinishedSources),
213 "vectorIndexAdds" | "vector_index_adds" => Ok(GeneratedField::VectorIndexAdds),
214 "cdcTableBackfillProgress" | "cdc_table_backfill_progress" => Ok(GeneratedField::CdcTableBackfillProgress),
215 "truncateTables" | "truncate_tables" => Ok(GeneratedField::TruncateTables),
216 "refreshFinishedTables" | "refresh_finished_tables" => Ok(GeneratedField::RefreshFinishedTables),
217 "listFinishedSources" | "list_finished_sources" => Ok(GeneratedField::ListFinishedSources),
218 "cdcSourceOffsetUpdated" | "cdc_source_offset_updated" => Ok(GeneratedField::CdcSourceOffsetUpdated),
219 "icebergPkIndexSinkMetadata" | "iceberg_pk_index_sink_metadata" => Ok(GeneratedField::IcebergPkIndexSinkMetadata),
220 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
221 }
222 }
223 }
224 deserializer.deserialize_identifier(GeneratedVisitor)
225 }
226 }
227 struct GeneratedVisitor;
228 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
229 type Value = BarrierCompleteResponse;
230
231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
232 formatter.write_str("struct stream_service.BarrierCompleteResponse")
233 }
234
235 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierCompleteResponse, V::Error>
236 where
237 V: serde::de::MapAccess<'de>,
238 {
239 let mut request_id__ = None;
240 let mut status__ = None;
241 let mut create_mview_progress__ = None;
242 let mut synced_sstables__ = None;
243 let mut worker_id__ = None;
244 let mut table_watermarks__ = None;
245 let mut old_value_sstables__ = None;
246 let mut partial_graph_id__ = None;
247 let mut epoch__ = None;
248 let mut load_finished_sources__ = None;
249 let mut vector_index_adds__ = None;
250 let mut cdc_table_backfill_progress__ = None;
251 let mut truncate_tables__ = None;
252 let mut refresh_finished_tables__ = None;
253 let mut list_finished_sources__ = None;
254 let mut cdc_source_offset_updated__ = None;
255 let mut iceberg_pk_index_sink_metadata__ = None;
256 while let Some(k) = map_.next_key()? {
257 match k {
258 GeneratedField::RequestId => {
259 if request_id__.is_some() {
260 return Err(serde::de::Error::duplicate_field("requestId"));
261 }
262 request_id__ = Some(map_.next_value()?);
263 }
264 GeneratedField::Status => {
265 if status__.is_some() {
266 return Err(serde::de::Error::duplicate_field("status"));
267 }
268 status__ = map_.next_value()?;
269 }
270 GeneratedField::CreateMviewProgress => {
271 if create_mview_progress__.is_some() {
272 return Err(serde::de::Error::duplicate_field("createMviewProgress"));
273 }
274 create_mview_progress__ = Some(map_.next_value()?);
275 }
276 GeneratedField::SyncedSstables => {
277 if synced_sstables__.is_some() {
278 return Err(serde::de::Error::duplicate_field("syncedSstables"));
279 }
280 synced_sstables__ = Some(map_.next_value()?);
281 }
282 GeneratedField::WorkerId => {
283 if worker_id__.is_some() {
284 return Err(serde::de::Error::duplicate_field("workerId"));
285 }
286 worker_id__ =
287 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
288 ;
289 }
290 GeneratedField::TableWatermarks => {
291 if table_watermarks__.is_some() {
292 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
293 }
294 table_watermarks__ = Some(
295 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
296 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
297 );
298 }
299 GeneratedField::OldValueSstables => {
300 if old_value_sstables__.is_some() {
301 return Err(serde::de::Error::duplicate_field("oldValueSstables"));
302 }
303 old_value_sstables__ = Some(map_.next_value()?);
304 }
305 GeneratedField::PartialGraphId => {
306 if partial_graph_id__.is_some() {
307 return Err(serde::de::Error::duplicate_field("partialGraphId"));
308 }
309 partial_graph_id__ =
310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
311 ;
312 }
313 GeneratedField::Epoch => {
314 if epoch__.is_some() {
315 return Err(serde::de::Error::duplicate_field("epoch"));
316 }
317 epoch__ =
318 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
319 ;
320 }
321 GeneratedField::LoadFinishedSources => {
322 if load_finished_sources__.is_some() {
323 return Err(serde::de::Error::duplicate_field("loadFinishedSources"));
324 }
325 load_finished_sources__ = Some(map_.next_value()?);
326 }
327 GeneratedField::VectorIndexAdds => {
328 if vector_index_adds__.is_some() {
329 return Err(serde::de::Error::duplicate_field("vectorIndexAdds"));
330 }
331 vector_index_adds__ = Some(
332 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
333 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
334 );
335 }
336 GeneratedField::CdcTableBackfillProgress => {
337 if cdc_table_backfill_progress__.is_some() {
338 return Err(serde::de::Error::duplicate_field("cdcTableBackfillProgress"));
339 }
340 cdc_table_backfill_progress__ = Some(map_.next_value()?);
341 }
342 GeneratedField::TruncateTables => {
343 if truncate_tables__.is_some() {
344 return Err(serde::de::Error::duplicate_field("truncateTables"));
345 }
346 truncate_tables__ =
347 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
348 .into_iter().map(|x| x.0).collect())
349 ;
350 }
351 GeneratedField::RefreshFinishedTables => {
352 if refresh_finished_tables__.is_some() {
353 return Err(serde::de::Error::duplicate_field("refreshFinishedTables"));
354 }
355 refresh_finished_tables__ =
356 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
357 .into_iter().map(|x| x.0).collect())
358 ;
359 }
360 GeneratedField::ListFinishedSources => {
361 if list_finished_sources__.is_some() {
362 return Err(serde::de::Error::duplicate_field("listFinishedSources"));
363 }
364 list_finished_sources__ = Some(map_.next_value()?);
365 }
366 GeneratedField::CdcSourceOffsetUpdated => {
367 if cdc_source_offset_updated__.is_some() {
368 return Err(serde::de::Error::duplicate_field("cdcSourceOffsetUpdated"));
369 }
370 cdc_source_offset_updated__ = Some(map_.next_value()?);
371 }
372 GeneratedField::IcebergPkIndexSinkMetadata => {
373 if iceberg_pk_index_sink_metadata__.is_some() {
374 return Err(serde::de::Error::duplicate_field("icebergPkIndexSinkMetadata"));
375 }
376 iceberg_pk_index_sink_metadata__ = Some(map_.next_value()?);
377 }
378 }
379 }
380 Ok(BarrierCompleteResponse {
381 request_id: request_id__.unwrap_or_default(),
382 status: status__,
383 create_mview_progress: create_mview_progress__.unwrap_or_default(),
384 synced_sstables: synced_sstables__.unwrap_or_default(),
385 worker_id: worker_id__.unwrap_or_default(),
386 table_watermarks: table_watermarks__.unwrap_or_default(),
387 old_value_sstables: old_value_sstables__.unwrap_or_default(),
388 partial_graph_id: partial_graph_id__.unwrap_or_default(),
389 epoch: epoch__.unwrap_or_default(),
390 load_finished_sources: load_finished_sources__.unwrap_or_default(),
391 vector_index_adds: vector_index_adds__.unwrap_or_default(),
392 cdc_table_backfill_progress: cdc_table_backfill_progress__.unwrap_or_default(),
393 truncate_tables: truncate_tables__.unwrap_or_default(),
394 refresh_finished_tables: refresh_finished_tables__.unwrap_or_default(),
395 list_finished_sources: list_finished_sources__.unwrap_or_default(),
396 cdc_source_offset_updated: cdc_source_offset_updated__.unwrap_or_default(),
397 iceberg_pk_index_sink_metadata: iceberg_pk_index_sink_metadata__.unwrap_or_default(),
398 })
399 }
400 }
401 deserializer.deserialize_struct("stream_service.BarrierCompleteResponse", FIELDS, GeneratedVisitor)
402 }
403}
404impl serde::Serialize for barrier_complete_response::CdcSourceOffsetUpdated {
405 #[allow(deprecated)]
406 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
407 where
408 S: serde::Serializer,
409 {
410 use serde::ser::SerializeStruct;
411 let mut len = 0;
412 if self.reporter_actor_id != 0 {
413 len += 1;
414 }
415 if self.source_id != 0 {
416 len += 1;
417 }
418 let mut struct_ser = serializer.serialize_struct("stream_service.BarrierCompleteResponse.CdcSourceOffsetUpdated", len)?;
419 if self.reporter_actor_id != 0 {
420 struct_ser.serialize_field("reporterActorId", &self.reporter_actor_id)?;
421 }
422 if self.source_id != 0 {
423 struct_ser.serialize_field("sourceId", &self.source_id)?;
424 }
425 struct_ser.end()
426 }
427}
428impl<'de> serde::Deserialize<'de> for barrier_complete_response::CdcSourceOffsetUpdated {
429 #[allow(deprecated)]
430 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
431 where
432 D: serde::Deserializer<'de>,
433 {
434 const FIELDS: &[&str] = &[
435 "reporter_actor_id",
436 "reporterActorId",
437 "source_id",
438 "sourceId",
439 ];
440
441 #[allow(clippy::enum_variant_names)]
442 enum GeneratedField {
443 ReporterActorId,
444 SourceId,
445 }
446 impl<'de> serde::Deserialize<'de> for GeneratedField {
447 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
448 where
449 D: serde::Deserializer<'de>,
450 {
451 struct GeneratedVisitor;
452
453 impl serde::de::Visitor<'_> for GeneratedVisitor {
454 type Value = GeneratedField;
455
456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
457 write!(formatter, "expected one of: {:?}", &FIELDS)
458 }
459
460 #[allow(unused_variables)]
461 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
462 where
463 E: serde::de::Error,
464 {
465 match value {
466 "reporterActorId" | "reporter_actor_id" => Ok(GeneratedField::ReporterActorId),
467 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
468 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
469 }
470 }
471 }
472 deserializer.deserialize_identifier(GeneratedVisitor)
473 }
474 }
475 struct GeneratedVisitor;
476 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
477 type Value = barrier_complete_response::CdcSourceOffsetUpdated;
478
479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
480 formatter.write_str("struct stream_service.BarrierCompleteResponse.CdcSourceOffsetUpdated")
481 }
482
483 fn visit_map<V>(self, mut map_: V) -> std::result::Result<barrier_complete_response::CdcSourceOffsetUpdated, V::Error>
484 where
485 V: serde::de::MapAccess<'de>,
486 {
487 let mut reporter_actor_id__ = None;
488 let mut source_id__ = None;
489 while let Some(k) = map_.next_key()? {
490 match k {
491 GeneratedField::ReporterActorId => {
492 if reporter_actor_id__.is_some() {
493 return Err(serde::de::Error::duplicate_field("reporterActorId"));
494 }
495 reporter_actor_id__ =
496 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
497 ;
498 }
499 GeneratedField::SourceId => {
500 if source_id__.is_some() {
501 return Err(serde::de::Error::duplicate_field("sourceId"));
502 }
503 source_id__ =
504 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
505 ;
506 }
507 }
508 }
509 Ok(barrier_complete_response::CdcSourceOffsetUpdated {
510 reporter_actor_id: reporter_actor_id__.unwrap_or_default(),
511 source_id: source_id__.unwrap_or_default(),
512 })
513 }
514 }
515 deserializer.deserialize_struct("stream_service.BarrierCompleteResponse.CdcSourceOffsetUpdated", FIELDS, GeneratedVisitor)
516 }
517}
518impl serde::Serialize for barrier_complete_response::CdcTableBackfillProgress {
519 #[allow(deprecated)]
520 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
521 where
522 S: serde::Serializer,
523 {
524 use serde::ser::SerializeStruct;
525 let mut len = 0;
526 if self.actor_id != 0 {
527 len += 1;
528 }
529 if self.epoch != 0 {
530 len += 1;
531 }
532 if self.done {
533 len += 1;
534 }
535 if self.split_id_start_inclusive != 0 {
536 len += 1;
537 }
538 if self.split_id_end_inclusive != 0 {
539 len += 1;
540 }
541 if self.generation != 0 {
542 len += 1;
543 }
544 if self.fragment_id != 0 {
545 len += 1;
546 }
547 let mut struct_ser = serializer.serialize_struct("stream_service.BarrierCompleteResponse.CdcTableBackfillProgress", len)?;
548 if self.actor_id != 0 {
549 struct_ser.serialize_field("actorId", &self.actor_id)?;
550 }
551 if self.epoch != 0 {
552 #[allow(clippy::needless_borrow)]
553 #[allow(clippy::needless_borrows_for_generic_args)]
554 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
555 }
556 if self.done {
557 struct_ser.serialize_field("done", &self.done)?;
558 }
559 if self.split_id_start_inclusive != 0 {
560 #[allow(clippy::needless_borrow)]
561 #[allow(clippy::needless_borrows_for_generic_args)]
562 struct_ser.serialize_field("splitIdStartInclusive", ToString::to_string(&self.split_id_start_inclusive).as_str())?;
563 }
564 if self.split_id_end_inclusive != 0 {
565 #[allow(clippy::needless_borrow)]
566 #[allow(clippy::needless_borrows_for_generic_args)]
567 struct_ser.serialize_field("splitIdEndInclusive", ToString::to_string(&self.split_id_end_inclusive).as_str())?;
568 }
569 if self.generation != 0 {
570 #[allow(clippy::needless_borrow)]
571 #[allow(clippy::needless_borrows_for_generic_args)]
572 struct_ser.serialize_field("generation", ToString::to_string(&self.generation).as_str())?;
573 }
574 if self.fragment_id != 0 {
575 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
576 }
577 struct_ser.end()
578 }
579}
580impl<'de> serde::Deserialize<'de> for barrier_complete_response::CdcTableBackfillProgress {
581 #[allow(deprecated)]
582 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
583 where
584 D: serde::Deserializer<'de>,
585 {
586 const FIELDS: &[&str] = &[
587 "actor_id",
588 "actorId",
589 "epoch",
590 "done",
591 "split_id_start_inclusive",
592 "splitIdStartInclusive",
593 "split_id_end_inclusive",
594 "splitIdEndInclusive",
595 "generation",
596 "fragment_id",
597 "fragmentId",
598 ];
599
600 #[allow(clippy::enum_variant_names)]
601 enum GeneratedField {
602 ActorId,
603 Epoch,
604 Done,
605 SplitIdStartInclusive,
606 SplitIdEndInclusive,
607 Generation,
608 FragmentId,
609 }
610 impl<'de> serde::Deserialize<'de> for GeneratedField {
611 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
612 where
613 D: serde::Deserializer<'de>,
614 {
615 struct GeneratedVisitor;
616
617 impl serde::de::Visitor<'_> for GeneratedVisitor {
618 type Value = GeneratedField;
619
620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
621 write!(formatter, "expected one of: {:?}", &FIELDS)
622 }
623
624 #[allow(unused_variables)]
625 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
626 where
627 E: serde::de::Error,
628 {
629 match value {
630 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
631 "epoch" => Ok(GeneratedField::Epoch),
632 "done" => Ok(GeneratedField::Done),
633 "splitIdStartInclusive" | "split_id_start_inclusive" => Ok(GeneratedField::SplitIdStartInclusive),
634 "splitIdEndInclusive" | "split_id_end_inclusive" => Ok(GeneratedField::SplitIdEndInclusive),
635 "generation" => Ok(GeneratedField::Generation),
636 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
637 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
638 }
639 }
640 }
641 deserializer.deserialize_identifier(GeneratedVisitor)
642 }
643 }
644 struct GeneratedVisitor;
645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
646 type Value = barrier_complete_response::CdcTableBackfillProgress;
647
648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
649 formatter.write_str("struct stream_service.BarrierCompleteResponse.CdcTableBackfillProgress")
650 }
651
652 fn visit_map<V>(self, mut map_: V) -> std::result::Result<barrier_complete_response::CdcTableBackfillProgress, V::Error>
653 where
654 V: serde::de::MapAccess<'de>,
655 {
656 let mut actor_id__ = None;
657 let mut epoch__ = None;
658 let mut done__ = None;
659 let mut split_id_start_inclusive__ = None;
660 let mut split_id_end_inclusive__ = None;
661 let mut generation__ = None;
662 let mut fragment_id__ = None;
663 while let Some(k) = map_.next_key()? {
664 match k {
665 GeneratedField::ActorId => {
666 if actor_id__.is_some() {
667 return Err(serde::de::Error::duplicate_field("actorId"));
668 }
669 actor_id__ =
670 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
671 ;
672 }
673 GeneratedField::Epoch => {
674 if epoch__.is_some() {
675 return Err(serde::de::Error::duplicate_field("epoch"));
676 }
677 epoch__ =
678 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
679 ;
680 }
681 GeneratedField::Done => {
682 if done__.is_some() {
683 return Err(serde::de::Error::duplicate_field("done"));
684 }
685 done__ = Some(map_.next_value()?);
686 }
687 GeneratedField::SplitIdStartInclusive => {
688 if split_id_start_inclusive__.is_some() {
689 return Err(serde::de::Error::duplicate_field("splitIdStartInclusive"));
690 }
691 split_id_start_inclusive__ =
692 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
693 ;
694 }
695 GeneratedField::SplitIdEndInclusive => {
696 if split_id_end_inclusive__.is_some() {
697 return Err(serde::de::Error::duplicate_field("splitIdEndInclusive"));
698 }
699 split_id_end_inclusive__ =
700 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
701 ;
702 }
703 GeneratedField::Generation => {
704 if generation__.is_some() {
705 return Err(serde::de::Error::duplicate_field("generation"));
706 }
707 generation__ =
708 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
709 ;
710 }
711 GeneratedField::FragmentId => {
712 if fragment_id__.is_some() {
713 return Err(serde::de::Error::duplicate_field("fragmentId"));
714 }
715 fragment_id__ =
716 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
717 ;
718 }
719 }
720 }
721 Ok(barrier_complete_response::CdcTableBackfillProgress {
722 actor_id: actor_id__.unwrap_or_default(),
723 epoch: epoch__.unwrap_or_default(),
724 done: done__.unwrap_or_default(),
725 split_id_start_inclusive: split_id_start_inclusive__.unwrap_or_default(),
726 split_id_end_inclusive: split_id_end_inclusive__.unwrap_or_default(),
727 generation: generation__.unwrap_or_default(),
728 fragment_id: fragment_id__.unwrap_or_default(),
729 })
730 }
731 }
732 deserializer.deserialize_struct("stream_service.BarrierCompleteResponse.CdcTableBackfillProgress", FIELDS, GeneratedVisitor)
733 }
734}
735impl serde::Serialize for barrier_complete_response::CreateMviewProgress {
736 #[allow(deprecated)]
737 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
738 where
739 S: serde::Serializer,
740 {
741 use serde::ser::SerializeStruct;
742 let mut len = 0;
743 if self.backfill_actor_id != 0 {
744 len += 1;
745 }
746 if self.done {
747 len += 1;
748 }
749 if self.consumed_epoch != 0 {
750 len += 1;
751 }
752 if self.consumed_rows != 0 {
753 len += 1;
754 }
755 if self.pending_epoch_lag != 0 {
756 len += 1;
757 }
758 if self.buffered_rows != 0 {
759 len += 1;
760 }
761 if self.fragment_id != 0 {
762 len += 1;
763 }
764 let mut struct_ser = serializer.serialize_struct("stream_service.BarrierCompleteResponse.CreateMviewProgress", len)?;
765 if self.backfill_actor_id != 0 {
766 struct_ser.serialize_field("backfillActorId", &self.backfill_actor_id)?;
767 }
768 if self.done {
769 struct_ser.serialize_field("done", &self.done)?;
770 }
771 if self.consumed_epoch != 0 {
772 #[allow(clippy::needless_borrow)]
773 #[allow(clippy::needless_borrows_for_generic_args)]
774 struct_ser.serialize_field("consumedEpoch", ToString::to_string(&self.consumed_epoch).as_str())?;
775 }
776 if self.consumed_rows != 0 {
777 #[allow(clippy::needless_borrow)]
778 #[allow(clippy::needless_borrows_for_generic_args)]
779 struct_ser.serialize_field("consumedRows", ToString::to_string(&self.consumed_rows).as_str())?;
780 }
781 if self.pending_epoch_lag != 0 {
782 #[allow(clippy::needless_borrow)]
783 #[allow(clippy::needless_borrows_for_generic_args)]
784 struct_ser.serialize_field("pendingEpochLag", ToString::to_string(&self.pending_epoch_lag).as_str())?;
785 }
786 if self.buffered_rows != 0 {
787 #[allow(clippy::needless_borrow)]
788 #[allow(clippy::needless_borrows_for_generic_args)]
789 struct_ser.serialize_field("bufferedRows", ToString::to_string(&self.buffered_rows).as_str())?;
790 }
791 if self.fragment_id != 0 {
792 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
793 }
794 struct_ser.end()
795 }
796}
797impl<'de> serde::Deserialize<'de> for barrier_complete_response::CreateMviewProgress {
798 #[allow(deprecated)]
799 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
800 where
801 D: serde::Deserializer<'de>,
802 {
803 const FIELDS: &[&str] = &[
804 "backfill_actor_id",
805 "backfillActorId",
806 "done",
807 "consumed_epoch",
808 "consumedEpoch",
809 "consumed_rows",
810 "consumedRows",
811 "pending_epoch_lag",
812 "pendingEpochLag",
813 "buffered_rows",
814 "bufferedRows",
815 "fragment_id",
816 "fragmentId",
817 ];
818
819 #[allow(clippy::enum_variant_names)]
820 enum GeneratedField {
821 BackfillActorId,
822 Done,
823 ConsumedEpoch,
824 ConsumedRows,
825 PendingEpochLag,
826 BufferedRows,
827 FragmentId,
828 }
829 impl<'de> serde::Deserialize<'de> for GeneratedField {
830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
831 where
832 D: serde::Deserializer<'de>,
833 {
834 struct GeneratedVisitor;
835
836 impl serde::de::Visitor<'_> for GeneratedVisitor {
837 type Value = GeneratedField;
838
839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
840 write!(formatter, "expected one of: {:?}", &FIELDS)
841 }
842
843 #[allow(unused_variables)]
844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
845 where
846 E: serde::de::Error,
847 {
848 match value {
849 "backfillActorId" | "backfill_actor_id" => Ok(GeneratedField::BackfillActorId),
850 "done" => Ok(GeneratedField::Done),
851 "consumedEpoch" | "consumed_epoch" => Ok(GeneratedField::ConsumedEpoch),
852 "consumedRows" | "consumed_rows" => Ok(GeneratedField::ConsumedRows),
853 "pendingEpochLag" | "pending_epoch_lag" => Ok(GeneratedField::PendingEpochLag),
854 "bufferedRows" | "buffered_rows" => Ok(GeneratedField::BufferedRows),
855 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
856 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
857 }
858 }
859 }
860 deserializer.deserialize_identifier(GeneratedVisitor)
861 }
862 }
863 struct GeneratedVisitor;
864 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
865 type Value = barrier_complete_response::CreateMviewProgress;
866
867 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
868 formatter.write_str("struct stream_service.BarrierCompleteResponse.CreateMviewProgress")
869 }
870
871 fn visit_map<V>(self, mut map_: V) -> std::result::Result<barrier_complete_response::CreateMviewProgress, V::Error>
872 where
873 V: serde::de::MapAccess<'de>,
874 {
875 let mut backfill_actor_id__ = None;
876 let mut done__ = None;
877 let mut consumed_epoch__ = None;
878 let mut consumed_rows__ = None;
879 let mut pending_epoch_lag__ = None;
880 let mut buffered_rows__ = None;
881 let mut fragment_id__ = None;
882 while let Some(k) = map_.next_key()? {
883 match k {
884 GeneratedField::BackfillActorId => {
885 if backfill_actor_id__.is_some() {
886 return Err(serde::de::Error::duplicate_field("backfillActorId"));
887 }
888 backfill_actor_id__ =
889 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
890 ;
891 }
892 GeneratedField::Done => {
893 if done__.is_some() {
894 return Err(serde::de::Error::duplicate_field("done"));
895 }
896 done__ = Some(map_.next_value()?);
897 }
898 GeneratedField::ConsumedEpoch => {
899 if consumed_epoch__.is_some() {
900 return Err(serde::de::Error::duplicate_field("consumedEpoch"));
901 }
902 consumed_epoch__ =
903 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
904 ;
905 }
906 GeneratedField::ConsumedRows => {
907 if consumed_rows__.is_some() {
908 return Err(serde::de::Error::duplicate_field("consumedRows"));
909 }
910 consumed_rows__ =
911 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
912 ;
913 }
914 GeneratedField::PendingEpochLag => {
915 if pending_epoch_lag__.is_some() {
916 return Err(serde::de::Error::duplicate_field("pendingEpochLag"));
917 }
918 pending_epoch_lag__ =
919 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
920 ;
921 }
922 GeneratedField::BufferedRows => {
923 if buffered_rows__.is_some() {
924 return Err(serde::de::Error::duplicate_field("bufferedRows"));
925 }
926 buffered_rows__ =
927 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
928 ;
929 }
930 GeneratedField::FragmentId => {
931 if fragment_id__.is_some() {
932 return Err(serde::de::Error::duplicate_field("fragmentId"));
933 }
934 fragment_id__ =
935 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
936 ;
937 }
938 }
939 }
940 Ok(barrier_complete_response::CreateMviewProgress {
941 backfill_actor_id: backfill_actor_id__.unwrap_or_default(),
942 done: done__.unwrap_or_default(),
943 consumed_epoch: consumed_epoch__.unwrap_or_default(),
944 consumed_rows: consumed_rows__.unwrap_or_default(),
945 pending_epoch_lag: pending_epoch_lag__.unwrap_or_default(),
946 buffered_rows: buffered_rows__.unwrap_or_default(),
947 fragment_id: fragment_id__.unwrap_or_default(),
948 })
949 }
950 }
951 deserializer.deserialize_struct("stream_service.BarrierCompleteResponse.CreateMviewProgress", FIELDS, GeneratedVisitor)
952 }
953}
954impl serde::Serialize for barrier_complete_response::IcebergPkIndexSinkMetadata {
955 #[allow(deprecated)]
956 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
957 where
958 S: serde::Serializer,
959 {
960 use serde::ser::SerializeStruct;
961 let mut len = 0;
962 if self.reporter_actor_id != 0 {
963 len += 1;
964 }
965 if self.sink_id != 0 {
966 len += 1;
967 }
968 if self.prev_epoch != 0 {
969 len += 1;
970 }
971 if self.role != 0 {
972 len += 1;
973 }
974 if self.metadata.is_some() {
975 len += 1;
976 }
977 let mut struct_ser = serializer.serialize_struct("stream_service.BarrierCompleteResponse.IcebergPkIndexSinkMetadata", len)?;
978 if self.reporter_actor_id != 0 {
979 struct_ser.serialize_field("reporterActorId", &self.reporter_actor_id)?;
980 }
981 if self.sink_id != 0 {
982 struct_ser.serialize_field("sinkId", &self.sink_id)?;
983 }
984 if self.prev_epoch != 0 {
985 #[allow(clippy::needless_borrow)]
986 #[allow(clippy::needless_borrows_for_generic_args)]
987 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
988 }
989 if self.role != 0 {
990 let v = PbIcebergPkIndexSinkRole::try_from(self.role)
991 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.role)))?;
992 struct_ser.serialize_field("role", &v)?;
993 }
994 if let Some(v) = self.metadata.as_ref() {
995 struct_ser.serialize_field("metadata", v)?;
996 }
997 struct_ser.end()
998 }
999}
1000impl<'de> serde::Deserialize<'de> for barrier_complete_response::IcebergPkIndexSinkMetadata {
1001 #[allow(deprecated)]
1002 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1003 where
1004 D: serde::Deserializer<'de>,
1005 {
1006 const FIELDS: &[&str] = &[
1007 "reporter_actor_id",
1008 "reporterActorId",
1009 "sink_id",
1010 "sinkId",
1011 "prev_epoch",
1012 "prevEpoch",
1013 "role",
1014 "metadata",
1015 ];
1016
1017 #[allow(clippy::enum_variant_names)]
1018 enum GeneratedField {
1019 ReporterActorId,
1020 SinkId,
1021 PrevEpoch,
1022 Role,
1023 Metadata,
1024 }
1025 impl<'de> serde::Deserialize<'de> for GeneratedField {
1026 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1027 where
1028 D: serde::Deserializer<'de>,
1029 {
1030 struct GeneratedVisitor;
1031
1032 impl serde::de::Visitor<'_> for GeneratedVisitor {
1033 type Value = GeneratedField;
1034
1035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1036 write!(formatter, "expected one of: {:?}", &FIELDS)
1037 }
1038
1039 #[allow(unused_variables)]
1040 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1041 where
1042 E: serde::de::Error,
1043 {
1044 match value {
1045 "reporterActorId" | "reporter_actor_id" => Ok(GeneratedField::ReporterActorId),
1046 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1047 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
1048 "role" => Ok(GeneratedField::Role),
1049 "metadata" => Ok(GeneratedField::Metadata),
1050 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1051 }
1052 }
1053 }
1054 deserializer.deserialize_identifier(GeneratedVisitor)
1055 }
1056 }
1057 struct GeneratedVisitor;
1058 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1059 type Value = barrier_complete_response::IcebergPkIndexSinkMetadata;
1060
1061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1062 formatter.write_str("struct stream_service.BarrierCompleteResponse.IcebergPkIndexSinkMetadata")
1063 }
1064
1065 fn visit_map<V>(self, mut map_: V) -> std::result::Result<barrier_complete_response::IcebergPkIndexSinkMetadata, V::Error>
1066 where
1067 V: serde::de::MapAccess<'de>,
1068 {
1069 let mut reporter_actor_id__ = None;
1070 let mut sink_id__ = None;
1071 let mut prev_epoch__ = None;
1072 let mut role__ = None;
1073 let mut metadata__ = None;
1074 while let Some(k) = map_.next_key()? {
1075 match k {
1076 GeneratedField::ReporterActorId => {
1077 if reporter_actor_id__.is_some() {
1078 return Err(serde::de::Error::duplicate_field("reporterActorId"));
1079 }
1080 reporter_actor_id__ =
1081 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1082 ;
1083 }
1084 GeneratedField::SinkId => {
1085 if sink_id__.is_some() {
1086 return Err(serde::de::Error::duplicate_field("sinkId"));
1087 }
1088 sink_id__ =
1089 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1090 ;
1091 }
1092 GeneratedField::PrevEpoch => {
1093 if prev_epoch__.is_some() {
1094 return Err(serde::de::Error::duplicate_field("prevEpoch"));
1095 }
1096 prev_epoch__ =
1097 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1098 ;
1099 }
1100 GeneratedField::Role => {
1101 if role__.is_some() {
1102 return Err(serde::de::Error::duplicate_field("role"));
1103 }
1104 role__ = Some(map_.next_value::<PbIcebergPkIndexSinkRole>()? as i32);
1105 }
1106 GeneratedField::Metadata => {
1107 if metadata__.is_some() {
1108 return Err(serde::de::Error::duplicate_field("metadata"));
1109 }
1110 metadata__ = map_.next_value()?;
1111 }
1112 }
1113 }
1114 Ok(barrier_complete_response::IcebergPkIndexSinkMetadata {
1115 reporter_actor_id: reporter_actor_id__.unwrap_or_default(),
1116 sink_id: sink_id__.unwrap_or_default(),
1117 prev_epoch: prev_epoch__.unwrap_or_default(),
1118 role: role__.unwrap_or_default(),
1119 metadata: metadata__,
1120 })
1121 }
1122 }
1123 deserializer.deserialize_struct("stream_service.BarrierCompleteResponse.IcebergPkIndexSinkMetadata", FIELDS, GeneratedVisitor)
1124 }
1125}
1126impl serde::Serialize for barrier_complete_response::ListFinishedSource {
1127 #[allow(deprecated)]
1128 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1129 where
1130 S: serde::Serializer,
1131 {
1132 use serde::ser::SerializeStruct;
1133 let mut len = 0;
1134 if self.reporter_actor_id != 0 {
1135 len += 1;
1136 }
1137 if self.table_id != 0 {
1138 len += 1;
1139 }
1140 if self.associated_source_id != 0 {
1141 len += 1;
1142 }
1143 let mut struct_ser = serializer.serialize_struct("stream_service.BarrierCompleteResponse.ListFinishedSource", len)?;
1144 if self.reporter_actor_id != 0 {
1145 struct_ser.serialize_field("reporterActorId", &self.reporter_actor_id)?;
1146 }
1147 if self.table_id != 0 {
1148 struct_ser.serialize_field("tableId", &self.table_id)?;
1149 }
1150 if self.associated_source_id != 0 {
1151 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
1152 }
1153 struct_ser.end()
1154 }
1155}
1156impl<'de> serde::Deserialize<'de> for barrier_complete_response::ListFinishedSource {
1157 #[allow(deprecated)]
1158 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1159 where
1160 D: serde::Deserializer<'de>,
1161 {
1162 const FIELDS: &[&str] = &[
1163 "reporter_actor_id",
1164 "reporterActorId",
1165 "table_id",
1166 "tableId",
1167 "associated_source_id",
1168 "associatedSourceId",
1169 ];
1170
1171 #[allow(clippy::enum_variant_names)]
1172 enum GeneratedField {
1173 ReporterActorId,
1174 TableId,
1175 AssociatedSourceId,
1176 }
1177 impl<'de> serde::Deserialize<'de> for GeneratedField {
1178 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1179 where
1180 D: serde::Deserializer<'de>,
1181 {
1182 struct GeneratedVisitor;
1183
1184 impl serde::de::Visitor<'_> for GeneratedVisitor {
1185 type Value = GeneratedField;
1186
1187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1188 write!(formatter, "expected one of: {:?}", &FIELDS)
1189 }
1190
1191 #[allow(unused_variables)]
1192 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1193 where
1194 E: serde::de::Error,
1195 {
1196 match value {
1197 "reporterActorId" | "reporter_actor_id" => Ok(GeneratedField::ReporterActorId),
1198 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1199 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
1200 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1201 }
1202 }
1203 }
1204 deserializer.deserialize_identifier(GeneratedVisitor)
1205 }
1206 }
1207 struct GeneratedVisitor;
1208 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1209 type Value = barrier_complete_response::ListFinishedSource;
1210
1211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1212 formatter.write_str("struct stream_service.BarrierCompleteResponse.ListFinishedSource")
1213 }
1214
1215 fn visit_map<V>(self, mut map_: V) -> std::result::Result<barrier_complete_response::ListFinishedSource, V::Error>
1216 where
1217 V: serde::de::MapAccess<'de>,
1218 {
1219 let mut reporter_actor_id__ = None;
1220 let mut table_id__ = None;
1221 let mut associated_source_id__ = None;
1222 while let Some(k) = map_.next_key()? {
1223 match k {
1224 GeneratedField::ReporterActorId => {
1225 if reporter_actor_id__.is_some() {
1226 return Err(serde::de::Error::duplicate_field("reporterActorId"));
1227 }
1228 reporter_actor_id__ =
1229 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1230 ;
1231 }
1232 GeneratedField::TableId => {
1233 if table_id__.is_some() {
1234 return Err(serde::de::Error::duplicate_field("tableId"));
1235 }
1236 table_id__ =
1237 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1238 ;
1239 }
1240 GeneratedField::AssociatedSourceId => {
1241 if associated_source_id__.is_some() {
1242 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
1243 }
1244 associated_source_id__ =
1245 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1246 ;
1247 }
1248 }
1249 }
1250 Ok(barrier_complete_response::ListFinishedSource {
1251 reporter_actor_id: reporter_actor_id__.unwrap_or_default(),
1252 table_id: table_id__.unwrap_or_default(),
1253 associated_source_id: associated_source_id__.unwrap_or_default(),
1254 })
1255 }
1256 }
1257 deserializer.deserialize_struct("stream_service.BarrierCompleteResponse.ListFinishedSource", FIELDS, GeneratedVisitor)
1258 }
1259}
1260impl serde::Serialize for barrier_complete_response::LoadFinishedSource {
1261 #[allow(deprecated)]
1262 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1263 where
1264 S: serde::Serializer,
1265 {
1266 use serde::ser::SerializeStruct;
1267 let mut len = 0;
1268 if self.reporter_actor_id != 0 {
1269 len += 1;
1270 }
1271 if self.table_id != 0 {
1272 len += 1;
1273 }
1274 if self.associated_source_id != 0 {
1275 len += 1;
1276 }
1277 let mut struct_ser = serializer.serialize_struct("stream_service.BarrierCompleteResponse.LoadFinishedSource", len)?;
1278 if self.reporter_actor_id != 0 {
1279 struct_ser.serialize_field("reporterActorId", &self.reporter_actor_id)?;
1280 }
1281 if self.table_id != 0 {
1282 struct_ser.serialize_field("tableId", &self.table_id)?;
1283 }
1284 if self.associated_source_id != 0 {
1285 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
1286 }
1287 struct_ser.end()
1288 }
1289}
1290impl<'de> serde::Deserialize<'de> for barrier_complete_response::LoadFinishedSource {
1291 #[allow(deprecated)]
1292 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1293 where
1294 D: serde::Deserializer<'de>,
1295 {
1296 const FIELDS: &[&str] = &[
1297 "reporter_actor_id",
1298 "reporterActorId",
1299 "table_id",
1300 "tableId",
1301 "associated_source_id",
1302 "associatedSourceId",
1303 ];
1304
1305 #[allow(clippy::enum_variant_names)]
1306 enum GeneratedField {
1307 ReporterActorId,
1308 TableId,
1309 AssociatedSourceId,
1310 }
1311 impl<'de> serde::Deserialize<'de> for GeneratedField {
1312 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1313 where
1314 D: serde::Deserializer<'de>,
1315 {
1316 struct GeneratedVisitor;
1317
1318 impl serde::de::Visitor<'_> for GeneratedVisitor {
1319 type Value = GeneratedField;
1320
1321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1322 write!(formatter, "expected one of: {:?}", &FIELDS)
1323 }
1324
1325 #[allow(unused_variables)]
1326 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1327 where
1328 E: serde::de::Error,
1329 {
1330 match value {
1331 "reporterActorId" | "reporter_actor_id" => Ok(GeneratedField::ReporterActorId),
1332 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1333 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
1334 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1335 }
1336 }
1337 }
1338 deserializer.deserialize_identifier(GeneratedVisitor)
1339 }
1340 }
1341 struct GeneratedVisitor;
1342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1343 type Value = barrier_complete_response::LoadFinishedSource;
1344
1345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1346 formatter.write_str("struct stream_service.BarrierCompleteResponse.LoadFinishedSource")
1347 }
1348
1349 fn visit_map<V>(self, mut map_: V) -> std::result::Result<barrier_complete_response::LoadFinishedSource, V::Error>
1350 where
1351 V: serde::de::MapAccess<'de>,
1352 {
1353 let mut reporter_actor_id__ = None;
1354 let mut table_id__ = None;
1355 let mut associated_source_id__ = None;
1356 while let Some(k) = map_.next_key()? {
1357 match k {
1358 GeneratedField::ReporterActorId => {
1359 if reporter_actor_id__.is_some() {
1360 return Err(serde::de::Error::duplicate_field("reporterActorId"));
1361 }
1362 reporter_actor_id__ =
1363 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1364 ;
1365 }
1366 GeneratedField::TableId => {
1367 if table_id__.is_some() {
1368 return Err(serde::de::Error::duplicate_field("tableId"));
1369 }
1370 table_id__ =
1371 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1372 ;
1373 }
1374 GeneratedField::AssociatedSourceId => {
1375 if associated_source_id__.is_some() {
1376 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
1377 }
1378 associated_source_id__ =
1379 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1380 ;
1381 }
1382 }
1383 }
1384 Ok(barrier_complete_response::LoadFinishedSource {
1385 reporter_actor_id: reporter_actor_id__.unwrap_or_default(),
1386 table_id: table_id__.unwrap_or_default(),
1387 associated_source_id: associated_source_id__.unwrap_or_default(),
1388 })
1389 }
1390 }
1391 deserializer.deserialize_struct("stream_service.BarrierCompleteResponse.LoadFinishedSource", FIELDS, GeneratedVisitor)
1392 }
1393}
1394impl serde::Serialize for barrier_complete_response::LocalSstableInfo {
1395 #[allow(deprecated)]
1396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1397 where
1398 S: serde::Serializer,
1399 {
1400 use serde::ser::SerializeStruct;
1401 let mut len = 0;
1402 if self.sst.is_some() {
1403 len += 1;
1404 }
1405 if !self.table_stats_map.is_empty() {
1406 len += 1;
1407 }
1408 if self.created_at != 0 {
1409 len += 1;
1410 }
1411 let mut struct_ser = serializer.serialize_struct("stream_service.BarrierCompleteResponse.LocalSstableInfo", len)?;
1412 if let Some(v) = self.sst.as_ref() {
1413 struct_ser.serialize_field("sst", v)?;
1414 }
1415 if !self.table_stats_map.is_empty() {
1416 struct_ser.serialize_field("tableStatsMap", &self.table_stats_map)?;
1417 }
1418 if self.created_at != 0 {
1419 #[allow(clippy::needless_borrow)]
1420 #[allow(clippy::needless_borrows_for_generic_args)]
1421 struct_ser.serialize_field("createdAt", ToString::to_string(&self.created_at).as_str())?;
1422 }
1423 struct_ser.end()
1424 }
1425}
1426impl<'de> serde::Deserialize<'de> for barrier_complete_response::LocalSstableInfo {
1427 #[allow(deprecated)]
1428 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1429 where
1430 D: serde::Deserializer<'de>,
1431 {
1432 const FIELDS: &[&str] = &[
1433 "sst",
1434 "table_stats_map",
1435 "tableStatsMap",
1436 "created_at",
1437 "createdAt",
1438 ];
1439
1440 #[allow(clippy::enum_variant_names)]
1441 enum GeneratedField {
1442 Sst,
1443 TableStatsMap,
1444 CreatedAt,
1445 }
1446 impl<'de> serde::Deserialize<'de> for GeneratedField {
1447 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1448 where
1449 D: serde::Deserializer<'de>,
1450 {
1451 struct GeneratedVisitor;
1452
1453 impl serde::de::Visitor<'_> for GeneratedVisitor {
1454 type Value = GeneratedField;
1455
1456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1457 write!(formatter, "expected one of: {:?}", &FIELDS)
1458 }
1459
1460 #[allow(unused_variables)]
1461 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1462 where
1463 E: serde::de::Error,
1464 {
1465 match value {
1466 "sst" => Ok(GeneratedField::Sst),
1467 "tableStatsMap" | "table_stats_map" => Ok(GeneratedField::TableStatsMap),
1468 "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt),
1469 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1470 }
1471 }
1472 }
1473 deserializer.deserialize_identifier(GeneratedVisitor)
1474 }
1475 }
1476 struct GeneratedVisitor;
1477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1478 type Value = barrier_complete_response::LocalSstableInfo;
1479
1480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1481 formatter.write_str("struct stream_service.BarrierCompleteResponse.LocalSstableInfo")
1482 }
1483
1484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<barrier_complete_response::LocalSstableInfo, V::Error>
1485 where
1486 V: serde::de::MapAccess<'de>,
1487 {
1488 let mut sst__ = None;
1489 let mut table_stats_map__ = None;
1490 let mut created_at__ = None;
1491 while let Some(k) = map_.next_key()? {
1492 match k {
1493 GeneratedField::Sst => {
1494 if sst__.is_some() {
1495 return Err(serde::de::Error::duplicate_field("sst"));
1496 }
1497 sst__ = map_.next_value()?;
1498 }
1499 GeneratedField::TableStatsMap => {
1500 if table_stats_map__.is_some() {
1501 return Err(serde::de::Error::duplicate_field("tableStatsMap"));
1502 }
1503 table_stats_map__ = Some(
1504 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1505 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1506 );
1507 }
1508 GeneratedField::CreatedAt => {
1509 if created_at__.is_some() {
1510 return Err(serde::de::Error::duplicate_field("createdAt"));
1511 }
1512 created_at__ =
1513 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1514 ;
1515 }
1516 }
1517 }
1518 Ok(barrier_complete_response::LocalSstableInfo {
1519 sst: sst__,
1520 table_stats_map: table_stats_map__.unwrap_or_default(),
1521 created_at: created_at__.unwrap_or_default(),
1522 })
1523 }
1524 }
1525 deserializer.deserialize_struct("stream_service.BarrierCompleteResponse.LocalSstableInfo", FIELDS, GeneratedVisitor)
1526 }
1527}
1528impl serde::Serialize for GetMinUncommittedObjectIdRequest {
1529 #[allow(deprecated)]
1530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1531 where
1532 S: serde::Serializer,
1533 {
1534 use serde::ser::SerializeStruct;
1535 let len = 0;
1536 let struct_ser = serializer.serialize_struct("stream_service.GetMinUncommittedObjectIdRequest", len)?;
1537 struct_ser.end()
1538 }
1539}
1540impl<'de> serde::Deserialize<'de> for GetMinUncommittedObjectIdRequest {
1541 #[allow(deprecated)]
1542 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1543 where
1544 D: serde::Deserializer<'de>,
1545 {
1546 const FIELDS: &[&str] = &[
1547 ];
1548
1549 #[allow(clippy::enum_variant_names)]
1550 enum GeneratedField {
1551 }
1552 impl<'de> serde::Deserialize<'de> for GeneratedField {
1553 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1554 where
1555 D: serde::Deserializer<'de>,
1556 {
1557 struct GeneratedVisitor;
1558
1559 impl serde::de::Visitor<'_> for GeneratedVisitor {
1560 type Value = GeneratedField;
1561
1562 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1563 write!(formatter, "expected one of: {:?}", &FIELDS)
1564 }
1565
1566 #[allow(unused_variables)]
1567 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1568 where
1569 E: serde::de::Error,
1570 {
1571 Err(serde::de::Error::unknown_field(value, FIELDS))
1572 }
1573 }
1574 deserializer.deserialize_identifier(GeneratedVisitor)
1575 }
1576 }
1577 struct GeneratedVisitor;
1578 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1579 type Value = GetMinUncommittedObjectIdRequest;
1580
1581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1582 formatter.write_str("struct stream_service.GetMinUncommittedObjectIdRequest")
1583 }
1584
1585 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMinUncommittedObjectIdRequest, V::Error>
1586 where
1587 V: serde::de::MapAccess<'de>,
1588 {
1589 while map_.next_key::<GeneratedField>()?.is_some() {
1590 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1591 }
1592 Ok(GetMinUncommittedObjectIdRequest {
1593 })
1594 }
1595 }
1596 deserializer.deserialize_struct("stream_service.GetMinUncommittedObjectIdRequest", FIELDS, GeneratedVisitor)
1597 }
1598}
1599impl serde::Serialize for GetMinUncommittedObjectIdResponse {
1600 #[allow(deprecated)]
1601 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1602 where
1603 S: serde::Serializer,
1604 {
1605 use serde::ser::SerializeStruct;
1606 let mut len = 0;
1607 if self.min_uncommitted_object_id != 0 {
1608 len += 1;
1609 }
1610 let mut struct_ser = serializer.serialize_struct("stream_service.GetMinUncommittedObjectIdResponse", len)?;
1611 if self.min_uncommitted_object_id != 0 {
1612 #[allow(clippy::needless_borrow)]
1613 #[allow(clippy::needless_borrows_for_generic_args)]
1614 struct_ser.serialize_field("minUncommittedObjectId", ToString::to_string(&self.min_uncommitted_object_id).as_str())?;
1615 }
1616 struct_ser.end()
1617 }
1618}
1619impl<'de> serde::Deserialize<'de> for GetMinUncommittedObjectIdResponse {
1620 #[allow(deprecated)]
1621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1622 where
1623 D: serde::Deserializer<'de>,
1624 {
1625 const FIELDS: &[&str] = &[
1626 "min_uncommitted_object_id",
1627 "minUncommittedObjectId",
1628 ];
1629
1630 #[allow(clippy::enum_variant_names)]
1631 enum GeneratedField {
1632 MinUncommittedObjectId,
1633 }
1634 impl<'de> serde::Deserialize<'de> for GeneratedField {
1635 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1636 where
1637 D: serde::Deserializer<'de>,
1638 {
1639 struct GeneratedVisitor;
1640
1641 impl serde::de::Visitor<'_> for GeneratedVisitor {
1642 type Value = GeneratedField;
1643
1644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1645 write!(formatter, "expected one of: {:?}", &FIELDS)
1646 }
1647
1648 #[allow(unused_variables)]
1649 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1650 where
1651 E: serde::de::Error,
1652 {
1653 match value {
1654 "minUncommittedObjectId" | "min_uncommitted_object_id" => Ok(GeneratedField::MinUncommittedObjectId),
1655 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1656 }
1657 }
1658 }
1659 deserializer.deserialize_identifier(GeneratedVisitor)
1660 }
1661 }
1662 struct GeneratedVisitor;
1663 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1664 type Value = GetMinUncommittedObjectIdResponse;
1665
1666 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1667 formatter.write_str("struct stream_service.GetMinUncommittedObjectIdResponse")
1668 }
1669
1670 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMinUncommittedObjectIdResponse, V::Error>
1671 where
1672 V: serde::de::MapAccess<'de>,
1673 {
1674 let mut min_uncommitted_object_id__ = None;
1675 while let Some(k) = map_.next_key()? {
1676 match k {
1677 GeneratedField::MinUncommittedObjectId => {
1678 if min_uncommitted_object_id__.is_some() {
1679 return Err(serde::de::Error::duplicate_field("minUncommittedObjectId"));
1680 }
1681 min_uncommitted_object_id__ =
1682 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1683 ;
1684 }
1685 }
1686 }
1687 Ok(GetMinUncommittedObjectIdResponse {
1688 min_uncommitted_object_id: min_uncommitted_object_id__.unwrap_or_default(),
1689 })
1690 }
1691 }
1692 deserializer.deserialize_struct("stream_service.GetMinUncommittedObjectIdResponse", FIELDS, GeneratedVisitor)
1693 }
1694}
1695impl serde::Serialize for InjectBarrierRequest {
1696 #[allow(deprecated)]
1697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1698 where
1699 S: serde::Serializer,
1700 {
1701 use serde::ser::SerializeStruct;
1702 let mut len = 0;
1703 if !self.request_id.is_empty() {
1704 len += 1;
1705 }
1706 if self.barrier.is_some() {
1707 len += 1;
1708 }
1709 if !self.actor_ids_to_collect.is_empty() {
1710 len += 1;
1711 }
1712 if !self.table_ids_to_sync.is_empty() {
1713 len += 1;
1714 }
1715 if self.partial_graph_id != 0 {
1716 len += 1;
1717 }
1718 if !self.actors_to_build.is_empty() {
1719 len += 1;
1720 }
1721 let mut struct_ser = serializer.serialize_struct("stream_service.InjectBarrierRequest", len)?;
1722 if !self.request_id.is_empty() {
1723 struct_ser.serialize_field("requestId", &self.request_id)?;
1724 }
1725 if let Some(v) = self.barrier.as_ref() {
1726 struct_ser.serialize_field("barrier", v)?;
1727 }
1728 if !self.actor_ids_to_collect.is_empty() {
1729 struct_ser.serialize_field("actorIdsToCollect", &self.actor_ids_to_collect)?;
1730 }
1731 if !self.table_ids_to_sync.is_empty() {
1732 struct_ser.serialize_field("tableIdsToSync", &self.table_ids_to_sync)?;
1733 }
1734 if self.partial_graph_id != 0 {
1735 #[allow(clippy::needless_borrow)]
1736 #[allow(clippy::needless_borrows_for_generic_args)]
1737 struct_ser.serialize_field("partialGraphId", ToString::to_string(&self.partial_graph_id).as_str())?;
1738 }
1739 if !self.actors_to_build.is_empty() {
1740 struct_ser.serialize_field("actorsToBuild", &self.actors_to_build)?;
1741 }
1742 struct_ser.end()
1743 }
1744}
1745impl<'de> serde::Deserialize<'de> for InjectBarrierRequest {
1746 #[allow(deprecated)]
1747 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1748 where
1749 D: serde::Deserializer<'de>,
1750 {
1751 const FIELDS: &[&str] = &[
1752 "request_id",
1753 "requestId",
1754 "barrier",
1755 "actor_ids_to_collect",
1756 "actorIdsToCollect",
1757 "table_ids_to_sync",
1758 "tableIdsToSync",
1759 "partial_graph_id",
1760 "partialGraphId",
1761 "actors_to_build",
1762 "actorsToBuild",
1763 ];
1764
1765 #[allow(clippy::enum_variant_names)]
1766 enum GeneratedField {
1767 RequestId,
1768 Barrier,
1769 ActorIdsToCollect,
1770 TableIdsToSync,
1771 PartialGraphId,
1772 ActorsToBuild,
1773 }
1774 impl<'de> serde::Deserialize<'de> for GeneratedField {
1775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1776 where
1777 D: serde::Deserializer<'de>,
1778 {
1779 struct GeneratedVisitor;
1780
1781 impl serde::de::Visitor<'_> for GeneratedVisitor {
1782 type Value = GeneratedField;
1783
1784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1785 write!(formatter, "expected one of: {:?}", &FIELDS)
1786 }
1787
1788 #[allow(unused_variables)]
1789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1790 where
1791 E: serde::de::Error,
1792 {
1793 match value {
1794 "requestId" | "request_id" => Ok(GeneratedField::RequestId),
1795 "barrier" => Ok(GeneratedField::Barrier),
1796 "actorIdsToCollect" | "actor_ids_to_collect" => Ok(GeneratedField::ActorIdsToCollect),
1797 "tableIdsToSync" | "table_ids_to_sync" => Ok(GeneratedField::TableIdsToSync),
1798 "partialGraphId" | "partial_graph_id" => Ok(GeneratedField::PartialGraphId),
1799 "actorsToBuild" | "actors_to_build" => Ok(GeneratedField::ActorsToBuild),
1800 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1801 }
1802 }
1803 }
1804 deserializer.deserialize_identifier(GeneratedVisitor)
1805 }
1806 }
1807 struct GeneratedVisitor;
1808 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1809 type Value = InjectBarrierRequest;
1810
1811 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1812 formatter.write_str("struct stream_service.InjectBarrierRequest")
1813 }
1814
1815 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectBarrierRequest, V::Error>
1816 where
1817 V: serde::de::MapAccess<'de>,
1818 {
1819 let mut request_id__ = None;
1820 let mut barrier__ = None;
1821 let mut actor_ids_to_collect__ = None;
1822 let mut table_ids_to_sync__ = None;
1823 let mut partial_graph_id__ = None;
1824 let mut actors_to_build__ = None;
1825 while let Some(k) = map_.next_key()? {
1826 match k {
1827 GeneratedField::RequestId => {
1828 if request_id__.is_some() {
1829 return Err(serde::de::Error::duplicate_field("requestId"));
1830 }
1831 request_id__ = Some(map_.next_value()?);
1832 }
1833 GeneratedField::Barrier => {
1834 if barrier__.is_some() {
1835 return Err(serde::de::Error::duplicate_field("barrier"));
1836 }
1837 barrier__ = map_.next_value()?;
1838 }
1839 GeneratedField::ActorIdsToCollect => {
1840 if actor_ids_to_collect__.is_some() {
1841 return Err(serde::de::Error::duplicate_field("actorIdsToCollect"));
1842 }
1843 actor_ids_to_collect__ =
1844 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1845 .into_iter().map(|x| x.0).collect())
1846 ;
1847 }
1848 GeneratedField::TableIdsToSync => {
1849 if table_ids_to_sync__.is_some() {
1850 return Err(serde::de::Error::duplicate_field("tableIdsToSync"));
1851 }
1852 table_ids_to_sync__ =
1853 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1854 .into_iter().map(|x| x.0).collect())
1855 ;
1856 }
1857 GeneratedField::PartialGraphId => {
1858 if partial_graph_id__.is_some() {
1859 return Err(serde::de::Error::duplicate_field("partialGraphId"));
1860 }
1861 partial_graph_id__ =
1862 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1863 ;
1864 }
1865 GeneratedField::ActorsToBuild => {
1866 if actors_to_build__.is_some() {
1867 return Err(serde::de::Error::duplicate_field("actorsToBuild"));
1868 }
1869 actors_to_build__ = Some(map_.next_value()?);
1870 }
1871 }
1872 }
1873 Ok(InjectBarrierRequest {
1874 request_id: request_id__.unwrap_or_default(),
1875 barrier: barrier__,
1876 actor_ids_to_collect: actor_ids_to_collect__.unwrap_or_default(),
1877 table_ids_to_sync: table_ids_to_sync__.unwrap_or_default(),
1878 partial_graph_id: partial_graph_id__.unwrap_or_default(),
1879 actors_to_build: actors_to_build__.unwrap_or_default(),
1880 })
1881 }
1882 }
1883 deserializer.deserialize_struct("stream_service.InjectBarrierRequest", FIELDS, GeneratedVisitor)
1884 }
1885}
1886impl serde::Serialize for inject_barrier_request::BuildActorInfo {
1887 #[allow(deprecated)]
1888 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1889 where
1890 S: serde::Serializer,
1891 {
1892 use serde::ser::SerializeStruct;
1893 let mut len = 0;
1894 if self.actor_id != 0 {
1895 len += 1;
1896 }
1897 if !self.fragment_upstreams.is_empty() {
1898 len += 1;
1899 }
1900 if !self.dispatchers.is_empty() {
1901 len += 1;
1902 }
1903 if self.vnode_bitmap.is_some() {
1904 len += 1;
1905 }
1906 if !self.mview_definition.is_empty() {
1907 len += 1;
1908 }
1909 if self.expr_context.is_some() {
1910 len += 1;
1911 }
1912 if !self.config_override.is_empty() {
1913 len += 1;
1914 }
1915 if !self.initial_subscriber_ids.is_empty() {
1916 len += 1;
1917 }
1918 let mut struct_ser = serializer.serialize_struct("stream_service.InjectBarrierRequest.BuildActorInfo", len)?;
1919 if self.actor_id != 0 {
1920 struct_ser.serialize_field("actorId", &self.actor_id)?;
1921 }
1922 if !self.fragment_upstreams.is_empty() {
1923 struct_ser.serialize_field("fragmentUpstreams", &self.fragment_upstreams)?;
1924 }
1925 if !self.dispatchers.is_empty() {
1926 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
1927 }
1928 if let Some(v) = self.vnode_bitmap.as_ref() {
1929 struct_ser.serialize_field("vnodeBitmap", v)?;
1930 }
1931 if !self.mview_definition.is_empty() {
1932 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
1933 }
1934 if let Some(v) = self.expr_context.as_ref() {
1935 struct_ser.serialize_field("exprContext", v)?;
1936 }
1937 if !self.config_override.is_empty() {
1938 struct_ser.serialize_field("configOverride", &self.config_override)?;
1939 }
1940 if !self.initial_subscriber_ids.is_empty() {
1941 struct_ser.serialize_field("initialSubscriberIds", &self.initial_subscriber_ids)?;
1942 }
1943 struct_ser.end()
1944 }
1945}
1946impl<'de> serde::Deserialize<'de> for inject_barrier_request::BuildActorInfo {
1947 #[allow(deprecated)]
1948 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1949 where
1950 D: serde::Deserializer<'de>,
1951 {
1952 const FIELDS: &[&str] = &[
1953 "actor_id",
1954 "actorId",
1955 "fragment_upstreams",
1956 "fragmentUpstreams",
1957 "dispatchers",
1958 "vnode_bitmap",
1959 "vnodeBitmap",
1960 "mview_definition",
1961 "mviewDefinition",
1962 "expr_context",
1963 "exprContext",
1964 "config_override",
1965 "configOverride",
1966 "initial_subscriber_ids",
1967 "initialSubscriberIds",
1968 ];
1969
1970 #[allow(clippy::enum_variant_names)]
1971 enum GeneratedField {
1972 ActorId,
1973 FragmentUpstreams,
1974 Dispatchers,
1975 VnodeBitmap,
1976 MviewDefinition,
1977 ExprContext,
1978 ConfigOverride,
1979 InitialSubscriberIds,
1980 }
1981 impl<'de> serde::Deserialize<'de> for GeneratedField {
1982 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1983 where
1984 D: serde::Deserializer<'de>,
1985 {
1986 struct GeneratedVisitor;
1987
1988 impl serde::de::Visitor<'_> for GeneratedVisitor {
1989 type Value = GeneratedField;
1990
1991 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1992 write!(formatter, "expected one of: {:?}", &FIELDS)
1993 }
1994
1995 #[allow(unused_variables)]
1996 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1997 where
1998 E: serde::de::Error,
1999 {
2000 match value {
2001 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
2002 "fragmentUpstreams" | "fragment_upstreams" => Ok(GeneratedField::FragmentUpstreams),
2003 "dispatchers" => Ok(GeneratedField::Dispatchers),
2004 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
2005 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
2006 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
2007 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
2008 "initialSubscriberIds" | "initial_subscriber_ids" => Ok(GeneratedField::InitialSubscriberIds),
2009 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2010 }
2011 }
2012 }
2013 deserializer.deserialize_identifier(GeneratedVisitor)
2014 }
2015 }
2016 struct GeneratedVisitor;
2017 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2018 type Value = inject_barrier_request::BuildActorInfo;
2019
2020 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2021 formatter.write_str("struct stream_service.InjectBarrierRequest.BuildActorInfo")
2022 }
2023
2024 fn visit_map<V>(self, mut map_: V) -> std::result::Result<inject_barrier_request::BuildActorInfo, V::Error>
2025 where
2026 V: serde::de::MapAccess<'de>,
2027 {
2028 let mut actor_id__ = None;
2029 let mut fragment_upstreams__ = None;
2030 let mut dispatchers__ = None;
2031 let mut vnode_bitmap__ = None;
2032 let mut mview_definition__ = None;
2033 let mut expr_context__ = None;
2034 let mut config_override__ = None;
2035 let mut initial_subscriber_ids__ = None;
2036 while let Some(k) = map_.next_key()? {
2037 match k {
2038 GeneratedField::ActorId => {
2039 if actor_id__.is_some() {
2040 return Err(serde::de::Error::duplicate_field("actorId"));
2041 }
2042 actor_id__ =
2043 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2044 ;
2045 }
2046 GeneratedField::FragmentUpstreams => {
2047 if fragment_upstreams__.is_some() {
2048 return Err(serde::de::Error::duplicate_field("fragmentUpstreams"));
2049 }
2050 fragment_upstreams__ = Some(
2051 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2052 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2053 );
2054 }
2055 GeneratedField::Dispatchers => {
2056 if dispatchers__.is_some() {
2057 return Err(serde::de::Error::duplicate_field("dispatchers"));
2058 }
2059 dispatchers__ = Some(map_.next_value()?);
2060 }
2061 GeneratedField::VnodeBitmap => {
2062 if vnode_bitmap__.is_some() {
2063 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
2064 }
2065 vnode_bitmap__ = map_.next_value()?;
2066 }
2067 GeneratedField::MviewDefinition => {
2068 if mview_definition__.is_some() {
2069 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
2070 }
2071 mview_definition__ = Some(map_.next_value()?);
2072 }
2073 GeneratedField::ExprContext => {
2074 if expr_context__.is_some() {
2075 return Err(serde::de::Error::duplicate_field("exprContext"));
2076 }
2077 expr_context__ = map_.next_value()?;
2078 }
2079 GeneratedField::ConfigOverride => {
2080 if config_override__.is_some() {
2081 return Err(serde::de::Error::duplicate_field("configOverride"));
2082 }
2083 config_override__ = Some(map_.next_value()?);
2084 }
2085 GeneratedField::InitialSubscriberIds => {
2086 if initial_subscriber_ids__.is_some() {
2087 return Err(serde::de::Error::duplicate_field("initialSubscriberIds"));
2088 }
2089 initial_subscriber_ids__ =
2090 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2091 .into_iter().map(|x| x.0).collect())
2092 ;
2093 }
2094 }
2095 }
2096 Ok(inject_barrier_request::BuildActorInfo {
2097 actor_id: actor_id__.unwrap_or_default(),
2098 fragment_upstreams: fragment_upstreams__.unwrap_or_default(),
2099 dispatchers: dispatchers__.unwrap_or_default(),
2100 vnode_bitmap: vnode_bitmap__,
2101 mview_definition: mview_definition__.unwrap_or_default(),
2102 expr_context: expr_context__,
2103 config_override: config_override__.unwrap_or_default(),
2104 initial_subscriber_ids: initial_subscriber_ids__.unwrap_or_default(),
2105 })
2106 }
2107 }
2108 deserializer.deserialize_struct("stream_service.InjectBarrierRequest.BuildActorInfo", FIELDS, GeneratedVisitor)
2109 }
2110}
2111impl serde::Serialize for inject_barrier_request::build_actor_info::UpstreamActors {
2112 #[allow(deprecated)]
2113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2114 where
2115 S: serde::Serializer,
2116 {
2117 use serde::ser::SerializeStruct;
2118 let mut len = 0;
2119 if !self.actors.is_empty() {
2120 len += 1;
2121 }
2122 let mut struct_ser = serializer.serialize_struct("stream_service.InjectBarrierRequest.BuildActorInfo.UpstreamActors", len)?;
2123 if !self.actors.is_empty() {
2124 struct_ser.serialize_field("actors", &self.actors)?;
2125 }
2126 struct_ser.end()
2127 }
2128}
2129impl<'de> serde::Deserialize<'de> for inject_barrier_request::build_actor_info::UpstreamActors {
2130 #[allow(deprecated)]
2131 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2132 where
2133 D: serde::Deserializer<'de>,
2134 {
2135 const FIELDS: &[&str] = &[
2136 "actors",
2137 ];
2138
2139 #[allow(clippy::enum_variant_names)]
2140 enum GeneratedField {
2141 Actors,
2142 }
2143 impl<'de> serde::Deserialize<'de> for GeneratedField {
2144 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2145 where
2146 D: serde::Deserializer<'de>,
2147 {
2148 struct GeneratedVisitor;
2149
2150 impl serde::de::Visitor<'_> for GeneratedVisitor {
2151 type Value = GeneratedField;
2152
2153 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2154 write!(formatter, "expected one of: {:?}", &FIELDS)
2155 }
2156
2157 #[allow(unused_variables)]
2158 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2159 where
2160 E: serde::de::Error,
2161 {
2162 match value {
2163 "actors" => Ok(GeneratedField::Actors),
2164 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2165 }
2166 }
2167 }
2168 deserializer.deserialize_identifier(GeneratedVisitor)
2169 }
2170 }
2171 struct GeneratedVisitor;
2172 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2173 type Value = inject_barrier_request::build_actor_info::UpstreamActors;
2174
2175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2176 formatter.write_str("struct stream_service.InjectBarrierRequest.BuildActorInfo.UpstreamActors")
2177 }
2178
2179 fn visit_map<V>(self, mut map_: V) -> std::result::Result<inject_barrier_request::build_actor_info::UpstreamActors, V::Error>
2180 where
2181 V: serde::de::MapAccess<'de>,
2182 {
2183 let mut actors__ = None;
2184 while let Some(k) = map_.next_key()? {
2185 match k {
2186 GeneratedField::Actors => {
2187 if actors__.is_some() {
2188 return Err(serde::de::Error::duplicate_field("actors"));
2189 }
2190 actors__ = Some(map_.next_value()?);
2191 }
2192 }
2193 }
2194 Ok(inject_barrier_request::build_actor_info::UpstreamActors {
2195 actors: actors__.unwrap_or_default(),
2196 })
2197 }
2198 }
2199 deserializer.deserialize_struct("stream_service.InjectBarrierRequest.BuildActorInfo.UpstreamActors", FIELDS, GeneratedVisitor)
2200 }
2201}
2202impl serde::Serialize for inject_barrier_request::FragmentBuildActorInfo {
2203 #[allow(deprecated)]
2204 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2205 where
2206 S: serde::Serializer,
2207 {
2208 use serde::ser::SerializeStruct;
2209 let mut len = 0;
2210 if self.fragment_id != 0 {
2211 len += 1;
2212 }
2213 if self.node.is_some() {
2214 len += 1;
2215 }
2216 if !self.actors.is_empty() {
2217 len += 1;
2218 }
2219 let mut struct_ser = serializer.serialize_struct("stream_service.InjectBarrierRequest.FragmentBuildActorInfo", len)?;
2220 if self.fragment_id != 0 {
2221 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
2222 }
2223 if let Some(v) = self.node.as_ref() {
2224 struct_ser.serialize_field("node", v)?;
2225 }
2226 if !self.actors.is_empty() {
2227 struct_ser.serialize_field("actors", &self.actors)?;
2228 }
2229 struct_ser.end()
2230 }
2231}
2232impl<'de> serde::Deserialize<'de> for inject_barrier_request::FragmentBuildActorInfo {
2233 #[allow(deprecated)]
2234 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2235 where
2236 D: serde::Deserializer<'de>,
2237 {
2238 const FIELDS: &[&str] = &[
2239 "fragment_id",
2240 "fragmentId",
2241 "node",
2242 "actors",
2243 ];
2244
2245 #[allow(clippy::enum_variant_names)]
2246 enum GeneratedField {
2247 FragmentId,
2248 Node,
2249 Actors,
2250 }
2251 impl<'de> serde::Deserialize<'de> for GeneratedField {
2252 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2253 where
2254 D: serde::Deserializer<'de>,
2255 {
2256 struct GeneratedVisitor;
2257
2258 impl serde::de::Visitor<'_> for GeneratedVisitor {
2259 type Value = GeneratedField;
2260
2261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2262 write!(formatter, "expected one of: {:?}", &FIELDS)
2263 }
2264
2265 #[allow(unused_variables)]
2266 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2267 where
2268 E: serde::de::Error,
2269 {
2270 match value {
2271 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
2272 "node" => Ok(GeneratedField::Node),
2273 "actors" => Ok(GeneratedField::Actors),
2274 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2275 }
2276 }
2277 }
2278 deserializer.deserialize_identifier(GeneratedVisitor)
2279 }
2280 }
2281 struct GeneratedVisitor;
2282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2283 type Value = inject_barrier_request::FragmentBuildActorInfo;
2284
2285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2286 formatter.write_str("struct stream_service.InjectBarrierRequest.FragmentBuildActorInfo")
2287 }
2288
2289 fn visit_map<V>(self, mut map_: V) -> std::result::Result<inject_barrier_request::FragmentBuildActorInfo, V::Error>
2290 where
2291 V: serde::de::MapAccess<'de>,
2292 {
2293 let mut fragment_id__ = None;
2294 let mut node__ = None;
2295 let mut actors__ = None;
2296 while let Some(k) = map_.next_key()? {
2297 match k {
2298 GeneratedField::FragmentId => {
2299 if fragment_id__.is_some() {
2300 return Err(serde::de::Error::duplicate_field("fragmentId"));
2301 }
2302 fragment_id__ =
2303 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2304 ;
2305 }
2306 GeneratedField::Node => {
2307 if node__.is_some() {
2308 return Err(serde::de::Error::duplicate_field("node"));
2309 }
2310 node__ = map_.next_value()?;
2311 }
2312 GeneratedField::Actors => {
2313 if actors__.is_some() {
2314 return Err(serde::de::Error::duplicate_field("actors"));
2315 }
2316 actors__ = Some(map_.next_value()?);
2317 }
2318 }
2319 }
2320 Ok(inject_barrier_request::FragmentBuildActorInfo {
2321 fragment_id: fragment_id__.unwrap_or_default(),
2322 node: node__,
2323 actors: actors__.unwrap_or_default(),
2324 })
2325 }
2326 }
2327 deserializer.deserialize_struct("stream_service.InjectBarrierRequest.FragmentBuildActorInfo", FIELDS, GeneratedVisitor)
2328 }
2329}
2330impl serde::Serialize for PbIcebergPkIndexSinkRole {
2331 #[allow(deprecated)]
2332 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2333 where
2334 S: serde::Serializer,
2335 {
2336 let variant = match self {
2337 Self::Unspecified => "PB_ICEBERG_PK_INDEX_SINK_ROLE_UNSPECIFIED",
2338 Self::Writer => "PB_ICEBERG_PK_INDEX_SINK_ROLE_WRITER",
2339 Self::PositionDeleteMerger => "PB_ICEBERG_PK_INDEX_SINK_ROLE_POSITION_DELETE_MERGER",
2340 };
2341 serializer.serialize_str(variant)
2342 }
2343}
2344impl<'de> serde::Deserialize<'de> for PbIcebergPkIndexSinkRole {
2345 #[allow(deprecated)]
2346 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2347 where
2348 D: serde::Deserializer<'de>,
2349 {
2350 const FIELDS: &[&str] = &[
2351 "PB_ICEBERG_PK_INDEX_SINK_ROLE_UNSPECIFIED",
2352 "PB_ICEBERG_PK_INDEX_SINK_ROLE_WRITER",
2353 "PB_ICEBERG_PK_INDEX_SINK_ROLE_POSITION_DELETE_MERGER",
2354 ];
2355
2356 struct GeneratedVisitor;
2357
2358 impl serde::de::Visitor<'_> for GeneratedVisitor {
2359 type Value = PbIcebergPkIndexSinkRole;
2360
2361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2362 write!(formatter, "expected one of: {:?}", &FIELDS)
2363 }
2364
2365 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2366 where
2367 E: serde::de::Error,
2368 {
2369 i32::try_from(v)
2370 .ok()
2371 .and_then(|x| x.try_into().ok())
2372 .ok_or_else(|| {
2373 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2374 })
2375 }
2376
2377 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2378 where
2379 E: serde::de::Error,
2380 {
2381 i32::try_from(v)
2382 .ok()
2383 .and_then(|x| x.try_into().ok())
2384 .ok_or_else(|| {
2385 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2386 })
2387 }
2388
2389 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2390 where
2391 E: serde::de::Error,
2392 {
2393 match value {
2394 "PB_ICEBERG_PK_INDEX_SINK_ROLE_UNSPECIFIED" => Ok(PbIcebergPkIndexSinkRole::Unspecified),
2395 "PB_ICEBERG_PK_INDEX_SINK_ROLE_WRITER" => Ok(PbIcebergPkIndexSinkRole::Writer),
2396 "PB_ICEBERG_PK_INDEX_SINK_ROLE_POSITION_DELETE_MERGER" => Ok(PbIcebergPkIndexSinkRole::PositionDeleteMerger),
2397 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2398 }
2399 }
2400 }
2401 deserializer.deserialize_any(GeneratedVisitor)
2402 }
2403}
2404impl serde::Serialize for ScoredError {
2405 #[allow(deprecated)]
2406 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2407 where
2408 S: serde::Serializer,
2409 {
2410 use serde::ser::SerializeStruct;
2411 let mut len = 0;
2412 if !self.err_msg.is_empty() {
2413 len += 1;
2414 }
2415 if self.score != 0 {
2416 len += 1;
2417 }
2418 let mut struct_ser = serializer.serialize_struct("stream_service.ScoredError", len)?;
2419 if !self.err_msg.is_empty() {
2420 struct_ser.serialize_field("errMsg", &self.err_msg)?;
2421 }
2422 if self.score != 0 {
2423 struct_ser.serialize_field("score", &self.score)?;
2424 }
2425 struct_ser.end()
2426 }
2427}
2428impl<'de> serde::Deserialize<'de> for ScoredError {
2429 #[allow(deprecated)]
2430 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2431 where
2432 D: serde::Deserializer<'de>,
2433 {
2434 const FIELDS: &[&str] = &[
2435 "err_msg",
2436 "errMsg",
2437 "score",
2438 ];
2439
2440 #[allow(clippy::enum_variant_names)]
2441 enum GeneratedField {
2442 ErrMsg,
2443 Score,
2444 }
2445 impl<'de> serde::Deserialize<'de> for GeneratedField {
2446 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2447 where
2448 D: serde::Deserializer<'de>,
2449 {
2450 struct GeneratedVisitor;
2451
2452 impl serde::de::Visitor<'_> for GeneratedVisitor {
2453 type Value = GeneratedField;
2454
2455 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2456 write!(formatter, "expected one of: {:?}", &FIELDS)
2457 }
2458
2459 #[allow(unused_variables)]
2460 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2461 where
2462 E: serde::de::Error,
2463 {
2464 match value {
2465 "errMsg" | "err_msg" => Ok(GeneratedField::ErrMsg),
2466 "score" => Ok(GeneratedField::Score),
2467 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2468 }
2469 }
2470 }
2471 deserializer.deserialize_identifier(GeneratedVisitor)
2472 }
2473 }
2474 struct GeneratedVisitor;
2475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2476 type Value = ScoredError;
2477
2478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2479 formatter.write_str("struct stream_service.ScoredError")
2480 }
2481
2482 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ScoredError, V::Error>
2483 where
2484 V: serde::de::MapAccess<'de>,
2485 {
2486 let mut err_msg__ = None;
2487 let mut score__ = None;
2488 while let Some(k) = map_.next_key()? {
2489 match k {
2490 GeneratedField::ErrMsg => {
2491 if err_msg__.is_some() {
2492 return Err(serde::de::Error::duplicate_field("errMsg"));
2493 }
2494 err_msg__ = Some(map_.next_value()?);
2495 }
2496 GeneratedField::Score => {
2497 if score__.is_some() {
2498 return Err(serde::de::Error::duplicate_field("score"));
2499 }
2500 score__ =
2501 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2502 ;
2503 }
2504 }
2505 }
2506 Ok(ScoredError {
2507 err_msg: err_msg__.unwrap_or_default(),
2508 score: score__.unwrap_or_default(),
2509 })
2510 }
2511 }
2512 deserializer.deserialize_struct("stream_service.ScoredError", FIELDS, GeneratedVisitor)
2513 }
2514}
2515impl serde::Serialize for StreamingControlStreamRequest {
2516 #[allow(deprecated)]
2517 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2518 where
2519 S: serde::Serializer,
2520 {
2521 use serde::ser::SerializeStruct;
2522 let mut len = 0;
2523 if self.request.is_some() {
2524 len += 1;
2525 }
2526 let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamRequest", len)?;
2527 if let Some(v) = self.request.as_ref() {
2528 match v {
2529 streaming_control_stream_request::Request::Init(v) => {
2530 struct_ser.serialize_field("init", v)?;
2531 }
2532 streaming_control_stream_request::Request::InjectBarrier(v) => {
2533 struct_ser.serialize_field("injectBarrier", v)?;
2534 }
2535 streaming_control_stream_request::Request::RemovePartialGraph(v) => {
2536 struct_ser.serialize_field("removePartialGraph", v)?;
2537 }
2538 streaming_control_stream_request::Request::CreatePartialGraph(v) => {
2539 struct_ser.serialize_field("createPartialGraph", v)?;
2540 }
2541 streaming_control_stream_request::Request::ResetPartialGraphs(v) => {
2542 struct_ser.serialize_field("resetPartialGraphs", v)?;
2543 }
2544 }
2545 }
2546 struct_ser.end()
2547 }
2548}
2549impl<'de> serde::Deserialize<'de> for StreamingControlStreamRequest {
2550 #[allow(deprecated)]
2551 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2552 where
2553 D: serde::Deserializer<'de>,
2554 {
2555 const FIELDS: &[&str] = &[
2556 "init",
2557 "inject_barrier",
2558 "injectBarrier",
2559 "remove_partial_graph",
2560 "removePartialGraph",
2561 "create_partial_graph",
2562 "createPartialGraph",
2563 "reset_partial_graphs",
2564 "resetPartialGraphs",
2565 ];
2566
2567 #[allow(clippy::enum_variant_names)]
2568 enum GeneratedField {
2569 Init,
2570 InjectBarrier,
2571 RemovePartialGraph,
2572 CreatePartialGraph,
2573 ResetPartialGraphs,
2574 }
2575 impl<'de> serde::Deserialize<'de> for GeneratedField {
2576 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2577 where
2578 D: serde::Deserializer<'de>,
2579 {
2580 struct GeneratedVisitor;
2581
2582 impl serde::de::Visitor<'_> for GeneratedVisitor {
2583 type Value = GeneratedField;
2584
2585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2586 write!(formatter, "expected one of: {:?}", &FIELDS)
2587 }
2588
2589 #[allow(unused_variables)]
2590 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2591 where
2592 E: serde::de::Error,
2593 {
2594 match value {
2595 "init" => Ok(GeneratedField::Init),
2596 "injectBarrier" | "inject_barrier" => Ok(GeneratedField::InjectBarrier),
2597 "removePartialGraph" | "remove_partial_graph" => Ok(GeneratedField::RemovePartialGraph),
2598 "createPartialGraph" | "create_partial_graph" => Ok(GeneratedField::CreatePartialGraph),
2599 "resetPartialGraphs" | "reset_partial_graphs" => Ok(GeneratedField::ResetPartialGraphs),
2600 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2601 }
2602 }
2603 }
2604 deserializer.deserialize_identifier(GeneratedVisitor)
2605 }
2606 }
2607 struct GeneratedVisitor;
2608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2609 type Value = StreamingControlStreamRequest;
2610
2611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2612 formatter.write_str("struct stream_service.StreamingControlStreamRequest")
2613 }
2614
2615 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamingControlStreamRequest, V::Error>
2616 where
2617 V: serde::de::MapAccess<'de>,
2618 {
2619 let mut request__ = None;
2620 while let Some(k) = map_.next_key()? {
2621 match k {
2622 GeneratedField::Init => {
2623 if request__.is_some() {
2624 return Err(serde::de::Error::duplicate_field("init"));
2625 }
2626 request__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_request::Request::Init)
2627;
2628 }
2629 GeneratedField::InjectBarrier => {
2630 if request__.is_some() {
2631 return Err(serde::de::Error::duplicate_field("injectBarrier"));
2632 }
2633 request__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_request::Request::InjectBarrier)
2634;
2635 }
2636 GeneratedField::RemovePartialGraph => {
2637 if request__.is_some() {
2638 return Err(serde::de::Error::duplicate_field("removePartialGraph"));
2639 }
2640 request__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_request::Request::RemovePartialGraph)
2641;
2642 }
2643 GeneratedField::CreatePartialGraph => {
2644 if request__.is_some() {
2645 return Err(serde::de::Error::duplicate_field("createPartialGraph"));
2646 }
2647 request__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_request::Request::CreatePartialGraph)
2648;
2649 }
2650 GeneratedField::ResetPartialGraphs => {
2651 if request__.is_some() {
2652 return Err(serde::de::Error::duplicate_field("resetPartialGraphs"));
2653 }
2654 request__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_request::Request::ResetPartialGraphs)
2655;
2656 }
2657 }
2658 }
2659 Ok(StreamingControlStreamRequest {
2660 request: request__,
2661 })
2662 }
2663 }
2664 deserializer.deserialize_struct("stream_service.StreamingControlStreamRequest", FIELDS, GeneratedVisitor)
2665 }
2666}
2667impl serde::Serialize for streaming_control_stream_request::CreatePartialGraphRequest {
2668 #[allow(deprecated)]
2669 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2670 where
2671 S: serde::Serializer,
2672 {
2673 use serde::ser::SerializeStruct;
2674 let mut len = 0;
2675 if self.partial_graph_id != 0 {
2676 len += 1;
2677 }
2678 let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamRequest.CreatePartialGraphRequest", len)?;
2679 if self.partial_graph_id != 0 {
2680 #[allow(clippy::needless_borrow)]
2681 #[allow(clippy::needless_borrows_for_generic_args)]
2682 struct_ser.serialize_field("partialGraphId", ToString::to_string(&self.partial_graph_id).as_str())?;
2683 }
2684 struct_ser.end()
2685 }
2686}
2687impl<'de> serde::Deserialize<'de> for streaming_control_stream_request::CreatePartialGraphRequest {
2688 #[allow(deprecated)]
2689 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2690 where
2691 D: serde::Deserializer<'de>,
2692 {
2693 const FIELDS: &[&str] = &[
2694 "partial_graph_id",
2695 "partialGraphId",
2696 ];
2697
2698 #[allow(clippy::enum_variant_names)]
2699 enum GeneratedField {
2700 PartialGraphId,
2701 }
2702 impl<'de> serde::Deserialize<'de> for GeneratedField {
2703 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2704 where
2705 D: serde::Deserializer<'de>,
2706 {
2707 struct GeneratedVisitor;
2708
2709 impl serde::de::Visitor<'_> for GeneratedVisitor {
2710 type Value = GeneratedField;
2711
2712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2713 write!(formatter, "expected one of: {:?}", &FIELDS)
2714 }
2715
2716 #[allow(unused_variables)]
2717 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2718 where
2719 E: serde::de::Error,
2720 {
2721 match value {
2722 "partialGraphId" | "partial_graph_id" => Ok(GeneratedField::PartialGraphId),
2723 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2724 }
2725 }
2726 }
2727 deserializer.deserialize_identifier(GeneratedVisitor)
2728 }
2729 }
2730 struct GeneratedVisitor;
2731 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2732 type Value = streaming_control_stream_request::CreatePartialGraphRequest;
2733
2734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2735 formatter.write_str("struct stream_service.StreamingControlStreamRequest.CreatePartialGraphRequest")
2736 }
2737
2738 fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_request::CreatePartialGraphRequest, V::Error>
2739 where
2740 V: serde::de::MapAccess<'de>,
2741 {
2742 let mut partial_graph_id__ = None;
2743 while let Some(k) = map_.next_key()? {
2744 match k {
2745 GeneratedField::PartialGraphId => {
2746 if partial_graph_id__.is_some() {
2747 return Err(serde::de::Error::duplicate_field("partialGraphId"));
2748 }
2749 partial_graph_id__ =
2750 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2751 ;
2752 }
2753 }
2754 }
2755 Ok(streaming_control_stream_request::CreatePartialGraphRequest {
2756 partial_graph_id: partial_graph_id__.unwrap_or_default(),
2757 })
2758 }
2759 }
2760 deserializer.deserialize_struct("stream_service.StreamingControlStreamRequest.CreatePartialGraphRequest", FIELDS, GeneratedVisitor)
2761 }
2762}
2763impl serde::Serialize for streaming_control_stream_request::InitRequest {
2764 #[allow(deprecated)]
2765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2766 where
2767 S: serde::Serializer,
2768 {
2769 use serde::ser::SerializeStruct;
2770 let mut len = 0;
2771 if !self.term_id.is_empty() {
2772 len += 1;
2773 }
2774 let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamRequest.InitRequest", len)?;
2775 if !self.term_id.is_empty() {
2776 struct_ser.serialize_field("termId", &self.term_id)?;
2777 }
2778 struct_ser.end()
2779 }
2780}
2781impl<'de> serde::Deserialize<'de> for streaming_control_stream_request::InitRequest {
2782 #[allow(deprecated)]
2783 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2784 where
2785 D: serde::Deserializer<'de>,
2786 {
2787 const FIELDS: &[&str] = &[
2788 "term_id",
2789 "termId",
2790 ];
2791
2792 #[allow(clippy::enum_variant_names)]
2793 enum GeneratedField {
2794 TermId,
2795 }
2796 impl<'de> serde::Deserialize<'de> for GeneratedField {
2797 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2798 where
2799 D: serde::Deserializer<'de>,
2800 {
2801 struct GeneratedVisitor;
2802
2803 impl serde::de::Visitor<'_> for GeneratedVisitor {
2804 type Value = GeneratedField;
2805
2806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2807 write!(formatter, "expected one of: {:?}", &FIELDS)
2808 }
2809
2810 #[allow(unused_variables)]
2811 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2812 where
2813 E: serde::de::Error,
2814 {
2815 match value {
2816 "termId" | "term_id" => Ok(GeneratedField::TermId),
2817 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2818 }
2819 }
2820 }
2821 deserializer.deserialize_identifier(GeneratedVisitor)
2822 }
2823 }
2824 struct GeneratedVisitor;
2825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2826 type Value = streaming_control_stream_request::InitRequest;
2827
2828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2829 formatter.write_str("struct stream_service.StreamingControlStreamRequest.InitRequest")
2830 }
2831
2832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_request::InitRequest, V::Error>
2833 where
2834 V: serde::de::MapAccess<'de>,
2835 {
2836 let mut term_id__ = None;
2837 while let Some(k) = map_.next_key()? {
2838 match k {
2839 GeneratedField::TermId => {
2840 if term_id__.is_some() {
2841 return Err(serde::de::Error::duplicate_field("termId"));
2842 }
2843 term_id__ = Some(map_.next_value()?);
2844 }
2845 }
2846 }
2847 Ok(streaming_control_stream_request::InitRequest {
2848 term_id: term_id__.unwrap_or_default(),
2849 })
2850 }
2851 }
2852 deserializer.deserialize_struct("stream_service.StreamingControlStreamRequest.InitRequest", FIELDS, GeneratedVisitor)
2853 }
2854}
2855impl serde::Serialize for streaming_control_stream_request::RemovePartialGraphRequest {
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.partial_graph_ids.is_empty() {
2864 len += 1;
2865 }
2866 let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamRequest.RemovePartialGraphRequest", len)?;
2867 if !self.partial_graph_ids.is_empty() {
2868 struct_ser.serialize_field("partialGraphIds", &self.partial_graph_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
2869 }
2870 struct_ser.end()
2871 }
2872}
2873impl<'de> serde::Deserialize<'de> for streaming_control_stream_request::RemovePartialGraphRequest {
2874 #[allow(deprecated)]
2875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2876 where
2877 D: serde::Deserializer<'de>,
2878 {
2879 const FIELDS: &[&str] = &[
2880 "partial_graph_ids",
2881 "partialGraphIds",
2882 ];
2883
2884 #[allow(clippy::enum_variant_names)]
2885 enum GeneratedField {
2886 PartialGraphIds,
2887 }
2888 impl<'de> serde::Deserialize<'de> for GeneratedField {
2889 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2890 where
2891 D: serde::Deserializer<'de>,
2892 {
2893 struct GeneratedVisitor;
2894
2895 impl serde::de::Visitor<'_> for GeneratedVisitor {
2896 type Value = GeneratedField;
2897
2898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2899 write!(formatter, "expected one of: {:?}", &FIELDS)
2900 }
2901
2902 #[allow(unused_variables)]
2903 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2904 where
2905 E: serde::de::Error,
2906 {
2907 match value {
2908 "partialGraphIds" | "partial_graph_ids" => Ok(GeneratedField::PartialGraphIds),
2909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2910 }
2911 }
2912 }
2913 deserializer.deserialize_identifier(GeneratedVisitor)
2914 }
2915 }
2916 struct GeneratedVisitor;
2917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2918 type Value = streaming_control_stream_request::RemovePartialGraphRequest;
2919
2920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2921 formatter.write_str("struct stream_service.StreamingControlStreamRequest.RemovePartialGraphRequest")
2922 }
2923
2924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_request::RemovePartialGraphRequest, V::Error>
2925 where
2926 V: serde::de::MapAccess<'de>,
2927 {
2928 let mut partial_graph_ids__ = None;
2929 while let Some(k) = map_.next_key()? {
2930 match k {
2931 GeneratedField::PartialGraphIds => {
2932 if partial_graph_ids__.is_some() {
2933 return Err(serde::de::Error::duplicate_field("partialGraphIds"));
2934 }
2935 partial_graph_ids__ =
2936 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2937 .into_iter().map(|x| x.0).collect())
2938 ;
2939 }
2940 }
2941 }
2942 Ok(streaming_control_stream_request::RemovePartialGraphRequest {
2943 partial_graph_ids: partial_graph_ids__.unwrap_or_default(),
2944 })
2945 }
2946 }
2947 deserializer.deserialize_struct("stream_service.StreamingControlStreamRequest.RemovePartialGraphRequest", FIELDS, GeneratedVisitor)
2948 }
2949}
2950impl serde::Serialize for streaming_control_stream_request::ResetPartialGraphsRequest {
2951 #[allow(deprecated)]
2952 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2953 where
2954 S: serde::Serializer,
2955 {
2956 use serde::ser::SerializeStruct;
2957 let mut len = 0;
2958 if !self.partial_graph_ids.is_empty() {
2959 len += 1;
2960 }
2961 let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamRequest.ResetPartialGraphsRequest", len)?;
2962 if !self.partial_graph_ids.is_empty() {
2963 struct_ser.serialize_field("partialGraphIds", &self.partial_graph_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
2964 }
2965 struct_ser.end()
2966 }
2967}
2968impl<'de> serde::Deserialize<'de> for streaming_control_stream_request::ResetPartialGraphsRequest {
2969 #[allow(deprecated)]
2970 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2971 where
2972 D: serde::Deserializer<'de>,
2973 {
2974 const FIELDS: &[&str] = &[
2975 "partial_graph_ids",
2976 "partialGraphIds",
2977 ];
2978
2979 #[allow(clippy::enum_variant_names)]
2980 enum GeneratedField {
2981 PartialGraphIds,
2982 }
2983 impl<'de> serde::Deserialize<'de> for GeneratedField {
2984 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2985 where
2986 D: serde::Deserializer<'de>,
2987 {
2988 struct GeneratedVisitor;
2989
2990 impl serde::de::Visitor<'_> for GeneratedVisitor {
2991 type Value = GeneratedField;
2992
2993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2994 write!(formatter, "expected one of: {:?}", &FIELDS)
2995 }
2996
2997 #[allow(unused_variables)]
2998 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2999 where
3000 E: serde::de::Error,
3001 {
3002 match value {
3003 "partialGraphIds" | "partial_graph_ids" => Ok(GeneratedField::PartialGraphIds),
3004 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3005 }
3006 }
3007 }
3008 deserializer.deserialize_identifier(GeneratedVisitor)
3009 }
3010 }
3011 struct GeneratedVisitor;
3012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3013 type Value = streaming_control_stream_request::ResetPartialGraphsRequest;
3014
3015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3016 formatter.write_str("struct stream_service.StreamingControlStreamRequest.ResetPartialGraphsRequest")
3017 }
3018
3019 fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_request::ResetPartialGraphsRequest, V::Error>
3020 where
3021 V: serde::de::MapAccess<'de>,
3022 {
3023 let mut partial_graph_ids__ = None;
3024 while let Some(k) = map_.next_key()? {
3025 match k {
3026 GeneratedField::PartialGraphIds => {
3027 if partial_graph_ids__.is_some() {
3028 return Err(serde::de::Error::duplicate_field("partialGraphIds"));
3029 }
3030 partial_graph_ids__ =
3031 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3032 .into_iter().map(|x| x.0).collect())
3033 ;
3034 }
3035 }
3036 }
3037 Ok(streaming_control_stream_request::ResetPartialGraphsRequest {
3038 partial_graph_ids: partial_graph_ids__.unwrap_or_default(),
3039 })
3040 }
3041 }
3042 deserializer.deserialize_struct("stream_service.StreamingControlStreamRequest.ResetPartialGraphsRequest", FIELDS, GeneratedVisitor)
3043 }
3044}
3045impl serde::Serialize for StreamingControlStreamResponse {
3046 #[allow(deprecated)]
3047 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3048 where
3049 S: serde::Serializer,
3050 {
3051 use serde::ser::SerializeStruct;
3052 let mut len = 0;
3053 if self.response.is_some() {
3054 len += 1;
3055 }
3056 let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamResponse", len)?;
3057 if let Some(v) = self.response.as_ref() {
3058 match v {
3059 streaming_control_stream_response::Response::Init(v) => {
3060 struct_ser.serialize_field("init", v)?;
3061 }
3062 streaming_control_stream_response::Response::CompleteBarrier(v) => {
3063 struct_ser.serialize_field("completeBarrier", v)?;
3064 }
3065 streaming_control_stream_response::Response::Shutdown(v) => {
3066 struct_ser.serialize_field("shutdown", v)?;
3067 }
3068 streaming_control_stream_response::Response::ReportPartialGraphFailure(v) => {
3069 struct_ser.serialize_field("reportPartialGraphFailure", v)?;
3070 }
3071 streaming_control_stream_response::Response::ResetPartialGraph(v) => {
3072 struct_ser.serialize_field("resetPartialGraph", v)?;
3073 }
3074 }
3075 }
3076 struct_ser.end()
3077 }
3078}
3079impl<'de> serde::Deserialize<'de> for StreamingControlStreamResponse {
3080 #[allow(deprecated)]
3081 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3082 where
3083 D: serde::Deserializer<'de>,
3084 {
3085 const FIELDS: &[&str] = &[
3086 "init",
3087 "complete_barrier",
3088 "completeBarrier",
3089 "shutdown",
3090 "report_partial_graph_failure",
3091 "reportPartialGraphFailure",
3092 "reset_partial_graph",
3093 "resetPartialGraph",
3094 ];
3095
3096 #[allow(clippy::enum_variant_names)]
3097 enum GeneratedField {
3098 Init,
3099 CompleteBarrier,
3100 Shutdown,
3101 ReportPartialGraphFailure,
3102 ResetPartialGraph,
3103 }
3104 impl<'de> serde::Deserialize<'de> for GeneratedField {
3105 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3106 where
3107 D: serde::Deserializer<'de>,
3108 {
3109 struct GeneratedVisitor;
3110
3111 impl serde::de::Visitor<'_> for GeneratedVisitor {
3112 type Value = GeneratedField;
3113
3114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3115 write!(formatter, "expected one of: {:?}", &FIELDS)
3116 }
3117
3118 #[allow(unused_variables)]
3119 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3120 where
3121 E: serde::de::Error,
3122 {
3123 match value {
3124 "init" => Ok(GeneratedField::Init),
3125 "completeBarrier" | "complete_barrier" => Ok(GeneratedField::CompleteBarrier),
3126 "shutdown" => Ok(GeneratedField::Shutdown),
3127 "reportPartialGraphFailure" | "report_partial_graph_failure" => Ok(GeneratedField::ReportPartialGraphFailure),
3128 "resetPartialGraph" | "reset_partial_graph" => Ok(GeneratedField::ResetPartialGraph),
3129 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3130 }
3131 }
3132 }
3133 deserializer.deserialize_identifier(GeneratedVisitor)
3134 }
3135 }
3136 struct GeneratedVisitor;
3137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3138 type Value = StreamingControlStreamResponse;
3139
3140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3141 formatter.write_str("struct stream_service.StreamingControlStreamResponse")
3142 }
3143
3144 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamingControlStreamResponse, V::Error>
3145 where
3146 V: serde::de::MapAccess<'de>,
3147 {
3148 let mut response__ = None;
3149 while let Some(k) = map_.next_key()? {
3150 match k {
3151 GeneratedField::Init => {
3152 if response__.is_some() {
3153 return Err(serde::de::Error::duplicate_field("init"));
3154 }
3155 response__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_response::Response::Init)
3156;
3157 }
3158 GeneratedField::CompleteBarrier => {
3159 if response__.is_some() {
3160 return Err(serde::de::Error::duplicate_field("completeBarrier"));
3161 }
3162 response__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_response::Response::CompleteBarrier)
3163;
3164 }
3165 GeneratedField::Shutdown => {
3166 if response__.is_some() {
3167 return Err(serde::de::Error::duplicate_field("shutdown"));
3168 }
3169 response__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_response::Response::Shutdown)
3170;
3171 }
3172 GeneratedField::ReportPartialGraphFailure => {
3173 if response__.is_some() {
3174 return Err(serde::de::Error::duplicate_field("reportPartialGraphFailure"));
3175 }
3176 response__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_response::Response::ReportPartialGraphFailure)
3177;
3178 }
3179 GeneratedField::ResetPartialGraph => {
3180 if response__.is_some() {
3181 return Err(serde::de::Error::duplicate_field("resetPartialGraph"));
3182 }
3183 response__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_response::Response::ResetPartialGraph)
3184;
3185 }
3186 }
3187 }
3188 Ok(StreamingControlStreamResponse {
3189 response: response__,
3190 })
3191 }
3192 }
3193 deserializer.deserialize_struct("stream_service.StreamingControlStreamResponse", FIELDS, GeneratedVisitor)
3194 }
3195}
3196impl serde::Serialize for streaming_control_stream_response::InitResponse {
3197 #[allow(deprecated)]
3198 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3199 where
3200 S: serde::Serializer,
3201 {
3202 use serde::ser::SerializeStruct;
3203 let len = 0;
3204 let struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamResponse.InitResponse", len)?;
3205 struct_ser.end()
3206 }
3207}
3208impl<'de> serde::Deserialize<'de> for streaming_control_stream_response::InitResponse {
3209 #[allow(deprecated)]
3210 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3211 where
3212 D: serde::Deserializer<'de>,
3213 {
3214 const FIELDS: &[&str] = &[
3215 ];
3216
3217 #[allow(clippy::enum_variant_names)]
3218 enum GeneratedField {
3219 }
3220 impl<'de> serde::Deserialize<'de> for GeneratedField {
3221 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3222 where
3223 D: serde::Deserializer<'de>,
3224 {
3225 struct GeneratedVisitor;
3226
3227 impl serde::de::Visitor<'_> for GeneratedVisitor {
3228 type Value = GeneratedField;
3229
3230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3231 write!(formatter, "expected one of: {:?}", &FIELDS)
3232 }
3233
3234 #[allow(unused_variables)]
3235 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3236 where
3237 E: serde::de::Error,
3238 {
3239 Err(serde::de::Error::unknown_field(value, FIELDS))
3240 }
3241 }
3242 deserializer.deserialize_identifier(GeneratedVisitor)
3243 }
3244 }
3245 struct GeneratedVisitor;
3246 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3247 type Value = streaming_control_stream_response::InitResponse;
3248
3249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3250 formatter.write_str("struct stream_service.StreamingControlStreamResponse.InitResponse")
3251 }
3252
3253 fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_response::InitResponse, V::Error>
3254 where
3255 V: serde::de::MapAccess<'de>,
3256 {
3257 while map_.next_key::<GeneratedField>()?.is_some() {
3258 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3259 }
3260 Ok(streaming_control_stream_response::InitResponse {
3261 })
3262 }
3263 }
3264 deserializer.deserialize_struct("stream_service.StreamingControlStreamResponse.InitResponse", FIELDS, GeneratedVisitor)
3265 }
3266}
3267impl serde::Serialize for streaming_control_stream_response::ReportPartialGraphFailureResponse {
3268 #[allow(deprecated)]
3269 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3270 where
3271 S: serde::Serializer,
3272 {
3273 use serde::ser::SerializeStruct;
3274 let mut len = 0;
3275 if self.partial_graph_id != 0 {
3276 len += 1;
3277 }
3278 let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamResponse.ReportPartialGraphFailureResponse", len)?;
3279 if self.partial_graph_id != 0 {
3280 #[allow(clippy::needless_borrow)]
3281 #[allow(clippy::needless_borrows_for_generic_args)]
3282 struct_ser.serialize_field("partialGraphId", ToString::to_string(&self.partial_graph_id).as_str())?;
3283 }
3284 struct_ser.end()
3285 }
3286}
3287impl<'de> serde::Deserialize<'de> for streaming_control_stream_response::ReportPartialGraphFailureResponse {
3288 #[allow(deprecated)]
3289 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3290 where
3291 D: serde::Deserializer<'de>,
3292 {
3293 const FIELDS: &[&str] = &[
3294 "partial_graph_id",
3295 "partialGraphId",
3296 ];
3297
3298 #[allow(clippy::enum_variant_names)]
3299 enum GeneratedField {
3300 PartialGraphId,
3301 }
3302 impl<'de> serde::Deserialize<'de> for GeneratedField {
3303 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3304 where
3305 D: serde::Deserializer<'de>,
3306 {
3307 struct GeneratedVisitor;
3308
3309 impl serde::de::Visitor<'_> for GeneratedVisitor {
3310 type Value = GeneratedField;
3311
3312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3313 write!(formatter, "expected one of: {:?}", &FIELDS)
3314 }
3315
3316 #[allow(unused_variables)]
3317 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3318 where
3319 E: serde::de::Error,
3320 {
3321 match value {
3322 "partialGraphId" | "partial_graph_id" => Ok(GeneratedField::PartialGraphId),
3323 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3324 }
3325 }
3326 }
3327 deserializer.deserialize_identifier(GeneratedVisitor)
3328 }
3329 }
3330 struct GeneratedVisitor;
3331 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3332 type Value = streaming_control_stream_response::ReportPartialGraphFailureResponse;
3333
3334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3335 formatter.write_str("struct stream_service.StreamingControlStreamResponse.ReportPartialGraphFailureResponse")
3336 }
3337
3338 fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_response::ReportPartialGraphFailureResponse, V::Error>
3339 where
3340 V: serde::de::MapAccess<'de>,
3341 {
3342 let mut partial_graph_id__ = None;
3343 while let Some(k) = map_.next_key()? {
3344 match k {
3345 GeneratedField::PartialGraphId => {
3346 if partial_graph_id__.is_some() {
3347 return Err(serde::de::Error::duplicate_field("partialGraphId"));
3348 }
3349 partial_graph_id__ =
3350 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3351 ;
3352 }
3353 }
3354 }
3355 Ok(streaming_control_stream_response::ReportPartialGraphFailureResponse {
3356 partial_graph_id: partial_graph_id__.unwrap_or_default(),
3357 })
3358 }
3359 }
3360 deserializer.deserialize_struct("stream_service.StreamingControlStreamResponse.ReportPartialGraphFailureResponse", FIELDS, GeneratedVisitor)
3361 }
3362}
3363impl serde::Serialize for streaming_control_stream_response::ResetPartialGraphResponse {
3364 #[allow(deprecated)]
3365 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3366 where
3367 S: serde::Serializer,
3368 {
3369 use serde::ser::SerializeStruct;
3370 let mut len = 0;
3371 if self.partial_graph_id != 0 {
3372 len += 1;
3373 }
3374 if self.root_err.is_some() {
3375 len += 1;
3376 }
3377 let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamResponse.ResetPartialGraphResponse", len)?;
3378 if self.partial_graph_id != 0 {
3379 #[allow(clippy::needless_borrow)]
3380 #[allow(clippy::needless_borrows_for_generic_args)]
3381 struct_ser.serialize_field("partialGraphId", ToString::to_string(&self.partial_graph_id).as_str())?;
3382 }
3383 if let Some(v) = self.root_err.as_ref() {
3384 struct_ser.serialize_field("rootErr", v)?;
3385 }
3386 struct_ser.end()
3387 }
3388}
3389impl<'de> serde::Deserialize<'de> for streaming_control_stream_response::ResetPartialGraphResponse {
3390 #[allow(deprecated)]
3391 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3392 where
3393 D: serde::Deserializer<'de>,
3394 {
3395 const FIELDS: &[&str] = &[
3396 "partial_graph_id",
3397 "partialGraphId",
3398 "root_err",
3399 "rootErr",
3400 ];
3401
3402 #[allow(clippy::enum_variant_names)]
3403 enum GeneratedField {
3404 PartialGraphId,
3405 RootErr,
3406 }
3407 impl<'de> serde::Deserialize<'de> for GeneratedField {
3408 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3409 where
3410 D: serde::Deserializer<'de>,
3411 {
3412 struct GeneratedVisitor;
3413
3414 impl serde::de::Visitor<'_> for GeneratedVisitor {
3415 type Value = GeneratedField;
3416
3417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3418 write!(formatter, "expected one of: {:?}", &FIELDS)
3419 }
3420
3421 #[allow(unused_variables)]
3422 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3423 where
3424 E: serde::de::Error,
3425 {
3426 match value {
3427 "partialGraphId" | "partial_graph_id" => Ok(GeneratedField::PartialGraphId),
3428 "rootErr" | "root_err" => Ok(GeneratedField::RootErr),
3429 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3430 }
3431 }
3432 }
3433 deserializer.deserialize_identifier(GeneratedVisitor)
3434 }
3435 }
3436 struct GeneratedVisitor;
3437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3438 type Value = streaming_control_stream_response::ResetPartialGraphResponse;
3439
3440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3441 formatter.write_str("struct stream_service.StreamingControlStreamResponse.ResetPartialGraphResponse")
3442 }
3443
3444 fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_response::ResetPartialGraphResponse, V::Error>
3445 where
3446 V: serde::de::MapAccess<'de>,
3447 {
3448 let mut partial_graph_id__ = None;
3449 let mut root_err__ = None;
3450 while let Some(k) = map_.next_key()? {
3451 match k {
3452 GeneratedField::PartialGraphId => {
3453 if partial_graph_id__.is_some() {
3454 return Err(serde::de::Error::duplicate_field("partialGraphId"));
3455 }
3456 partial_graph_id__ =
3457 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3458 ;
3459 }
3460 GeneratedField::RootErr => {
3461 if root_err__.is_some() {
3462 return Err(serde::de::Error::duplicate_field("rootErr"));
3463 }
3464 root_err__ = map_.next_value()?;
3465 }
3466 }
3467 }
3468 Ok(streaming_control_stream_response::ResetPartialGraphResponse {
3469 partial_graph_id: partial_graph_id__.unwrap_or_default(),
3470 root_err: root_err__,
3471 })
3472 }
3473 }
3474 deserializer.deserialize_struct("stream_service.StreamingControlStreamResponse.ResetPartialGraphResponse", FIELDS, GeneratedVisitor)
3475 }
3476}
3477impl serde::Serialize for streaming_control_stream_response::ShutdownResponse {
3478 #[allow(deprecated)]
3479 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3480 where
3481 S: serde::Serializer,
3482 {
3483 use serde::ser::SerializeStruct;
3484 let len = 0;
3485 let struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamResponse.ShutdownResponse", len)?;
3486 struct_ser.end()
3487 }
3488}
3489impl<'de> serde::Deserialize<'de> for streaming_control_stream_response::ShutdownResponse {
3490 #[allow(deprecated)]
3491 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3492 where
3493 D: serde::Deserializer<'de>,
3494 {
3495 const FIELDS: &[&str] = &[
3496 ];
3497
3498 #[allow(clippy::enum_variant_names)]
3499 enum GeneratedField {
3500 }
3501 impl<'de> serde::Deserialize<'de> for GeneratedField {
3502 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3503 where
3504 D: serde::Deserializer<'de>,
3505 {
3506 struct GeneratedVisitor;
3507
3508 impl serde::de::Visitor<'_> for GeneratedVisitor {
3509 type Value = GeneratedField;
3510
3511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3512 write!(formatter, "expected one of: {:?}", &FIELDS)
3513 }
3514
3515 #[allow(unused_variables)]
3516 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3517 where
3518 E: serde::de::Error,
3519 {
3520 Err(serde::de::Error::unknown_field(value, FIELDS))
3521 }
3522 }
3523 deserializer.deserialize_identifier(GeneratedVisitor)
3524 }
3525 }
3526 struct GeneratedVisitor;
3527 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3528 type Value = streaming_control_stream_response::ShutdownResponse;
3529
3530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3531 formatter.write_str("struct stream_service.StreamingControlStreamResponse.ShutdownResponse")
3532 }
3533
3534 fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_response::ShutdownResponse, V::Error>
3535 where
3536 V: serde::de::MapAccess<'de>,
3537 {
3538 while map_.next_key::<GeneratedField>()?.is_some() {
3539 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3540 }
3541 Ok(streaming_control_stream_response::ShutdownResponse {
3542 })
3543 }
3544 }
3545 deserializer.deserialize_struct("stream_service.StreamingControlStreamResponse.ShutdownResponse", FIELDS, GeneratedVisitor)
3546 }
3547}