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