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