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