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