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