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