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