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