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