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