1use crate::hummock::*;
2impl serde::Serialize for BloomFilterType {
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 let variant = match self {
9 Self::BloomFilterUnspecified => "BLOOM_FILTER_UNSPECIFIED",
10 Self::Sstable => "SSTABLE",
11 Self::Blocked => "BLOCKED",
12 };
13 serializer.serialize_str(variant)
14 }
15}
16impl<'de> serde::Deserialize<'de> for BloomFilterType {
17 #[allow(deprecated)]
18 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19 where
20 D: serde::Deserializer<'de>,
21 {
22 const FIELDS: &[&str] = &[
23 "BLOOM_FILTER_UNSPECIFIED",
24 "SSTABLE",
25 "BLOCKED",
26 ];
27
28 struct GeneratedVisitor;
29
30 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
31 type Value = BloomFilterType;
32
33 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34 write!(formatter, "expected one of: {:?}", &FIELDS)
35 }
36
37 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
38 where
39 E: serde::de::Error,
40 {
41 i32::try_from(v)
42 .ok()
43 .and_then(|x| x.try_into().ok())
44 .ok_or_else(|| {
45 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
46 })
47 }
48
49 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
50 where
51 E: serde::de::Error,
52 {
53 i32::try_from(v)
54 .ok()
55 .and_then(|x| x.try_into().ok())
56 .ok_or_else(|| {
57 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
58 })
59 }
60
61 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
62 where
63 E: serde::de::Error,
64 {
65 match value {
66 "BLOOM_FILTER_UNSPECIFIED" => Ok(BloomFilterType::BloomFilterUnspecified),
67 "SSTABLE" => Ok(BloomFilterType::Sstable),
68 "BLOCKED" => Ok(BloomFilterType::Blocked),
69 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
70 }
71 }
72 }
73 deserializer.deserialize_any(GeneratedVisitor)
74 }
75}
76impl serde::Serialize for BranchedObject {
77 #[allow(deprecated)]
78 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
79 where
80 S: serde::Serializer,
81 {
82 use serde::ser::SerializeStruct;
83 let mut len = 0;
84 if self.object_id != 0 {
85 len += 1;
86 }
87 if !self.sst_id.is_empty() {
88 len += 1;
89 }
90 if self.compaction_group_id != 0 {
91 len += 1;
92 }
93 let mut struct_ser = serializer.serialize_struct("hummock.BranchedObject", len)?;
94 if self.object_id != 0 {
95 #[allow(clippy::needless_borrow)]
96 #[allow(clippy::needless_borrows_for_generic_args)]
97 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
98 }
99 if !self.sst_id.is_empty() {
100 struct_ser.serialize_field("sstId", &self.sst_id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
101 }
102 if self.compaction_group_id != 0 {
103 #[allow(clippy::needless_borrow)]
104 #[allow(clippy::needless_borrows_for_generic_args)]
105 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
106 }
107 struct_ser.end()
108 }
109}
110impl<'de> serde::Deserialize<'de> for BranchedObject {
111 #[allow(deprecated)]
112 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
113 where
114 D: serde::Deserializer<'de>,
115 {
116 const FIELDS: &[&str] = &[
117 "object_id",
118 "objectId",
119 "sst_id",
120 "sstId",
121 "compaction_group_id",
122 "compactionGroupId",
123 ];
124
125 #[allow(clippy::enum_variant_names)]
126 enum GeneratedField {
127 ObjectId,
128 SstId,
129 CompactionGroupId,
130 }
131 impl<'de> serde::Deserialize<'de> for GeneratedField {
132 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
133 where
134 D: serde::Deserializer<'de>,
135 {
136 struct GeneratedVisitor;
137
138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
139 type Value = GeneratedField;
140
141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
142 write!(formatter, "expected one of: {:?}", &FIELDS)
143 }
144
145 #[allow(unused_variables)]
146 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
147 where
148 E: serde::de::Error,
149 {
150 match value {
151 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
152 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
153 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
154 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
155 }
156 }
157 }
158 deserializer.deserialize_identifier(GeneratedVisitor)
159 }
160 }
161 struct GeneratedVisitor;
162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
163 type Value = BranchedObject;
164
165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
166 formatter.write_str("struct hummock.BranchedObject")
167 }
168
169 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BranchedObject, V::Error>
170 where
171 V: serde::de::MapAccess<'de>,
172 {
173 let mut object_id__ = None;
174 let mut sst_id__ = None;
175 let mut compaction_group_id__ = None;
176 while let Some(k) = map_.next_key()? {
177 match k {
178 GeneratedField::ObjectId => {
179 if object_id__.is_some() {
180 return Err(serde::de::Error::duplicate_field("objectId"));
181 }
182 object_id__ =
183 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
184 ;
185 }
186 GeneratedField::SstId => {
187 if sst_id__.is_some() {
188 return Err(serde::de::Error::duplicate_field("sstId"));
189 }
190 sst_id__ =
191 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
192 .into_iter().map(|x| x.0).collect())
193 ;
194 }
195 GeneratedField::CompactionGroupId => {
196 if compaction_group_id__.is_some() {
197 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
198 }
199 compaction_group_id__ =
200 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
201 ;
202 }
203 }
204 }
205 Ok(BranchedObject {
206 object_id: object_id__.unwrap_or_default(),
207 sst_id: sst_id__.unwrap_or_default(),
208 compaction_group_id: compaction_group_id__.unwrap_or_default(),
209 })
210 }
211 }
212 deserializer.deserialize_struct("hummock.BranchedObject", FIELDS, GeneratedVisitor)
213 }
214}
215impl serde::Serialize for CancelCompactTask {
216 #[allow(deprecated)]
217 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
218 where
219 S: serde::Serializer,
220 {
221 use serde::ser::SerializeStruct;
222 let mut len = 0;
223 if self.context_id != 0 {
224 len += 1;
225 }
226 if self.task_id != 0 {
227 len += 1;
228 }
229 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTask", len)?;
230 if self.context_id != 0 {
231 struct_ser.serialize_field("contextId", &self.context_id)?;
232 }
233 if self.task_id != 0 {
234 #[allow(clippy::needless_borrow)]
235 #[allow(clippy::needless_borrows_for_generic_args)]
236 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
237 }
238 struct_ser.end()
239 }
240}
241impl<'de> serde::Deserialize<'de> for CancelCompactTask {
242 #[allow(deprecated)]
243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
244 where
245 D: serde::Deserializer<'de>,
246 {
247 const FIELDS: &[&str] = &[
248 "context_id",
249 "contextId",
250 "task_id",
251 "taskId",
252 ];
253
254 #[allow(clippy::enum_variant_names)]
255 enum GeneratedField {
256 ContextId,
257 TaskId,
258 }
259 impl<'de> serde::Deserialize<'de> for GeneratedField {
260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
261 where
262 D: serde::Deserializer<'de>,
263 {
264 struct GeneratedVisitor;
265
266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
267 type Value = GeneratedField;
268
269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
270 write!(formatter, "expected one of: {:?}", &FIELDS)
271 }
272
273 #[allow(unused_variables)]
274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
275 where
276 E: serde::de::Error,
277 {
278 match value {
279 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
280 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
281 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
282 }
283 }
284 }
285 deserializer.deserialize_identifier(GeneratedVisitor)
286 }
287 }
288 struct GeneratedVisitor;
289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
290 type Value = CancelCompactTask;
291
292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
293 formatter.write_str("struct hummock.CancelCompactTask")
294 }
295
296 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTask, V::Error>
297 where
298 V: serde::de::MapAccess<'de>,
299 {
300 let mut context_id__ = None;
301 let mut task_id__ = None;
302 while let Some(k) = map_.next_key()? {
303 match k {
304 GeneratedField::ContextId => {
305 if context_id__.is_some() {
306 return Err(serde::de::Error::duplicate_field("contextId"));
307 }
308 context_id__ =
309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
310 ;
311 }
312 GeneratedField::TaskId => {
313 if task_id__.is_some() {
314 return Err(serde::de::Error::duplicate_field("taskId"));
315 }
316 task_id__ =
317 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
318 ;
319 }
320 }
321 }
322 Ok(CancelCompactTask {
323 context_id: context_id__.unwrap_or_default(),
324 task_id: task_id__.unwrap_or_default(),
325 })
326 }
327 }
328 deserializer.deserialize_struct("hummock.CancelCompactTask", FIELDS, GeneratedVisitor)
329 }
330}
331impl serde::Serialize for CancelCompactTaskRequest {
332 #[allow(deprecated)]
333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
334 where
335 S: serde::Serializer,
336 {
337 use serde::ser::SerializeStruct;
338 let mut len = 0;
339 if self.task_id != 0 {
340 len += 1;
341 }
342 if self.task_status != 0 {
343 len += 1;
344 }
345 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskRequest", len)?;
346 if self.task_id != 0 {
347 #[allow(clippy::needless_borrow)]
348 #[allow(clippy::needless_borrows_for_generic_args)]
349 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
350 }
351 if self.task_status != 0 {
352 let v = compact_task::TaskStatus::try_from(self.task_status)
353 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
354 struct_ser.serialize_field("taskStatus", &v)?;
355 }
356 struct_ser.end()
357 }
358}
359impl<'de> serde::Deserialize<'de> for CancelCompactTaskRequest {
360 #[allow(deprecated)]
361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
362 where
363 D: serde::Deserializer<'de>,
364 {
365 const FIELDS: &[&str] = &[
366 "task_id",
367 "taskId",
368 "task_status",
369 "taskStatus",
370 ];
371
372 #[allow(clippy::enum_variant_names)]
373 enum GeneratedField {
374 TaskId,
375 TaskStatus,
376 }
377 impl<'de> serde::Deserialize<'de> for GeneratedField {
378 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
379 where
380 D: serde::Deserializer<'de>,
381 {
382 struct GeneratedVisitor;
383
384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
385 type Value = GeneratedField;
386
387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
388 write!(formatter, "expected one of: {:?}", &FIELDS)
389 }
390
391 #[allow(unused_variables)]
392 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
393 where
394 E: serde::de::Error,
395 {
396 match value {
397 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
398 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
399 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
400 }
401 }
402 }
403 deserializer.deserialize_identifier(GeneratedVisitor)
404 }
405 }
406 struct GeneratedVisitor;
407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
408 type Value = CancelCompactTaskRequest;
409
410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
411 formatter.write_str("struct hummock.CancelCompactTaskRequest")
412 }
413
414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskRequest, V::Error>
415 where
416 V: serde::de::MapAccess<'de>,
417 {
418 let mut task_id__ = None;
419 let mut task_status__ = None;
420 while let Some(k) = map_.next_key()? {
421 match k {
422 GeneratedField::TaskId => {
423 if task_id__.is_some() {
424 return Err(serde::de::Error::duplicate_field("taskId"));
425 }
426 task_id__ =
427 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
428 ;
429 }
430 GeneratedField::TaskStatus => {
431 if task_status__.is_some() {
432 return Err(serde::de::Error::duplicate_field("taskStatus"));
433 }
434 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
435 }
436 }
437 }
438 Ok(CancelCompactTaskRequest {
439 task_id: task_id__.unwrap_or_default(),
440 task_status: task_status__.unwrap_or_default(),
441 })
442 }
443 }
444 deserializer.deserialize_struct("hummock.CancelCompactTaskRequest", FIELDS, GeneratedVisitor)
445 }
446}
447impl serde::Serialize for CancelCompactTaskResponse {
448 #[allow(deprecated)]
449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
450 where
451 S: serde::Serializer,
452 {
453 use serde::ser::SerializeStruct;
454 let mut len = 0;
455 if self.ret {
456 len += 1;
457 }
458 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskResponse", len)?;
459 if self.ret {
460 struct_ser.serialize_field("ret", &self.ret)?;
461 }
462 struct_ser.end()
463 }
464}
465impl<'de> serde::Deserialize<'de> for CancelCompactTaskResponse {
466 #[allow(deprecated)]
467 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
468 where
469 D: serde::Deserializer<'de>,
470 {
471 const FIELDS: &[&str] = &[
472 "ret",
473 ];
474
475 #[allow(clippy::enum_variant_names)]
476 enum GeneratedField {
477 Ret,
478 }
479 impl<'de> serde::Deserialize<'de> for GeneratedField {
480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
481 where
482 D: serde::Deserializer<'de>,
483 {
484 struct GeneratedVisitor;
485
486 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
487 type Value = GeneratedField;
488
489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
490 write!(formatter, "expected one of: {:?}", &FIELDS)
491 }
492
493 #[allow(unused_variables)]
494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
495 where
496 E: serde::de::Error,
497 {
498 match value {
499 "ret" => Ok(GeneratedField::Ret),
500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
501 }
502 }
503 }
504 deserializer.deserialize_identifier(GeneratedVisitor)
505 }
506 }
507 struct GeneratedVisitor;
508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
509 type Value = CancelCompactTaskResponse;
510
511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
512 formatter.write_str("struct hummock.CancelCompactTaskResponse")
513 }
514
515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskResponse, V::Error>
516 where
517 V: serde::de::MapAccess<'de>,
518 {
519 let mut ret__ = None;
520 while let Some(k) = map_.next_key()? {
521 match k {
522 GeneratedField::Ret => {
523 if ret__.is_some() {
524 return Err(serde::de::Error::duplicate_field("ret"));
525 }
526 ret__ = Some(map_.next_value()?);
527 }
528 }
529 }
530 Ok(CancelCompactTaskResponse {
531 ret: ret__.unwrap_or_default(),
532 })
533 }
534 }
535 deserializer.deserialize_struct("hummock.CancelCompactTaskResponse", FIELDS, GeneratedVisitor)
536 }
537}
538impl serde::Serialize for CompactStatus {
539 #[allow(deprecated)]
540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
541 where
542 S: serde::Serializer,
543 {
544 use serde::ser::SerializeStruct;
545 let mut len = 0;
546 if self.compaction_group_id != 0 {
547 len += 1;
548 }
549 if !self.level_handlers.is_empty() {
550 len += 1;
551 }
552 let mut struct_ser = serializer.serialize_struct("hummock.CompactStatus", len)?;
553 if self.compaction_group_id != 0 {
554 #[allow(clippy::needless_borrow)]
555 #[allow(clippy::needless_borrows_for_generic_args)]
556 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
557 }
558 if !self.level_handlers.is_empty() {
559 struct_ser.serialize_field("levelHandlers", &self.level_handlers)?;
560 }
561 struct_ser.end()
562 }
563}
564impl<'de> serde::Deserialize<'de> for CompactStatus {
565 #[allow(deprecated)]
566 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
567 where
568 D: serde::Deserializer<'de>,
569 {
570 const FIELDS: &[&str] = &[
571 "compaction_group_id",
572 "compactionGroupId",
573 "level_handlers",
574 "levelHandlers",
575 ];
576
577 #[allow(clippy::enum_variant_names)]
578 enum GeneratedField {
579 CompactionGroupId,
580 LevelHandlers,
581 }
582 impl<'de> serde::Deserialize<'de> for GeneratedField {
583 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
584 where
585 D: serde::Deserializer<'de>,
586 {
587 struct GeneratedVisitor;
588
589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
590 type Value = GeneratedField;
591
592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
593 write!(formatter, "expected one of: {:?}", &FIELDS)
594 }
595
596 #[allow(unused_variables)]
597 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
598 where
599 E: serde::de::Error,
600 {
601 match value {
602 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
603 "levelHandlers" | "level_handlers" => Ok(GeneratedField::LevelHandlers),
604 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
605 }
606 }
607 }
608 deserializer.deserialize_identifier(GeneratedVisitor)
609 }
610 }
611 struct GeneratedVisitor;
612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
613 type Value = CompactStatus;
614
615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
616 formatter.write_str("struct hummock.CompactStatus")
617 }
618
619 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactStatus, V::Error>
620 where
621 V: serde::de::MapAccess<'de>,
622 {
623 let mut compaction_group_id__ = None;
624 let mut level_handlers__ = None;
625 while let Some(k) = map_.next_key()? {
626 match k {
627 GeneratedField::CompactionGroupId => {
628 if compaction_group_id__.is_some() {
629 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
630 }
631 compaction_group_id__ =
632 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
633 ;
634 }
635 GeneratedField::LevelHandlers => {
636 if level_handlers__.is_some() {
637 return Err(serde::de::Error::duplicate_field("levelHandlers"));
638 }
639 level_handlers__ = Some(map_.next_value()?);
640 }
641 }
642 }
643 Ok(CompactStatus {
644 compaction_group_id: compaction_group_id__.unwrap_or_default(),
645 level_handlers: level_handlers__.unwrap_or_default(),
646 })
647 }
648 }
649 deserializer.deserialize_struct("hummock.CompactStatus", FIELDS, GeneratedVisitor)
650 }
651}
652impl serde::Serialize for CompactTask {
653 #[allow(deprecated)]
654 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
655 where
656 S: serde::Serializer,
657 {
658 use serde::ser::SerializeStruct;
659 let mut len = 0;
660 if !self.input_ssts.is_empty() {
661 len += 1;
662 }
663 if !self.splits.is_empty() {
664 len += 1;
665 }
666 if !self.sorted_output_ssts.is_empty() {
667 len += 1;
668 }
669 if self.task_id != 0 {
670 len += 1;
671 }
672 if self.target_level != 0 {
673 len += 1;
674 }
675 if self.gc_delete_keys {
676 len += 1;
677 }
678 if self.base_level != 0 {
679 len += 1;
680 }
681 if self.task_status != 0 {
682 len += 1;
683 }
684 if self.compaction_group_id != 0 {
685 len += 1;
686 }
687 if !self.existing_table_ids.is_empty() {
688 len += 1;
689 }
690 if self.compression_algorithm != 0 {
691 len += 1;
692 }
693 if self.target_file_size != 0 {
694 len += 1;
695 }
696 if self.compaction_filter_mask != 0 {
697 len += 1;
698 }
699 if !self.table_options.is_empty() {
700 len += 1;
701 }
702 if self.current_epoch_time != 0 {
703 len += 1;
704 }
705 if self.target_sub_level_id != 0 {
706 len += 1;
707 }
708 if self.task_type != 0 {
709 len += 1;
710 }
711 if self.split_by_state_table {
712 len += 1;
713 }
714 if self.split_weight_by_vnode != 0 {
715 len += 1;
716 }
717 if !self.table_vnode_partition.is_empty() {
718 len += 1;
719 }
720 if !self.table_watermarks.is_empty() {
721 len += 1;
722 }
723 if !self.table_schemas.is_empty() {
724 len += 1;
725 }
726 if self.max_sub_compaction != 0 {
727 len += 1;
728 }
729 if self.compaction_group_version_id != 0 {
730 len += 1;
731 }
732 let mut struct_ser = serializer.serialize_struct("hummock.CompactTask", len)?;
733 if !self.input_ssts.is_empty() {
734 struct_ser.serialize_field("inputSsts", &self.input_ssts)?;
735 }
736 if !self.splits.is_empty() {
737 struct_ser.serialize_field("splits", &self.splits)?;
738 }
739 if !self.sorted_output_ssts.is_empty() {
740 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
741 }
742 if self.task_id != 0 {
743 #[allow(clippy::needless_borrow)]
744 #[allow(clippy::needless_borrows_for_generic_args)]
745 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
746 }
747 if self.target_level != 0 {
748 struct_ser.serialize_field("targetLevel", &self.target_level)?;
749 }
750 if self.gc_delete_keys {
751 struct_ser.serialize_field("gcDeleteKeys", &self.gc_delete_keys)?;
752 }
753 if self.base_level != 0 {
754 struct_ser.serialize_field("baseLevel", &self.base_level)?;
755 }
756 if self.task_status != 0 {
757 let v = compact_task::TaskStatus::try_from(self.task_status)
758 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
759 struct_ser.serialize_field("taskStatus", &v)?;
760 }
761 if self.compaction_group_id != 0 {
762 #[allow(clippy::needless_borrow)]
763 #[allow(clippy::needless_borrows_for_generic_args)]
764 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
765 }
766 if !self.existing_table_ids.is_empty() {
767 struct_ser.serialize_field("existingTableIds", &self.existing_table_ids)?;
768 }
769 if self.compression_algorithm != 0 {
770 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
771 }
772 if self.target_file_size != 0 {
773 #[allow(clippy::needless_borrow)]
774 #[allow(clippy::needless_borrows_for_generic_args)]
775 struct_ser.serialize_field("targetFileSize", ToString::to_string(&self.target_file_size).as_str())?;
776 }
777 if self.compaction_filter_mask != 0 {
778 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
779 }
780 if !self.table_options.is_empty() {
781 struct_ser.serialize_field("tableOptions", &self.table_options)?;
782 }
783 if self.current_epoch_time != 0 {
784 #[allow(clippy::needless_borrow)]
785 #[allow(clippy::needless_borrows_for_generic_args)]
786 struct_ser.serialize_field("currentEpochTime", ToString::to_string(&self.current_epoch_time).as_str())?;
787 }
788 if self.target_sub_level_id != 0 {
789 #[allow(clippy::needless_borrow)]
790 #[allow(clippy::needless_borrows_for_generic_args)]
791 struct_ser.serialize_field("targetSubLevelId", ToString::to_string(&self.target_sub_level_id).as_str())?;
792 }
793 if self.task_type != 0 {
794 let v = compact_task::TaskType::try_from(self.task_type)
795 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_type)))?;
796 struct_ser.serialize_field("taskType", &v)?;
797 }
798 if self.split_by_state_table {
799 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
800 }
801 if self.split_weight_by_vnode != 0 {
802 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
803 }
804 if !self.table_vnode_partition.is_empty() {
805 struct_ser.serialize_field("tableVnodePartition", &self.table_vnode_partition)?;
806 }
807 if !self.table_watermarks.is_empty() {
808 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
809 }
810 if !self.table_schemas.is_empty() {
811 struct_ser.serialize_field("tableSchemas", &self.table_schemas)?;
812 }
813 if self.max_sub_compaction != 0 {
814 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
815 }
816 if self.compaction_group_version_id != 0 {
817 #[allow(clippy::needless_borrow)]
818 #[allow(clippy::needless_borrows_for_generic_args)]
819 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
820 }
821 struct_ser.end()
822 }
823}
824impl<'de> serde::Deserialize<'de> for CompactTask {
825 #[allow(deprecated)]
826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
827 where
828 D: serde::Deserializer<'de>,
829 {
830 const FIELDS: &[&str] = &[
831 "input_ssts",
832 "inputSsts",
833 "splits",
834 "sorted_output_ssts",
835 "sortedOutputSsts",
836 "task_id",
837 "taskId",
838 "target_level",
839 "targetLevel",
840 "gc_delete_keys",
841 "gcDeleteKeys",
842 "base_level",
843 "baseLevel",
844 "task_status",
845 "taskStatus",
846 "compaction_group_id",
847 "compactionGroupId",
848 "existing_table_ids",
849 "existingTableIds",
850 "compression_algorithm",
851 "compressionAlgorithm",
852 "target_file_size",
853 "targetFileSize",
854 "compaction_filter_mask",
855 "compactionFilterMask",
856 "table_options",
857 "tableOptions",
858 "current_epoch_time",
859 "currentEpochTime",
860 "target_sub_level_id",
861 "targetSubLevelId",
862 "task_type",
863 "taskType",
864 "split_by_state_table",
865 "splitByStateTable",
866 "split_weight_by_vnode",
867 "splitWeightByVnode",
868 "table_vnode_partition",
869 "tableVnodePartition",
870 "table_watermarks",
871 "tableWatermarks",
872 "table_schemas",
873 "tableSchemas",
874 "max_sub_compaction",
875 "maxSubCompaction",
876 "compaction_group_version_id",
877 "compactionGroupVersionId",
878 ];
879
880 #[allow(clippy::enum_variant_names)]
881 enum GeneratedField {
882 InputSsts,
883 Splits,
884 SortedOutputSsts,
885 TaskId,
886 TargetLevel,
887 GcDeleteKeys,
888 BaseLevel,
889 TaskStatus,
890 CompactionGroupId,
891 ExistingTableIds,
892 CompressionAlgorithm,
893 TargetFileSize,
894 CompactionFilterMask,
895 TableOptions,
896 CurrentEpochTime,
897 TargetSubLevelId,
898 TaskType,
899 SplitByStateTable,
900 SplitWeightByVnode,
901 TableVnodePartition,
902 TableWatermarks,
903 TableSchemas,
904 MaxSubCompaction,
905 CompactionGroupVersionId,
906 }
907 impl<'de> serde::Deserialize<'de> for GeneratedField {
908 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
909 where
910 D: serde::Deserializer<'de>,
911 {
912 struct GeneratedVisitor;
913
914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
915 type Value = GeneratedField;
916
917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
918 write!(formatter, "expected one of: {:?}", &FIELDS)
919 }
920
921 #[allow(unused_variables)]
922 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
923 where
924 E: serde::de::Error,
925 {
926 match value {
927 "inputSsts" | "input_ssts" => Ok(GeneratedField::InputSsts),
928 "splits" => Ok(GeneratedField::Splits),
929 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
930 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
931 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
932 "gcDeleteKeys" | "gc_delete_keys" => Ok(GeneratedField::GcDeleteKeys),
933 "baseLevel" | "base_level" => Ok(GeneratedField::BaseLevel),
934 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
935 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
936 "existingTableIds" | "existing_table_ids" => Ok(GeneratedField::ExistingTableIds),
937 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
938 "targetFileSize" | "target_file_size" => Ok(GeneratedField::TargetFileSize),
939 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
940 "tableOptions" | "table_options" => Ok(GeneratedField::TableOptions),
941 "currentEpochTime" | "current_epoch_time" => Ok(GeneratedField::CurrentEpochTime),
942 "targetSubLevelId" | "target_sub_level_id" => Ok(GeneratedField::TargetSubLevelId),
943 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
944 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
945 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
946 "tableVnodePartition" | "table_vnode_partition" => Ok(GeneratedField::TableVnodePartition),
947 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
948 "tableSchemas" | "table_schemas" => Ok(GeneratedField::TableSchemas),
949 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
950 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
951 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
952 }
953 }
954 }
955 deserializer.deserialize_identifier(GeneratedVisitor)
956 }
957 }
958 struct GeneratedVisitor;
959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
960 type Value = CompactTask;
961
962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
963 formatter.write_str("struct hummock.CompactTask")
964 }
965
966 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTask, V::Error>
967 where
968 V: serde::de::MapAccess<'de>,
969 {
970 let mut input_ssts__ = None;
971 let mut splits__ = None;
972 let mut sorted_output_ssts__ = None;
973 let mut task_id__ = None;
974 let mut target_level__ = None;
975 let mut gc_delete_keys__ = None;
976 let mut base_level__ = None;
977 let mut task_status__ = None;
978 let mut compaction_group_id__ = None;
979 let mut existing_table_ids__ = None;
980 let mut compression_algorithm__ = None;
981 let mut target_file_size__ = None;
982 let mut compaction_filter_mask__ = None;
983 let mut table_options__ = None;
984 let mut current_epoch_time__ = None;
985 let mut target_sub_level_id__ = None;
986 let mut task_type__ = None;
987 let mut split_by_state_table__ = None;
988 let mut split_weight_by_vnode__ = None;
989 let mut table_vnode_partition__ = None;
990 let mut table_watermarks__ = None;
991 let mut table_schemas__ = None;
992 let mut max_sub_compaction__ = None;
993 let mut compaction_group_version_id__ = None;
994 while let Some(k) = map_.next_key()? {
995 match k {
996 GeneratedField::InputSsts => {
997 if input_ssts__.is_some() {
998 return Err(serde::de::Error::duplicate_field("inputSsts"));
999 }
1000 input_ssts__ = Some(map_.next_value()?);
1001 }
1002 GeneratedField::Splits => {
1003 if splits__.is_some() {
1004 return Err(serde::de::Error::duplicate_field("splits"));
1005 }
1006 splits__ = Some(map_.next_value()?);
1007 }
1008 GeneratedField::SortedOutputSsts => {
1009 if sorted_output_ssts__.is_some() {
1010 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
1011 }
1012 sorted_output_ssts__ = Some(map_.next_value()?);
1013 }
1014 GeneratedField::TaskId => {
1015 if task_id__.is_some() {
1016 return Err(serde::de::Error::duplicate_field("taskId"));
1017 }
1018 task_id__ =
1019 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1020 ;
1021 }
1022 GeneratedField::TargetLevel => {
1023 if target_level__.is_some() {
1024 return Err(serde::de::Error::duplicate_field("targetLevel"));
1025 }
1026 target_level__ =
1027 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1028 ;
1029 }
1030 GeneratedField::GcDeleteKeys => {
1031 if gc_delete_keys__.is_some() {
1032 return Err(serde::de::Error::duplicate_field("gcDeleteKeys"));
1033 }
1034 gc_delete_keys__ = Some(map_.next_value()?);
1035 }
1036 GeneratedField::BaseLevel => {
1037 if base_level__.is_some() {
1038 return Err(serde::de::Error::duplicate_field("baseLevel"));
1039 }
1040 base_level__ =
1041 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1042 ;
1043 }
1044 GeneratedField::TaskStatus => {
1045 if task_status__.is_some() {
1046 return Err(serde::de::Error::duplicate_field("taskStatus"));
1047 }
1048 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
1049 }
1050 GeneratedField::CompactionGroupId => {
1051 if compaction_group_id__.is_some() {
1052 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1053 }
1054 compaction_group_id__ =
1055 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1056 ;
1057 }
1058 GeneratedField::ExistingTableIds => {
1059 if existing_table_ids__.is_some() {
1060 return Err(serde::de::Error::duplicate_field("existingTableIds"));
1061 }
1062 existing_table_ids__ =
1063 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1064 .into_iter().map(|x| x.0).collect())
1065 ;
1066 }
1067 GeneratedField::CompressionAlgorithm => {
1068 if compression_algorithm__.is_some() {
1069 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
1070 }
1071 compression_algorithm__ =
1072 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1073 ;
1074 }
1075 GeneratedField::TargetFileSize => {
1076 if target_file_size__.is_some() {
1077 return Err(serde::de::Error::duplicate_field("targetFileSize"));
1078 }
1079 target_file_size__ =
1080 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1081 ;
1082 }
1083 GeneratedField::CompactionFilterMask => {
1084 if compaction_filter_mask__.is_some() {
1085 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
1086 }
1087 compaction_filter_mask__ =
1088 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1089 ;
1090 }
1091 GeneratedField::TableOptions => {
1092 if table_options__.is_some() {
1093 return Err(serde::de::Error::duplicate_field("tableOptions"));
1094 }
1095 table_options__ = Some(
1096 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1097 .into_iter().map(|(k,v)| (k.0, v)).collect()
1098 );
1099 }
1100 GeneratedField::CurrentEpochTime => {
1101 if current_epoch_time__.is_some() {
1102 return Err(serde::de::Error::duplicate_field("currentEpochTime"));
1103 }
1104 current_epoch_time__ =
1105 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1106 ;
1107 }
1108 GeneratedField::TargetSubLevelId => {
1109 if target_sub_level_id__.is_some() {
1110 return Err(serde::de::Error::duplicate_field("targetSubLevelId"));
1111 }
1112 target_sub_level_id__ =
1113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1114 ;
1115 }
1116 GeneratedField::TaskType => {
1117 if task_type__.is_some() {
1118 return Err(serde::de::Error::duplicate_field("taskType"));
1119 }
1120 task_type__ = Some(map_.next_value::<compact_task::TaskType>()? as i32);
1121 }
1122 GeneratedField::SplitByStateTable => {
1123 if split_by_state_table__.is_some() {
1124 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
1125 }
1126 split_by_state_table__ = Some(map_.next_value()?);
1127 }
1128 GeneratedField::SplitWeightByVnode => {
1129 if split_weight_by_vnode__.is_some() {
1130 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
1131 }
1132 split_weight_by_vnode__ =
1133 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1134 ;
1135 }
1136 GeneratedField::TableVnodePartition => {
1137 if table_vnode_partition__.is_some() {
1138 return Err(serde::de::Error::duplicate_field("tableVnodePartition"));
1139 }
1140 table_vnode_partition__ = Some(
1141 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
1142 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
1143 );
1144 }
1145 GeneratedField::TableWatermarks => {
1146 if table_watermarks__.is_some() {
1147 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
1148 }
1149 table_watermarks__ = Some(
1150 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1151 .into_iter().map(|(k,v)| (k.0, v)).collect()
1152 );
1153 }
1154 GeneratedField::TableSchemas => {
1155 if table_schemas__.is_some() {
1156 return Err(serde::de::Error::duplicate_field("tableSchemas"));
1157 }
1158 table_schemas__ = Some(
1159 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1160 .into_iter().map(|(k,v)| (k.0, v)).collect()
1161 );
1162 }
1163 GeneratedField::MaxSubCompaction => {
1164 if max_sub_compaction__.is_some() {
1165 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
1166 }
1167 max_sub_compaction__ =
1168 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1169 ;
1170 }
1171 GeneratedField::CompactionGroupVersionId => {
1172 if compaction_group_version_id__.is_some() {
1173 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
1174 }
1175 compaction_group_version_id__ =
1176 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1177 ;
1178 }
1179 }
1180 }
1181 Ok(CompactTask {
1182 input_ssts: input_ssts__.unwrap_or_default(),
1183 splits: splits__.unwrap_or_default(),
1184 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
1185 task_id: task_id__.unwrap_or_default(),
1186 target_level: target_level__.unwrap_or_default(),
1187 gc_delete_keys: gc_delete_keys__.unwrap_or_default(),
1188 base_level: base_level__.unwrap_or_default(),
1189 task_status: task_status__.unwrap_or_default(),
1190 compaction_group_id: compaction_group_id__.unwrap_or_default(),
1191 existing_table_ids: existing_table_ids__.unwrap_or_default(),
1192 compression_algorithm: compression_algorithm__.unwrap_or_default(),
1193 target_file_size: target_file_size__.unwrap_or_default(),
1194 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
1195 table_options: table_options__.unwrap_or_default(),
1196 current_epoch_time: current_epoch_time__.unwrap_or_default(),
1197 target_sub_level_id: target_sub_level_id__.unwrap_or_default(),
1198 task_type: task_type__.unwrap_or_default(),
1199 split_by_state_table: split_by_state_table__.unwrap_or_default(),
1200 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
1201 table_vnode_partition: table_vnode_partition__.unwrap_or_default(),
1202 table_watermarks: table_watermarks__.unwrap_or_default(),
1203 table_schemas: table_schemas__.unwrap_or_default(),
1204 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
1205 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
1206 })
1207 }
1208 }
1209 deserializer.deserialize_struct("hummock.CompactTask", FIELDS, GeneratedVisitor)
1210 }
1211}
1212impl serde::Serialize for compact_task::TaskStatus {
1213 #[allow(deprecated)]
1214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1215 where
1216 S: serde::Serializer,
1217 {
1218 let variant = match self {
1219 Self::Unspecified => "UNSPECIFIED",
1220 Self::Pending => "PENDING",
1221 Self::Success => "SUCCESS",
1222 Self::HeartbeatCanceled => "HEARTBEAT_CANCELED",
1223 Self::NoAvailMemoryResourceCanceled => "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1224 Self::AssignFailCanceled => "ASSIGN_FAIL_CANCELED",
1225 Self::SendFailCanceled => "SEND_FAIL_CANCELED",
1226 Self::ManualCanceled => "MANUAL_CANCELED",
1227 Self::InvalidGroupCanceled => "INVALID_GROUP_CANCELED",
1228 Self::InputOutdatedCanceled => "INPUT_OUTDATED_CANCELED",
1229 Self::ExecuteFailed => "EXECUTE_FAILED",
1230 Self::JoinHandleFailed => "JOIN_HANDLE_FAILED",
1231 Self::TrackSstObjectIdFailed => "TRACK_SST_OBJECT_ID_FAILED",
1232 Self::NoAvailCpuResourceCanceled => "NO_AVAIL_CPU_RESOURCE_CANCELED",
1233 Self::HeartbeatProgressCanceled => "HEARTBEAT_PROGRESS_CANCELED",
1234 Self::RetentionTimeRejected => "RETENTION_TIME_REJECTED",
1235 Self::ServerlessSendFailCanceled => "SERVERLESS_SEND_FAIL_CANCELED",
1236 Self::ServerlessTableNotFoundCanceled => "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1237 };
1238 serializer.serialize_str(variant)
1239 }
1240}
1241impl<'de> serde::Deserialize<'de> for compact_task::TaskStatus {
1242 #[allow(deprecated)]
1243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1244 where
1245 D: serde::Deserializer<'de>,
1246 {
1247 const FIELDS: &[&str] = &[
1248 "UNSPECIFIED",
1249 "PENDING",
1250 "SUCCESS",
1251 "HEARTBEAT_CANCELED",
1252 "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1253 "ASSIGN_FAIL_CANCELED",
1254 "SEND_FAIL_CANCELED",
1255 "MANUAL_CANCELED",
1256 "INVALID_GROUP_CANCELED",
1257 "INPUT_OUTDATED_CANCELED",
1258 "EXECUTE_FAILED",
1259 "JOIN_HANDLE_FAILED",
1260 "TRACK_SST_OBJECT_ID_FAILED",
1261 "NO_AVAIL_CPU_RESOURCE_CANCELED",
1262 "HEARTBEAT_PROGRESS_CANCELED",
1263 "RETENTION_TIME_REJECTED",
1264 "SERVERLESS_SEND_FAIL_CANCELED",
1265 "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1266 ];
1267
1268 struct GeneratedVisitor;
1269
1270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1271 type Value = compact_task::TaskStatus;
1272
1273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1274 write!(formatter, "expected one of: {:?}", &FIELDS)
1275 }
1276
1277 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1278 where
1279 E: serde::de::Error,
1280 {
1281 i32::try_from(v)
1282 .ok()
1283 .and_then(|x| x.try_into().ok())
1284 .ok_or_else(|| {
1285 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1286 })
1287 }
1288
1289 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1290 where
1291 E: serde::de::Error,
1292 {
1293 i32::try_from(v)
1294 .ok()
1295 .and_then(|x| x.try_into().ok())
1296 .ok_or_else(|| {
1297 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1298 })
1299 }
1300
1301 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1302 where
1303 E: serde::de::Error,
1304 {
1305 match value {
1306 "UNSPECIFIED" => Ok(compact_task::TaskStatus::Unspecified),
1307 "PENDING" => Ok(compact_task::TaskStatus::Pending),
1308 "SUCCESS" => Ok(compact_task::TaskStatus::Success),
1309 "HEARTBEAT_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatCanceled),
1310 "NO_AVAIL_MEMORY_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailMemoryResourceCanceled),
1311 "ASSIGN_FAIL_CANCELED" => Ok(compact_task::TaskStatus::AssignFailCanceled),
1312 "SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::SendFailCanceled),
1313 "MANUAL_CANCELED" => Ok(compact_task::TaskStatus::ManualCanceled),
1314 "INVALID_GROUP_CANCELED" => Ok(compact_task::TaskStatus::InvalidGroupCanceled),
1315 "INPUT_OUTDATED_CANCELED" => Ok(compact_task::TaskStatus::InputOutdatedCanceled),
1316 "EXECUTE_FAILED" => Ok(compact_task::TaskStatus::ExecuteFailed),
1317 "JOIN_HANDLE_FAILED" => Ok(compact_task::TaskStatus::JoinHandleFailed),
1318 "TRACK_SST_OBJECT_ID_FAILED" => Ok(compact_task::TaskStatus::TrackSstObjectIdFailed),
1319 "NO_AVAIL_CPU_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailCpuResourceCanceled),
1320 "HEARTBEAT_PROGRESS_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatProgressCanceled),
1321 "RETENTION_TIME_REJECTED" => Ok(compact_task::TaskStatus::RetentionTimeRejected),
1322 "SERVERLESS_SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::ServerlessSendFailCanceled),
1323 "SERVERLESS_TABLE_NOT_FOUND_CANCELED" => Ok(compact_task::TaskStatus::ServerlessTableNotFoundCanceled),
1324 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1325 }
1326 }
1327 }
1328 deserializer.deserialize_any(GeneratedVisitor)
1329 }
1330}
1331impl serde::Serialize for compact_task::TaskType {
1332 #[allow(deprecated)]
1333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1334 where
1335 S: serde::Serializer,
1336 {
1337 let variant = match self {
1338 Self::TypeUnspecified => "TYPE_UNSPECIFIED",
1339 Self::Dynamic => "DYNAMIC",
1340 Self::SpaceReclaim => "SPACE_RECLAIM",
1341 Self::Manual => "MANUAL",
1342 Self::SharedBuffer => "SHARED_BUFFER",
1343 Self::Ttl => "TTL",
1344 Self::Tombstone => "TOMBSTONE",
1345 Self::Emergency => "EMERGENCY",
1346 Self::VnodeWatermark => "VNODE_WATERMARK",
1347 };
1348 serializer.serialize_str(variant)
1349 }
1350}
1351impl<'de> serde::Deserialize<'de> for compact_task::TaskType {
1352 #[allow(deprecated)]
1353 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1354 where
1355 D: serde::Deserializer<'de>,
1356 {
1357 const FIELDS: &[&str] = &[
1358 "TYPE_UNSPECIFIED",
1359 "DYNAMIC",
1360 "SPACE_RECLAIM",
1361 "MANUAL",
1362 "SHARED_BUFFER",
1363 "TTL",
1364 "TOMBSTONE",
1365 "EMERGENCY",
1366 "VNODE_WATERMARK",
1367 ];
1368
1369 struct GeneratedVisitor;
1370
1371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1372 type Value = compact_task::TaskType;
1373
1374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1375 write!(formatter, "expected one of: {:?}", &FIELDS)
1376 }
1377
1378 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1379 where
1380 E: serde::de::Error,
1381 {
1382 i32::try_from(v)
1383 .ok()
1384 .and_then(|x| x.try_into().ok())
1385 .ok_or_else(|| {
1386 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1387 })
1388 }
1389
1390 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1391 where
1392 E: serde::de::Error,
1393 {
1394 i32::try_from(v)
1395 .ok()
1396 .and_then(|x| x.try_into().ok())
1397 .ok_or_else(|| {
1398 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1399 })
1400 }
1401
1402 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1403 where
1404 E: serde::de::Error,
1405 {
1406 match value {
1407 "TYPE_UNSPECIFIED" => Ok(compact_task::TaskType::TypeUnspecified),
1408 "DYNAMIC" => Ok(compact_task::TaskType::Dynamic),
1409 "SPACE_RECLAIM" => Ok(compact_task::TaskType::SpaceReclaim),
1410 "MANUAL" => Ok(compact_task::TaskType::Manual),
1411 "SHARED_BUFFER" => Ok(compact_task::TaskType::SharedBuffer),
1412 "TTL" => Ok(compact_task::TaskType::Ttl),
1413 "TOMBSTONE" => Ok(compact_task::TaskType::Tombstone),
1414 "EMERGENCY" => Ok(compact_task::TaskType::Emergency),
1415 "VNODE_WATERMARK" => Ok(compact_task::TaskType::VnodeWatermark),
1416 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1417 }
1418 }
1419 }
1420 deserializer.deserialize_any(GeneratedVisitor)
1421 }
1422}
1423impl serde::Serialize for CompactTaskAssignment {
1424 #[allow(deprecated)]
1425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1426 where
1427 S: serde::Serializer,
1428 {
1429 use serde::ser::SerializeStruct;
1430 let mut len = 0;
1431 if self.compact_task.is_some() {
1432 len += 1;
1433 }
1434 if self.context_id != 0 {
1435 len += 1;
1436 }
1437 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskAssignment", len)?;
1438 if let Some(v) = self.compact_task.as_ref() {
1439 struct_ser.serialize_field("compactTask", v)?;
1440 }
1441 if self.context_id != 0 {
1442 struct_ser.serialize_field("contextId", &self.context_id)?;
1443 }
1444 struct_ser.end()
1445 }
1446}
1447impl<'de> serde::Deserialize<'de> for CompactTaskAssignment {
1448 #[allow(deprecated)]
1449 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1450 where
1451 D: serde::Deserializer<'de>,
1452 {
1453 const FIELDS: &[&str] = &[
1454 "compact_task",
1455 "compactTask",
1456 "context_id",
1457 "contextId",
1458 ];
1459
1460 #[allow(clippy::enum_variant_names)]
1461 enum GeneratedField {
1462 CompactTask,
1463 ContextId,
1464 }
1465 impl<'de> serde::Deserialize<'de> for GeneratedField {
1466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1467 where
1468 D: serde::Deserializer<'de>,
1469 {
1470 struct GeneratedVisitor;
1471
1472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1473 type Value = GeneratedField;
1474
1475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1476 write!(formatter, "expected one of: {:?}", &FIELDS)
1477 }
1478
1479 #[allow(unused_variables)]
1480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1481 where
1482 E: serde::de::Error,
1483 {
1484 match value {
1485 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
1486 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
1487 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1488 }
1489 }
1490 }
1491 deserializer.deserialize_identifier(GeneratedVisitor)
1492 }
1493 }
1494 struct GeneratedVisitor;
1495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1496 type Value = CompactTaskAssignment;
1497
1498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1499 formatter.write_str("struct hummock.CompactTaskAssignment")
1500 }
1501
1502 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskAssignment, V::Error>
1503 where
1504 V: serde::de::MapAccess<'de>,
1505 {
1506 let mut compact_task__ = None;
1507 let mut context_id__ = None;
1508 while let Some(k) = map_.next_key()? {
1509 match k {
1510 GeneratedField::CompactTask => {
1511 if compact_task__.is_some() {
1512 return Err(serde::de::Error::duplicate_field("compactTask"));
1513 }
1514 compact_task__ = map_.next_value()?;
1515 }
1516 GeneratedField::ContextId => {
1517 if context_id__.is_some() {
1518 return Err(serde::de::Error::duplicate_field("contextId"));
1519 }
1520 context_id__ =
1521 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1522 ;
1523 }
1524 }
1525 }
1526 Ok(CompactTaskAssignment {
1527 compact_task: compact_task__,
1528 context_id: context_id__.unwrap_or_default(),
1529 })
1530 }
1531 }
1532 deserializer.deserialize_struct("hummock.CompactTaskAssignment", FIELDS, GeneratedVisitor)
1533 }
1534}
1535impl serde::Serialize for CompactTaskProgress {
1536 #[allow(deprecated)]
1537 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1538 where
1539 S: serde::Serializer,
1540 {
1541 use serde::ser::SerializeStruct;
1542 let mut len = 0;
1543 if self.task_id != 0 {
1544 len += 1;
1545 }
1546 if self.num_ssts_sealed != 0 {
1547 len += 1;
1548 }
1549 if self.num_ssts_uploaded != 0 {
1550 len += 1;
1551 }
1552 if self.num_progress_key != 0 {
1553 len += 1;
1554 }
1555 if self.num_pending_read_io != 0 {
1556 len += 1;
1557 }
1558 if self.num_pending_write_io != 0 {
1559 len += 1;
1560 }
1561 if self.compaction_group_id.is_some() {
1562 len += 1;
1563 }
1564 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskProgress", len)?;
1565 if self.task_id != 0 {
1566 #[allow(clippy::needless_borrow)]
1567 #[allow(clippy::needless_borrows_for_generic_args)]
1568 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
1569 }
1570 if self.num_ssts_sealed != 0 {
1571 struct_ser.serialize_field("numSstsSealed", &self.num_ssts_sealed)?;
1572 }
1573 if self.num_ssts_uploaded != 0 {
1574 struct_ser.serialize_field("numSstsUploaded", &self.num_ssts_uploaded)?;
1575 }
1576 if self.num_progress_key != 0 {
1577 #[allow(clippy::needless_borrow)]
1578 #[allow(clippy::needless_borrows_for_generic_args)]
1579 struct_ser.serialize_field("numProgressKey", ToString::to_string(&self.num_progress_key).as_str())?;
1580 }
1581 if self.num_pending_read_io != 0 {
1582 #[allow(clippy::needless_borrow)]
1583 #[allow(clippy::needless_borrows_for_generic_args)]
1584 struct_ser.serialize_field("numPendingReadIo", ToString::to_string(&self.num_pending_read_io).as_str())?;
1585 }
1586 if self.num_pending_write_io != 0 {
1587 #[allow(clippy::needless_borrow)]
1588 #[allow(clippy::needless_borrows_for_generic_args)]
1589 struct_ser.serialize_field("numPendingWriteIo", ToString::to_string(&self.num_pending_write_io).as_str())?;
1590 }
1591 if let Some(v) = self.compaction_group_id.as_ref() {
1592 #[allow(clippy::needless_borrow)]
1593 #[allow(clippy::needless_borrows_for_generic_args)]
1594 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&v).as_str())?;
1595 }
1596 struct_ser.end()
1597 }
1598}
1599impl<'de> serde::Deserialize<'de> for CompactTaskProgress {
1600 #[allow(deprecated)]
1601 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1602 where
1603 D: serde::Deserializer<'de>,
1604 {
1605 const FIELDS: &[&str] = &[
1606 "task_id",
1607 "taskId",
1608 "num_ssts_sealed",
1609 "numSstsSealed",
1610 "num_ssts_uploaded",
1611 "numSstsUploaded",
1612 "num_progress_key",
1613 "numProgressKey",
1614 "num_pending_read_io",
1615 "numPendingReadIo",
1616 "num_pending_write_io",
1617 "numPendingWriteIo",
1618 "compaction_group_id",
1619 "compactionGroupId",
1620 ];
1621
1622 #[allow(clippy::enum_variant_names)]
1623 enum GeneratedField {
1624 TaskId,
1625 NumSstsSealed,
1626 NumSstsUploaded,
1627 NumProgressKey,
1628 NumPendingReadIo,
1629 NumPendingWriteIo,
1630 CompactionGroupId,
1631 }
1632 impl<'de> serde::Deserialize<'de> for GeneratedField {
1633 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1634 where
1635 D: serde::Deserializer<'de>,
1636 {
1637 struct GeneratedVisitor;
1638
1639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1640 type Value = GeneratedField;
1641
1642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1643 write!(formatter, "expected one of: {:?}", &FIELDS)
1644 }
1645
1646 #[allow(unused_variables)]
1647 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1648 where
1649 E: serde::de::Error,
1650 {
1651 match value {
1652 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1653 "numSstsSealed" | "num_ssts_sealed" => Ok(GeneratedField::NumSstsSealed),
1654 "numSstsUploaded" | "num_ssts_uploaded" => Ok(GeneratedField::NumSstsUploaded),
1655 "numProgressKey" | "num_progress_key" => Ok(GeneratedField::NumProgressKey),
1656 "numPendingReadIo" | "num_pending_read_io" => Ok(GeneratedField::NumPendingReadIo),
1657 "numPendingWriteIo" | "num_pending_write_io" => Ok(GeneratedField::NumPendingWriteIo),
1658 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
1659 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1660 }
1661 }
1662 }
1663 deserializer.deserialize_identifier(GeneratedVisitor)
1664 }
1665 }
1666 struct GeneratedVisitor;
1667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1668 type Value = CompactTaskProgress;
1669
1670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1671 formatter.write_str("struct hummock.CompactTaskProgress")
1672 }
1673
1674 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskProgress, V::Error>
1675 where
1676 V: serde::de::MapAccess<'de>,
1677 {
1678 let mut task_id__ = None;
1679 let mut num_ssts_sealed__ = None;
1680 let mut num_ssts_uploaded__ = None;
1681 let mut num_progress_key__ = None;
1682 let mut num_pending_read_io__ = None;
1683 let mut num_pending_write_io__ = None;
1684 let mut compaction_group_id__ = None;
1685 while let Some(k) = map_.next_key()? {
1686 match k {
1687 GeneratedField::TaskId => {
1688 if task_id__.is_some() {
1689 return Err(serde::de::Error::duplicate_field("taskId"));
1690 }
1691 task_id__ =
1692 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1693 ;
1694 }
1695 GeneratedField::NumSstsSealed => {
1696 if num_ssts_sealed__.is_some() {
1697 return Err(serde::de::Error::duplicate_field("numSstsSealed"));
1698 }
1699 num_ssts_sealed__ =
1700 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1701 ;
1702 }
1703 GeneratedField::NumSstsUploaded => {
1704 if num_ssts_uploaded__.is_some() {
1705 return Err(serde::de::Error::duplicate_field("numSstsUploaded"));
1706 }
1707 num_ssts_uploaded__ =
1708 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1709 ;
1710 }
1711 GeneratedField::NumProgressKey => {
1712 if num_progress_key__.is_some() {
1713 return Err(serde::de::Error::duplicate_field("numProgressKey"));
1714 }
1715 num_progress_key__ =
1716 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1717 ;
1718 }
1719 GeneratedField::NumPendingReadIo => {
1720 if num_pending_read_io__.is_some() {
1721 return Err(serde::de::Error::duplicate_field("numPendingReadIo"));
1722 }
1723 num_pending_read_io__ =
1724 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1725 ;
1726 }
1727 GeneratedField::NumPendingWriteIo => {
1728 if num_pending_write_io__.is_some() {
1729 return Err(serde::de::Error::duplicate_field("numPendingWriteIo"));
1730 }
1731 num_pending_write_io__ =
1732 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1733 ;
1734 }
1735 GeneratedField::CompactionGroupId => {
1736 if compaction_group_id__.is_some() {
1737 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1738 }
1739 compaction_group_id__ =
1740 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1741 ;
1742 }
1743 }
1744 }
1745 Ok(CompactTaskProgress {
1746 task_id: task_id__.unwrap_or_default(),
1747 num_ssts_sealed: num_ssts_sealed__.unwrap_or_default(),
1748 num_ssts_uploaded: num_ssts_uploaded__.unwrap_or_default(),
1749 num_progress_key: num_progress_key__.unwrap_or_default(),
1750 num_pending_read_io: num_pending_read_io__.unwrap_or_default(),
1751 num_pending_write_io: num_pending_write_io__.unwrap_or_default(),
1752 compaction_group_id: compaction_group_id__,
1753 })
1754 }
1755 }
1756 deserializer.deserialize_struct("hummock.CompactTaskProgress", FIELDS, GeneratedVisitor)
1757 }
1758}
1759impl serde::Serialize for CompactionConfig {
1760 #[allow(deprecated)]
1761 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1762 where
1763 S: serde::Serializer,
1764 {
1765 use serde::ser::SerializeStruct;
1766 let mut len = 0;
1767 if self.max_bytes_for_level_base != 0 {
1768 len += 1;
1769 }
1770 if self.max_level != 0 {
1771 len += 1;
1772 }
1773 if self.max_bytes_for_level_multiplier != 0 {
1774 len += 1;
1775 }
1776 if self.max_compaction_bytes != 0 {
1777 len += 1;
1778 }
1779 if self.sub_level_max_compaction_bytes != 0 {
1780 len += 1;
1781 }
1782 if self.level0_tier_compact_file_number != 0 {
1783 len += 1;
1784 }
1785 if self.compaction_mode != 0 {
1786 len += 1;
1787 }
1788 if !self.compression_algorithm.is_empty() {
1789 len += 1;
1790 }
1791 if self.target_file_size_base != 0 {
1792 len += 1;
1793 }
1794 if self.compaction_filter_mask != 0 {
1795 len += 1;
1796 }
1797 if self.max_sub_compaction != 0 {
1798 len += 1;
1799 }
1800 if self.max_space_reclaim_bytes != 0 {
1801 len += 1;
1802 }
1803 if self.split_by_state_table {
1804 len += 1;
1805 }
1806 if self.split_weight_by_vnode != 0 {
1807 len += 1;
1808 }
1809 if self.level0_stop_write_threshold_sub_level_number != 0 {
1810 len += 1;
1811 }
1812 if self.level0_max_compact_file_number != 0 {
1813 len += 1;
1814 }
1815 if self.level0_sub_level_compact_level_count != 0 {
1816 len += 1;
1817 }
1818 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1819 len += 1;
1820 }
1821 if self.tombstone_reclaim_ratio != 0 {
1822 len += 1;
1823 }
1824 if self.enable_emergency_picker {
1825 len += 1;
1826 }
1827 if self.max_l0_compact_level_count.is_some() {
1828 len += 1;
1829 }
1830 if self.sst_allowed_trivial_move_min_size.is_some() {
1831 len += 1;
1832 }
1833 if self.disable_auto_group_scheduling.is_some() {
1834 len += 1;
1835 }
1836 if self.max_overlapping_level_size.is_some() {
1837 len += 1;
1838 }
1839 if self.emergency_level0_sst_file_count.is_some() {
1840 len += 1;
1841 }
1842 if self.emergency_level0_sub_level_partition.is_some() {
1843 len += 1;
1844 }
1845 if self.level0_stop_write_threshold_max_sst_count.is_some() {
1846 len += 1;
1847 }
1848 if self.level0_stop_write_threshold_max_size.is_some() {
1849 len += 1;
1850 }
1851 if self.sst_allowed_trivial_move_max_count.is_some() {
1852 len += 1;
1853 }
1854 if self.enable_optimize_l0_interval_selection.is_some() {
1855 len += 1;
1856 }
1857 let mut struct_ser = serializer.serialize_struct("hummock.CompactionConfig", len)?;
1858 if self.max_bytes_for_level_base != 0 {
1859 #[allow(clippy::needless_borrow)]
1860 #[allow(clippy::needless_borrows_for_generic_args)]
1861 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&self.max_bytes_for_level_base).as_str())?;
1862 }
1863 if self.max_level != 0 {
1864 #[allow(clippy::needless_borrow)]
1865 #[allow(clippy::needless_borrows_for_generic_args)]
1866 struct_ser.serialize_field("maxLevel", ToString::to_string(&self.max_level).as_str())?;
1867 }
1868 if self.max_bytes_for_level_multiplier != 0 {
1869 #[allow(clippy::needless_borrow)]
1870 #[allow(clippy::needless_borrows_for_generic_args)]
1871 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&self.max_bytes_for_level_multiplier).as_str())?;
1872 }
1873 if self.max_compaction_bytes != 0 {
1874 #[allow(clippy::needless_borrow)]
1875 #[allow(clippy::needless_borrows_for_generic_args)]
1876 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&self.max_compaction_bytes).as_str())?;
1877 }
1878 if self.sub_level_max_compaction_bytes != 0 {
1879 #[allow(clippy::needless_borrow)]
1880 #[allow(clippy::needless_borrows_for_generic_args)]
1881 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&self.sub_level_max_compaction_bytes).as_str())?;
1882 }
1883 if self.level0_tier_compact_file_number != 0 {
1884 #[allow(clippy::needless_borrow)]
1885 #[allow(clippy::needless_borrows_for_generic_args)]
1886 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&self.level0_tier_compact_file_number).as_str())?;
1887 }
1888 if self.compaction_mode != 0 {
1889 let v = compaction_config::CompactionMode::try_from(self.compaction_mode)
1890 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compaction_mode)))?;
1891 struct_ser.serialize_field("compactionMode", &v)?;
1892 }
1893 if !self.compression_algorithm.is_empty() {
1894 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
1895 }
1896 if self.target_file_size_base != 0 {
1897 #[allow(clippy::needless_borrow)]
1898 #[allow(clippy::needless_borrows_for_generic_args)]
1899 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&self.target_file_size_base).as_str())?;
1900 }
1901 if self.compaction_filter_mask != 0 {
1902 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
1903 }
1904 if self.max_sub_compaction != 0 {
1905 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
1906 }
1907 if self.max_space_reclaim_bytes != 0 {
1908 #[allow(clippy::needless_borrow)]
1909 #[allow(clippy::needless_borrows_for_generic_args)]
1910 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&self.max_space_reclaim_bytes).as_str())?;
1911 }
1912 if self.split_by_state_table {
1913 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
1914 }
1915 if self.split_weight_by_vnode != 0 {
1916 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
1917 }
1918 if self.level0_stop_write_threshold_sub_level_number != 0 {
1919 #[allow(clippy::needless_borrow)]
1920 #[allow(clippy::needless_borrows_for_generic_args)]
1921 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&self.level0_stop_write_threshold_sub_level_number).as_str())?;
1922 }
1923 if self.level0_max_compact_file_number != 0 {
1924 #[allow(clippy::needless_borrow)]
1925 #[allow(clippy::needless_borrows_for_generic_args)]
1926 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&self.level0_max_compact_file_number).as_str())?;
1927 }
1928 if self.level0_sub_level_compact_level_count != 0 {
1929 struct_ser.serialize_field("level0SubLevelCompactLevelCount", &self.level0_sub_level_compact_level_count)?;
1930 }
1931 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1932 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", &self.level0_overlapping_sub_level_compact_level_count)?;
1933 }
1934 if self.tombstone_reclaim_ratio != 0 {
1935 struct_ser.serialize_field("tombstoneReclaimRatio", &self.tombstone_reclaim_ratio)?;
1936 }
1937 if self.enable_emergency_picker {
1938 struct_ser.serialize_field("enableEmergencyPicker", &self.enable_emergency_picker)?;
1939 }
1940 if let Some(v) = self.max_l0_compact_level_count.as_ref() {
1941 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
1942 }
1943 if let Some(v) = self.sst_allowed_trivial_move_min_size.as_ref() {
1944 #[allow(clippy::needless_borrow)]
1945 #[allow(clippy::needless_borrows_for_generic_args)]
1946 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
1947 }
1948 if let Some(v) = self.disable_auto_group_scheduling.as_ref() {
1949 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
1950 }
1951 if let Some(v) = self.max_overlapping_level_size.as_ref() {
1952 #[allow(clippy::needless_borrow)]
1953 #[allow(clippy::needless_borrows_for_generic_args)]
1954 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
1955 }
1956 if let Some(v) = self.emergency_level0_sst_file_count.as_ref() {
1957 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
1958 }
1959 if let Some(v) = self.emergency_level0_sub_level_partition.as_ref() {
1960 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
1961 }
1962 if let Some(v) = self.level0_stop_write_threshold_max_sst_count.as_ref() {
1963 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
1964 }
1965 if let Some(v) = self.level0_stop_write_threshold_max_size.as_ref() {
1966 #[allow(clippy::needless_borrow)]
1967 #[allow(clippy::needless_borrows_for_generic_args)]
1968 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
1969 }
1970 if let Some(v) = self.sst_allowed_trivial_move_max_count.as_ref() {
1971 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
1972 }
1973 if let Some(v) = self.enable_optimize_l0_interval_selection.as_ref() {
1974 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
1975 }
1976 struct_ser.end()
1977 }
1978}
1979impl<'de> serde::Deserialize<'de> for CompactionConfig {
1980 #[allow(deprecated)]
1981 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1982 where
1983 D: serde::Deserializer<'de>,
1984 {
1985 const FIELDS: &[&str] = &[
1986 "max_bytes_for_level_base",
1987 "maxBytesForLevelBase",
1988 "max_level",
1989 "maxLevel",
1990 "max_bytes_for_level_multiplier",
1991 "maxBytesForLevelMultiplier",
1992 "max_compaction_bytes",
1993 "maxCompactionBytes",
1994 "sub_level_max_compaction_bytes",
1995 "subLevelMaxCompactionBytes",
1996 "level0_tier_compact_file_number",
1997 "level0TierCompactFileNumber",
1998 "compaction_mode",
1999 "compactionMode",
2000 "compression_algorithm",
2001 "compressionAlgorithm",
2002 "target_file_size_base",
2003 "targetFileSizeBase",
2004 "compaction_filter_mask",
2005 "compactionFilterMask",
2006 "max_sub_compaction",
2007 "maxSubCompaction",
2008 "max_space_reclaim_bytes",
2009 "maxSpaceReclaimBytes",
2010 "split_by_state_table",
2011 "splitByStateTable",
2012 "split_weight_by_vnode",
2013 "splitWeightByVnode",
2014 "level0_stop_write_threshold_sub_level_number",
2015 "level0StopWriteThresholdSubLevelNumber",
2016 "level0_max_compact_file_number",
2017 "level0MaxCompactFileNumber",
2018 "level0_sub_level_compact_level_count",
2019 "level0SubLevelCompactLevelCount",
2020 "level0_overlapping_sub_level_compact_level_count",
2021 "level0OverlappingSubLevelCompactLevelCount",
2022 "tombstone_reclaim_ratio",
2023 "tombstoneReclaimRatio",
2024 "enable_emergency_picker",
2025 "enableEmergencyPicker",
2026 "max_l0_compact_level_count",
2027 "maxL0CompactLevelCount",
2028 "sst_allowed_trivial_move_min_size",
2029 "sstAllowedTrivialMoveMinSize",
2030 "disable_auto_group_scheduling",
2031 "disableAutoGroupScheduling",
2032 "max_overlapping_level_size",
2033 "maxOverlappingLevelSize",
2034 "emergency_level0_sst_file_count",
2035 "emergencyLevel0SstFileCount",
2036 "emergency_level0_sub_level_partition",
2037 "emergencyLevel0SubLevelPartition",
2038 "level0_stop_write_threshold_max_sst_count",
2039 "level0StopWriteThresholdMaxSstCount",
2040 "level0_stop_write_threshold_max_size",
2041 "level0StopWriteThresholdMaxSize",
2042 "sst_allowed_trivial_move_max_count",
2043 "sstAllowedTrivialMoveMaxCount",
2044 "enable_optimize_l0_interval_selection",
2045 "enableOptimizeL0IntervalSelection",
2046 ];
2047
2048 #[allow(clippy::enum_variant_names)]
2049 enum GeneratedField {
2050 MaxBytesForLevelBase,
2051 MaxLevel,
2052 MaxBytesForLevelMultiplier,
2053 MaxCompactionBytes,
2054 SubLevelMaxCompactionBytes,
2055 Level0TierCompactFileNumber,
2056 CompactionMode,
2057 CompressionAlgorithm,
2058 TargetFileSizeBase,
2059 CompactionFilterMask,
2060 MaxSubCompaction,
2061 MaxSpaceReclaimBytes,
2062 SplitByStateTable,
2063 SplitWeightByVnode,
2064 Level0StopWriteThresholdSubLevelNumber,
2065 Level0MaxCompactFileNumber,
2066 Level0SubLevelCompactLevelCount,
2067 Level0OverlappingSubLevelCompactLevelCount,
2068 TombstoneReclaimRatio,
2069 EnableEmergencyPicker,
2070 MaxL0CompactLevelCount,
2071 SstAllowedTrivialMoveMinSize,
2072 DisableAutoGroupScheduling,
2073 MaxOverlappingLevelSize,
2074 EmergencyLevel0SstFileCount,
2075 EmergencyLevel0SubLevelPartition,
2076 Level0StopWriteThresholdMaxSstCount,
2077 Level0StopWriteThresholdMaxSize,
2078 SstAllowedTrivialMoveMaxCount,
2079 EnableOptimizeL0IntervalSelection,
2080 }
2081 impl<'de> serde::Deserialize<'de> for GeneratedField {
2082 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2083 where
2084 D: serde::Deserializer<'de>,
2085 {
2086 struct GeneratedVisitor;
2087
2088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2089 type Value = GeneratedField;
2090
2091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2092 write!(formatter, "expected one of: {:?}", &FIELDS)
2093 }
2094
2095 #[allow(unused_variables)]
2096 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2097 where
2098 E: serde::de::Error,
2099 {
2100 match value {
2101 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
2102 "maxLevel" | "max_level" => Ok(GeneratedField::MaxLevel),
2103 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
2104 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
2105 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
2106 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
2107 "compactionMode" | "compaction_mode" => Ok(GeneratedField::CompactionMode),
2108 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
2109 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
2110 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
2111 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
2112 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
2113 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
2114 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
2115 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
2116 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
2117 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
2118 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
2119 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
2120 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
2121 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
2122 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
2123 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
2124 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
2125 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
2126 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
2127 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
2128 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
2129 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
2130 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
2131 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2132 }
2133 }
2134 }
2135 deserializer.deserialize_identifier(GeneratedVisitor)
2136 }
2137 }
2138 struct GeneratedVisitor;
2139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2140 type Value = CompactionConfig;
2141
2142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2143 formatter.write_str("struct hummock.CompactionConfig")
2144 }
2145
2146 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionConfig, V::Error>
2147 where
2148 V: serde::de::MapAccess<'de>,
2149 {
2150 let mut max_bytes_for_level_base__ = None;
2151 let mut max_level__ = None;
2152 let mut max_bytes_for_level_multiplier__ = None;
2153 let mut max_compaction_bytes__ = None;
2154 let mut sub_level_max_compaction_bytes__ = None;
2155 let mut level0_tier_compact_file_number__ = None;
2156 let mut compaction_mode__ = None;
2157 let mut compression_algorithm__ = None;
2158 let mut target_file_size_base__ = None;
2159 let mut compaction_filter_mask__ = None;
2160 let mut max_sub_compaction__ = None;
2161 let mut max_space_reclaim_bytes__ = None;
2162 let mut split_by_state_table__ = None;
2163 let mut split_weight_by_vnode__ = None;
2164 let mut level0_stop_write_threshold_sub_level_number__ = None;
2165 let mut level0_max_compact_file_number__ = None;
2166 let mut level0_sub_level_compact_level_count__ = None;
2167 let mut level0_overlapping_sub_level_compact_level_count__ = None;
2168 let mut tombstone_reclaim_ratio__ = None;
2169 let mut enable_emergency_picker__ = None;
2170 let mut max_l0_compact_level_count__ = None;
2171 let mut sst_allowed_trivial_move_min_size__ = None;
2172 let mut disable_auto_group_scheduling__ = None;
2173 let mut max_overlapping_level_size__ = None;
2174 let mut emergency_level0_sst_file_count__ = None;
2175 let mut emergency_level0_sub_level_partition__ = None;
2176 let mut level0_stop_write_threshold_max_sst_count__ = None;
2177 let mut level0_stop_write_threshold_max_size__ = None;
2178 let mut sst_allowed_trivial_move_max_count__ = None;
2179 let mut enable_optimize_l0_interval_selection__ = None;
2180 while let Some(k) = map_.next_key()? {
2181 match k {
2182 GeneratedField::MaxBytesForLevelBase => {
2183 if max_bytes_for_level_base__.is_some() {
2184 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
2185 }
2186 max_bytes_for_level_base__ =
2187 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2188 ;
2189 }
2190 GeneratedField::MaxLevel => {
2191 if max_level__.is_some() {
2192 return Err(serde::de::Error::duplicate_field("maxLevel"));
2193 }
2194 max_level__ =
2195 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2196 ;
2197 }
2198 GeneratedField::MaxBytesForLevelMultiplier => {
2199 if max_bytes_for_level_multiplier__.is_some() {
2200 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
2201 }
2202 max_bytes_for_level_multiplier__ =
2203 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2204 ;
2205 }
2206 GeneratedField::MaxCompactionBytes => {
2207 if max_compaction_bytes__.is_some() {
2208 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
2209 }
2210 max_compaction_bytes__ =
2211 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2212 ;
2213 }
2214 GeneratedField::SubLevelMaxCompactionBytes => {
2215 if sub_level_max_compaction_bytes__.is_some() {
2216 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
2217 }
2218 sub_level_max_compaction_bytes__ =
2219 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2220 ;
2221 }
2222 GeneratedField::Level0TierCompactFileNumber => {
2223 if level0_tier_compact_file_number__.is_some() {
2224 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
2225 }
2226 level0_tier_compact_file_number__ =
2227 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2228 ;
2229 }
2230 GeneratedField::CompactionMode => {
2231 if compaction_mode__.is_some() {
2232 return Err(serde::de::Error::duplicate_field("compactionMode"));
2233 }
2234 compaction_mode__ = Some(map_.next_value::<compaction_config::CompactionMode>()? as i32);
2235 }
2236 GeneratedField::CompressionAlgorithm => {
2237 if compression_algorithm__.is_some() {
2238 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
2239 }
2240 compression_algorithm__ = Some(map_.next_value()?);
2241 }
2242 GeneratedField::TargetFileSizeBase => {
2243 if target_file_size_base__.is_some() {
2244 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
2245 }
2246 target_file_size_base__ =
2247 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2248 ;
2249 }
2250 GeneratedField::CompactionFilterMask => {
2251 if compaction_filter_mask__.is_some() {
2252 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
2253 }
2254 compaction_filter_mask__ =
2255 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2256 ;
2257 }
2258 GeneratedField::MaxSubCompaction => {
2259 if max_sub_compaction__.is_some() {
2260 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
2261 }
2262 max_sub_compaction__ =
2263 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2264 ;
2265 }
2266 GeneratedField::MaxSpaceReclaimBytes => {
2267 if max_space_reclaim_bytes__.is_some() {
2268 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
2269 }
2270 max_space_reclaim_bytes__ =
2271 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2272 ;
2273 }
2274 GeneratedField::SplitByStateTable => {
2275 if split_by_state_table__.is_some() {
2276 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
2277 }
2278 split_by_state_table__ = Some(map_.next_value()?);
2279 }
2280 GeneratedField::SplitWeightByVnode => {
2281 if split_weight_by_vnode__.is_some() {
2282 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
2283 }
2284 split_weight_by_vnode__ =
2285 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2286 ;
2287 }
2288 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
2289 if level0_stop_write_threshold_sub_level_number__.is_some() {
2290 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
2291 }
2292 level0_stop_write_threshold_sub_level_number__ =
2293 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2294 ;
2295 }
2296 GeneratedField::Level0MaxCompactFileNumber => {
2297 if level0_max_compact_file_number__.is_some() {
2298 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
2299 }
2300 level0_max_compact_file_number__ =
2301 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2302 ;
2303 }
2304 GeneratedField::Level0SubLevelCompactLevelCount => {
2305 if level0_sub_level_compact_level_count__.is_some() {
2306 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
2307 }
2308 level0_sub_level_compact_level_count__ =
2309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2310 ;
2311 }
2312 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
2313 if level0_overlapping_sub_level_compact_level_count__.is_some() {
2314 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
2315 }
2316 level0_overlapping_sub_level_compact_level_count__ =
2317 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2318 ;
2319 }
2320 GeneratedField::TombstoneReclaimRatio => {
2321 if tombstone_reclaim_ratio__.is_some() {
2322 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
2323 }
2324 tombstone_reclaim_ratio__ =
2325 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2326 ;
2327 }
2328 GeneratedField::EnableEmergencyPicker => {
2329 if enable_emergency_picker__.is_some() {
2330 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
2331 }
2332 enable_emergency_picker__ = Some(map_.next_value()?);
2333 }
2334 GeneratedField::MaxL0CompactLevelCount => {
2335 if max_l0_compact_level_count__.is_some() {
2336 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
2337 }
2338 max_l0_compact_level_count__ =
2339 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2340 ;
2341 }
2342 GeneratedField::SstAllowedTrivialMoveMinSize => {
2343 if sst_allowed_trivial_move_min_size__.is_some() {
2344 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
2345 }
2346 sst_allowed_trivial_move_min_size__ =
2347 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2348 ;
2349 }
2350 GeneratedField::DisableAutoGroupScheduling => {
2351 if disable_auto_group_scheduling__.is_some() {
2352 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
2353 }
2354 disable_auto_group_scheduling__ = map_.next_value()?;
2355 }
2356 GeneratedField::MaxOverlappingLevelSize => {
2357 if max_overlapping_level_size__.is_some() {
2358 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
2359 }
2360 max_overlapping_level_size__ =
2361 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2362 ;
2363 }
2364 GeneratedField::EmergencyLevel0SstFileCount => {
2365 if emergency_level0_sst_file_count__.is_some() {
2366 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
2367 }
2368 emergency_level0_sst_file_count__ =
2369 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2370 ;
2371 }
2372 GeneratedField::EmergencyLevel0SubLevelPartition => {
2373 if emergency_level0_sub_level_partition__.is_some() {
2374 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
2375 }
2376 emergency_level0_sub_level_partition__ =
2377 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2378 ;
2379 }
2380 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
2381 if level0_stop_write_threshold_max_sst_count__.is_some() {
2382 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
2383 }
2384 level0_stop_write_threshold_max_sst_count__ =
2385 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2386 ;
2387 }
2388 GeneratedField::Level0StopWriteThresholdMaxSize => {
2389 if level0_stop_write_threshold_max_size__.is_some() {
2390 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
2391 }
2392 level0_stop_write_threshold_max_size__ =
2393 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2394 ;
2395 }
2396 GeneratedField::SstAllowedTrivialMoveMaxCount => {
2397 if sst_allowed_trivial_move_max_count__.is_some() {
2398 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
2399 }
2400 sst_allowed_trivial_move_max_count__ =
2401 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2402 ;
2403 }
2404 GeneratedField::EnableOptimizeL0IntervalSelection => {
2405 if enable_optimize_l0_interval_selection__.is_some() {
2406 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
2407 }
2408 enable_optimize_l0_interval_selection__ = map_.next_value()?;
2409 }
2410 }
2411 }
2412 Ok(CompactionConfig {
2413 max_bytes_for_level_base: max_bytes_for_level_base__.unwrap_or_default(),
2414 max_level: max_level__.unwrap_or_default(),
2415 max_bytes_for_level_multiplier: max_bytes_for_level_multiplier__.unwrap_or_default(),
2416 max_compaction_bytes: max_compaction_bytes__.unwrap_or_default(),
2417 sub_level_max_compaction_bytes: sub_level_max_compaction_bytes__.unwrap_or_default(),
2418 level0_tier_compact_file_number: level0_tier_compact_file_number__.unwrap_or_default(),
2419 compaction_mode: compaction_mode__.unwrap_or_default(),
2420 compression_algorithm: compression_algorithm__.unwrap_or_default(),
2421 target_file_size_base: target_file_size_base__.unwrap_or_default(),
2422 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
2423 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
2424 max_space_reclaim_bytes: max_space_reclaim_bytes__.unwrap_or_default(),
2425 split_by_state_table: split_by_state_table__.unwrap_or_default(),
2426 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
2427 level0_stop_write_threshold_sub_level_number: level0_stop_write_threshold_sub_level_number__.unwrap_or_default(),
2428 level0_max_compact_file_number: level0_max_compact_file_number__.unwrap_or_default(),
2429 level0_sub_level_compact_level_count: level0_sub_level_compact_level_count__.unwrap_or_default(),
2430 level0_overlapping_sub_level_compact_level_count: level0_overlapping_sub_level_compact_level_count__.unwrap_or_default(),
2431 tombstone_reclaim_ratio: tombstone_reclaim_ratio__.unwrap_or_default(),
2432 enable_emergency_picker: enable_emergency_picker__.unwrap_or_default(),
2433 max_l0_compact_level_count: max_l0_compact_level_count__,
2434 sst_allowed_trivial_move_min_size: sst_allowed_trivial_move_min_size__,
2435 disable_auto_group_scheduling: disable_auto_group_scheduling__,
2436 max_overlapping_level_size: max_overlapping_level_size__,
2437 emergency_level0_sst_file_count: emergency_level0_sst_file_count__,
2438 emergency_level0_sub_level_partition: emergency_level0_sub_level_partition__,
2439 level0_stop_write_threshold_max_sst_count: level0_stop_write_threshold_max_sst_count__,
2440 level0_stop_write_threshold_max_size: level0_stop_write_threshold_max_size__,
2441 sst_allowed_trivial_move_max_count: sst_allowed_trivial_move_max_count__,
2442 enable_optimize_l0_interval_selection: enable_optimize_l0_interval_selection__,
2443 })
2444 }
2445 }
2446 deserializer.deserialize_struct("hummock.CompactionConfig", FIELDS, GeneratedVisitor)
2447 }
2448}
2449impl serde::Serialize for compaction_config::CompactionMode {
2450 #[allow(deprecated)]
2451 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2452 where
2453 S: serde::Serializer,
2454 {
2455 let variant = match self {
2456 Self::Unspecified => "UNSPECIFIED",
2457 Self::Range => "RANGE",
2458 };
2459 serializer.serialize_str(variant)
2460 }
2461}
2462impl<'de> serde::Deserialize<'de> for compaction_config::CompactionMode {
2463 #[allow(deprecated)]
2464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2465 where
2466 D: serde::Deserializer<'de>,
2467 {
2468 const FIELDS: &[&str] = &[
2469 "UNSPECIFIED",
2470 "RANGE",
2471 ];
2472
2473 struct GeneratedVisitor;
2474
2475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2476 type Value = compaction_config::CompactionMode;
2477
2478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2479 write!(formatter, "expected one of: {:?}", &FIELDS)
2480 }
2481
2482 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2483 where
2484 E: serde::de::Error,
2485 {
2486 i32::try_from(v)
2487 .ok()
2488 .and_then(|x| x.try_into().ok())
2489 .ok_or_else(|| {
2490 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2491 })
2492 }
2493
2494 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2495 where
2496 E: serde::de::Error,
2497 {
2498 i32::try_from(v)
2499 .ok()
2500 .and_then(|x| x.try_into().ok())
2501 .ok_or_else(|| {
2502 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2503 })
2504 }
2505
2506 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2507 where
2508 E: serde::de::Error,
2509 {
2510 match value {
2511 "UNSPECIFIED" => Ok(compaction_config::CompactionMode::Unspecified),
2512 "RANGE" => Ok(compaction_config::CompactionMode::Range),
2513 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2514 }
2515 }
2516 }
2517 deserializer.deserialize_any(GeneratedVisitor)
2518 }
2519}
2520impl serde::Serialize for CompactionGroup {
2521 #[allow(deprecated)]
2522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2523 where
2524 S: serde::Serializer,
2525 {
2526 use serde::ser::SerializeStruct;
2527 let mut len = 0;
2528 if self.id != 0 {
2529 len += 1;
2530 }
2531 if self.compaction_config.is_some() {
2532 len += 1;
2533 }
2534 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroup", len)?;
2535 if self.id != 0 {
2536 #[allow(clippy::needless_borrow)]
2537 #[allow(clippy::needless_borrows_for_generic_args)]
2538 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2539 }
2540 if let Some(v) = self.compaction_config.as_ref() {
2541 struct_ser.serialize_field("compactionConfig", v)?;
2542 }
2543 struct_ser.end()
2544 }
2545}
2546impl<'de> serde::Deserialize<'de> for CompactionGroup {
2547 #[allow(deprecated)]
2548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2549 where
2550 D: serde::Deserializer<'de>,
2551 {
2552 const FIELDS: &[&str] = &[
2553 "id",
2554 "compaction_config",
2555 "compactionConfig",
2556 ];
2557
2558 #[allow(clippy::enum_variant_names)]
2559 enum GeneratedField {
2560 Id,
2561 CompactionConfig,
2562 }
2563 impl<'de> serde::Deserialize<'de> for GeneratedField {
2564 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2565 where
2566 D: serde::Deserializer<'de>,
2567 {
2568 struct GeneratedVisitor;
2569
2570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2571 type Value = GeneratedField;
2572
2573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2574 write!(formatter, "expected one of: {:?}", &FIELDS)
2575 }
2576
2577 #[allow(unused_variables)]
2578 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2579 where
2580 E: serde::de::Error,
2581 {
2582 match value {
2583 "id" => Ok(GeneratedField::Id),
2584 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2585 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2586 }
2587 }
2588 }
2589 deserializer.deserialize_identifier(GeneratedVisitor)
2590 }
2591 }
2592 struct GeneratedVisitor;
2593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2594 type Value = CompactionGroup;
2595
2596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2597 formatter.write_str("struct hummock.CompactionGroup")
2598 }
2599
2600 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroup, V::Error>
2601 where
2602 V: serde::de::MapAccess<'de>,
2603 {
2604 let mut id__ = None;
2605 let mut compaction_config__ = None;
2606 while let Some(k) = map_.next_key()? {
2607 match k {
2608 GeneratedField::Id => {
2609 if id__.is_some() {
2610 return Err(serde::de::Error::duplicate_field("id"));
2611 }
2612 id__ =
2613 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2614 ;
2615 }
2616 GeneratedField::CompactionConfig => {
2617 if compaction_config__.is_some() {
2618 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2619 }
2620 compaction_config__ = map_.next_value()?;
2621 }
2622 }
2623 }
2624 Ok(CompactionGroup {
2625 id: id__.unwrap_or_default(),
2626 compaction_config: compaction_config__,
2627 })
2628 }
2629 }
2630 deserializer.deserialize_struct("hummock.CompactionGroup", FIELDS, GeneratedVisitor)
2631 }
2632}
2633impl serde::Serialize for CompactionGroupInfo {
2634 #[allow(deprecated)]
2635 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2636 where
2637 S: serde::Serializer,
2638 {
2639 use serde::ser::SerializeStruct;
2640 let mut len = 0;
2641 if self.id != 0 {
2642 len += 1;
2643 }
2644 if self.parent_id != 0 {
2645 len += 1;
2646 }
2647 if !self.member_table_ids.is_empty() {
2648 len += 1;
2649 }
2650 if self.compaction_config.is_some() {
2651 len += 1;
2652 }
2653 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroupInfo", len)?;
2654 if self.id != 0 {
2655 #[allow(clippy::needless_borrow)]
2656 #[allow(clippy::needless_borrows_for_generic_args)]
2657 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2658 }
2659 if self.parent_id != 0 {
2660 #[allow(clippy::needless_borrow)]
2661 #[allow(clippy::needless_borrows_for_generic_args)]
2662 struct_ser.serialize_field("parentId", ToString::to_string(&self.parent_id).as_str())?;
2663 }
2664 if !self.member_table_ids.is_empty() {
2665 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
2666 }
2667 if let Some(v) = self.compaction_config.as_ref() {
2668 struct_ser.serialize_field("compactionConfig", v)?;
2669 }
2670 struct_ser.end()
2671 }
2672}
2673impl<'de> serde::Deserialize<'de> for CompactionGroupInfo {
2674 #[allow(deprecated)]
2675 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2676 where
2677 D: serde::Deserializer<'de>,
2678 {
2679 const FIELDS: &[&str] = &[
2680 "id",
2681 "parent_id",
2682 "parentId",
2683 "member_table_ids",
2684 "memberTableIds",
2685 "compaction_config",
2686 "compactionConfig",
2687 ];
2688
2689 #[allow(clippy::enum_variant_names)]
2690 enum GeneratedField {
2691 Id,
2692 ParentId,
2693 MemberTableIds,
2694 CompactionConfig,
2695 }
2696 impl<'de> serde::Deserialize<'de> for GeneratedField {
2697 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2698 where
2699 D: serde::Deserializer<'de>,
2700 {
2701 struct GeneratedVisitor;
2702
2703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2704 type Value = GeneratedField;
2705
2706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2707 write!(formatter, "expected one of: {:?}", &FIELDS)
2708 }
2709
2710 #[allow(unused_variables)]
2711 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2712 where
2713 E: serde::de::Error,
2714 {
2715 match value {
2716 "id" => Ok(GeneratedField::Id),
2717 "parentId" | "parent_id" => Ok(GeneratedField::ParentId),
2718 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
2719 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2720 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2721 }
2722 }
2723 }
2724 deserializer.deserialize_identifier(GeneratedVisitor)
2725 }
2726 }
2727 struct GeneratedVisitor;
2728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2729 type Value = CompactionGroupInfo;
2730
2731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2732 formatter.write_str("struct hummock.CompactionGroupInfo")
2733 }
2734
2735 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroupInfo, V::Error>
2736 where
2737 V: serde::de::MapAccess<'de>,
2738 {
2739 let mut id__ = None;
2740 let mut parent_id__ = None;
2741 let mut member_table_ids__ = None;
2742 let mut compaction_config__ = None;
2743 while let Some(k) = map_.next_key()? {
2744 match k {
2745 GeneratedField::Id => {
2746 if id__.is_some() {
2747 return Err(serde::de::Error::duplicate_field("id"));
2748 }
2749 id__ =
2750 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2751 ;
2752 }
2753 GeneratedField::ParentId => {
2754 if parent_id__.is_some() {
2755 return Err(serde::de::Error::duplicate_field("parentId"));
2756 }
2757 parent_id__ =
2758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2759 ;
2760 }
2761 GeneratedField::MemberTableIds => {
2762 if member_table_ids__.is_some() {
2763 return Err(serde::de::Error::duplicate_field("memberTableIds"));
2764 }
2765 member_table_ids__ =
2766 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2767 .into_iter().map(|x| x.0).collect())
2768 ;
2769 }
2770 GeneratedField::CompactionConfig => {
2771 if compaction_config__.is_some() {
2772 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2773 }
2774 compaction_config__ = map_.next_value()?;
2775 }
2776 }
2777 }
2778 Ok(CompactionGroupInfo {
2779 id: id__.unwrap_or_default(),
2780 parent_id: parent_id__.unwrap_or_default(),
2781 member_table_ids: member_table_ids__.unwrap_or_default(),
2782 compaction_config: compaction_config__,
2783 })
2784 }
2785 }
2786 deserializer.deserialize_struct("hummock.CompactionGroupInfo", FIELDS, GeneratedVisitor)
2787 }
2788}
2789impl serde::Serialize for CompatibilityVersion {
2790 #[allow(deprecated)]
2791 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2792 where
2793 S: serde::Serializer,
2794 {
2795 let variant = match self {
2796 Self::VersionUnspecified => "VERSION_UNSPECIFIED",
2797 Self::NoTrivialSplit => "NO_TRIVIAL_SPLIT",
2798 Self::NoMemberTableIds => "NO_MEMBER_TABLE_IDS",
2799 Self::SplitGroupByTableId => "SPLIT_GROUP_BY_TABLE_ID",
2800 };
2801 serializer.serialize_str(variant)
2802 }
2803}
2804impl<'de> serde::Deserialize<'de> for CompatibilityVersion {
2805 #[allow(deprecated)]
2806 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2807 where
2808 D: serde::Deserializer<'de>,
2809 {
2810 const FIELDS: &[&str] = &[
2811 "VERSION_UNSPECIFIED",
2812 "NO_TRIVIAL_SPLIT",
2813 "NO_MEMBER_TABLE_IDS",
2814 "SPLIT_GROUP_BY_TABLE_ID",
2815 ];
2816
2817 struct GeneratedVisitor;
2818
2819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2820 type Value = CompatibilityVersion;
2821
2822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2823 write!(formatter, "expected one of: {:?}", &FIELDS)
2824 }
2825
2826 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2827 where
2828 E: serde::de::Error,
2829 {
2830 i32::try_from(v)
2831 .ok()
2832 .and_then(|x| x.try_into().ok())
2833 .ok_or_else(|| {
2834 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2835 })
2836 }
2837
2838 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2839 where
2840 E: serde::de::Error,
2841 {
2842 i32::try_from(v)
2843 .ok()
2844 .and_then(|x| x.try_into().ok())
2845 .ok_or_else(|| {
2846 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2847 })
2848 }
2849
2850 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2851 where
2852 E: serde::de::Error,
2853 {
2854 match value {
2855 "VERSION_UNSPECIFIED" => Ok(CompatibilityVersion::VersionUnspecified),
2856 "NO_TRIVIAL_SPLIT" => Ok(CompatibilityVersion::NoTrivialSplit),
2857 "NO_MEMBER_TABLE_IDS" => Ok(CompatibilityVersion::NoMemberTableIds),
2858 "SPLIT_GROUP_BY_TABLE_ID" => Ok(CompatibilityVersion::SplitGroupByTableId),
2859 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2860 }
2861 }
2862 }
2863 deserializer.deserialize_any(GeneratedVisitor)
2864 }
2865}
2866impl serde::Serialize for DisableCommitEpochRequest {
2867 #[allow(deprecated)]
2868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2869 where
2870 S: serde::Serializer,
2871 {
2872 use serde::ser::SerializeStruct;
2873 let len = 0;
2874 let struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochRequest", len)?;
2875 struct_ser.end()
2876 }
2877}
2878impl<'de> serde::Deserialize<'de> for DisableCommitEpochRequest {
2879 #[allow(deprecated)]
2880 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2881 where
2882 D: serde::Deserializer<'de>,
2883 {
2884 const FIELDS: &[&str] = &[
2885 ];
2886
2887 #[allow(clippy::enum_variant_names)]
2888 enum GeneratedField {
2889 }
2890 impl<'de> serde::Deserialize<'de> for GeneratedField {
2891 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2892 where
2893 D: serde::Deserializer<'de>,
2894 {
2895 struct GeneratedVisitor;
2896
2897 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2898 type Value = GeneratedField;
2899
2900 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2901 write!(formatter, "expected one of: {:?}", &FIELDS)
2902 }
2903
2904 #[allow(unused_variables)]
2905 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2906 where
2907 E: serde::de::Error,
2908 {
2909 Err(serde::de::Error::unknown_field(value, FIELDS))
2910 }
2911 }
2912 deserializer.deserialize_identifier(GeneratedVisitor)
2913 }
2914 }
2915 struct GeneratedVisitor;
2916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2917 type Value = DisableCommitEpochRequest;
2918
2919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2920 formatter.write_str("struct hummock.DisableCommitEpochRequest")
2921 }
2922
2923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochRequest, V::Error>
2924 where
2925 V: serde::de::MapAccess<'de>,
2926 {
2927 while map_.next_key::<GeneratedField>()?.is_some() {
2928 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2929 }
2930 Ok(DisableCommitEpochRequest {
2931 })
2932 }
2933 }
2934 deserializer.deserialize_struct("hummock.DisableCommitEpochRequest", FIELDS, GeneratedVisitor)
2935 }
2936}
2937impl serde::Serialize for DisableCommitEpochResponse {
2938 #[allow(deprecated)]
2939 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2940 where
2941 S: serde::Serializer,
2942 {
2943 use serde::ser::SerializeStruct;
2944 let mut len = 0;
2945 if self.current_version.is_some() {
2946 len += 1;
2947 }
2948 let mut struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochResponse", len)?;
2949 if let Some(v) = self.current_version.as_ref() {
2950 struct_ser.serialize_field("currentVersion", v)?;
2951 }
2952 struct_ser.end()
2953 }
2954}
2955impl<'de> serde::Deserialize<'de> for DisableCommitEpochResponse {
2956 #[allow(deprecated)]
2957 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2958 where
2959 D: serde::Deserializer<'de>,
2960 {
2961 const FIELDS: &[&str] = &[
2962 "current_version",
2963 "currentVersion",
2964 ];
2965
2966 #[allow(clippy::enum_variant_names)]
2967 enum GeneratedField {
2968 CurrentVersion,
2969 }
2970 impl<'de> serde::Deserialize<'de> for GeneratedField {
2971 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2972 where
2973 D: serde::Deserializer<'de>,
2974 {
2975 struct GeneratedVisitor;
2976
2977 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2978 type Value = GeneratedField;
2979
2980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2981 write!(formatter, "expected one of: {:?}", &FIELDS)
2982 }
2983
2984 #[allow(unused_variables)]
2985 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2986 where
2987 E: serde::de::Error,
2988 {
2989 match value {
2990 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
2991 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2992 }
2993 }
2994 }
2995 deserializer.deserialize_identifier(GeneratedVisitor)
2996 }
2997 }
2998 struct GeneratedVisitor;
2999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3000 type Value = DisableCommitEpochResponse;
3001
3002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3003 formatter.write_str("struct hummock.DisableCommitEpochResponse")
3004 }
3005
3006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochResponse, V::Error>
3007 where
3008 V: serde::de::MapAccess<'de>,
3009 {
3010 let mut current_version__ = None;
3011 while let Some(k) = map_.next_key()? {
3012 match k {
3013 GeneratedField::CurrentVersion => {
3014 if current_version__.is_some() {
3015 return Err(serde::de::Error::duplicate_field("currentVersion"));
3016 }
3017 current_version__ = map_.next_value()?;
3018 }
3019 }
3020 }
3021 Ok(DisableCommitEpochResponse {
3022 current_version: current_version__,
3023 })
3024 }
3025 }
3026 deserializer.deserialize_struct("hummock.DisableCommitEpochResponse", FIELDS, GeneratedVisitor)
3027 }
3028}
3029impl serde::Serialize for EpochNewChangeLog {
3030 #[allow(deprecated)]
3031 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3032 where
3033 S: serde::Serializer,
3034 {
3035 use serde::ser::SerializeStruct;
3036 let mut len = 0;
3037 if !self.old_value.is_empty() {
3038 len += 1;
3039 }
3040 if !self.new_value.is_empty() {
3041 len += 1;
3042 }
3043 if !self.epochs.is_empty() {
3044 len += 1;
3045 }
3046 let mut struct_ser = serializer.serialize_struct("hummock.EpochNewChangeLog", len)?;
3047 if !self.old_value.is_empty() {
3048 struct_ser.serialize_field("oldValue", &self.old_value)?;
3049 }
3050 if !self.new_value.is_empty() {
3051 struct_ser.serialize_field("newValue", &self.new_value)?;
3052 }
3053 if !self.epochs.is_empty() {
3054 struct_ser.serialize_field("epochs", &self.epochs.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3055 }
3056 struct_ser.end()
3057 }
3058}
3059impl<'de> serde::Deserialize<'de> for EpochNewChangeLog {
3060 #[allow(deprecated)]
3061 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3062 where
3063 D: serde::Deserializer<'de>,
3064 {
3065 const FIELDS: &[&str] = &[
3066 "old_value",
3067 "oldValue",
3068 "new_value",
3069 "newValue",
3070 "epochs",
3071 ];
3072
3073 #[allow(clippy::enum_variant_names)]
3074 enum GeneratedField {
3075 OldValue,
3076 NewValue,
3077 Epochs,
3078 }
3079 impl<'de> serde::Deserialize<'de> for GeneratedField {
3080 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3081 where
3082 D: serde::Deserializer<'de>,
3083 {
3084 struct GeneratedVisitor;
3085
3086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3087 type Value = GeneratedField;
3088
3089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3090 write!(formatter, "expected one of: {:?}", &FIELDS)
3091 }
3092
3093 #[allow(unused_variables)]
3094 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3095 where
3096 E: serde::de::Error,
3097 {
3098 match value {
3099 "oldValue" | "old_value" => Ok(GeneratedField::OldValue),
3100 "newValue" | "new_value" => Ok(GeneratedField::NewValue),
3101 "epochs" => Ok(GeneratedField::Epochs),
3102 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3103 }
3104 }
3105 }
3106 deserializer.deserialize_identifier(GeneratedVisitor)
3107 }
3108 }
3109 struct GeneratedVisitor;
3110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3111 type Value = EpochNewChangeLog;
3112
3113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3114 formatter.write_str("struct hummock.EpochNewChangeLog")
3115 }
3116
3117 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EpochNewChangeLog, V::Error>
3118 where
3119 V: serde::de::MapAccess<'de>,
3120 {
3121 let mut old_value__ = None;
3122 let mut new_value__ = None;
3123 let mut epochs__ = None;
3124 while let Some(k) = map_.next_key()? {
3125 match k {
3126 GeneratedField::OldValue => {
3127 if old_value__.is_some() {
3128 return Err(serde::de::Error::duplicate_field("oldValue"));
3129 }
3130 old_value__ = Some(map_.next_value()?);
3131 }
3132 GeneratedField::NewValue => {
3133 if new_value__.is_some() {
3134 return Err(serde::de::Error::duplicate_field("newValue"));
3135 }
3136 new_value__ = Some(map_.next_value()?);
3137 }
3138 GeneratedField::Epochs => {
3139 if epochs__.is_some() {
3140 return Err(serde::de::Error::duplicate_field("epochs"));
3141 }
3142 epochs__ =
3143 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3144 .into_iter().map(|x| x.0).collect())
3145 ;
3146 }
3147 }
3148 }
3149 Ok(EpochNewChangeLog {
3150 old_value: old_value__.unwrap_or_default(),
3151 new_value: new_value__.unwrap_or_default(),
3152 epochs: epochs__.unwrap_or_default(),
3153 })
3154 }
3155 }
3156 deserializer.deserialize_struct("hummock.EpochNewChangeLog", FIELDS, GeneratedVisitor)
3157 }
3158}
3159impl serde::Serialize for FullScanTask {
3160 #[allow(deprecated)]
3161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3162 where
3163 S: serde::Serializer,
3164 {
3165 use serde::ser::SerializeStruct;
3166 let mut len = 0;
3167 if self.sst_retention_watermark != 0 {
3168 len += 1;
3169 }
3170 if self.prefix.is_some() {
3171 len += 1;
3172 }
3173 if self.start_after.is_some() {
3174 len += 1;
3175 }
3176 if self.limit.is_some() {
3177 len += 1;
3178 }
3179 let mut struct_ser = serializer.serialize_struct("hummock.FullScanTask", len)?;
3180 if self.sst_retention_watermark != 0 {
3181 #[allow(clippy::needless_borrow)]
3182 #[allow(clippy::needless_borrows_for_generic_args)]
3183 struct_ser.serialize_field("sstRetentionWatermark", ToString::to_string(&self.sst_retention_watermark).as_str())?;
3184 }
3185 if let Some(v) = self.prefix.as_ref() {
3186 struct_ser.serialize_field("prefix", v)?;
3187 }
3188 if let Some(v) = self.start_after.as_ref() {
3189 struct_ser.serialize_field("startAfter", v)?;
3190 }
3191 if let Some(v) = self.limit.as_ref() {
3192 #[allow(clippy::needless_borrow)]
3193 #[allow(clippy::needless_borrows_for_generic_args)]
3194 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
3195 }
3196 struct_ser.end()
3197 }
3198}
3199impl<'de> serde::Deserialize<'de> for FullScanTask {
3200 #[allow(deprecated)]
3201 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3202 where
3203 D: serde::Deserializer<'de>,
3204 {
3205 const FIELDS: &[&str] = &[
3206 "sst_retention_watermark",
3207 "sstRetentionWatermark",
3208 "prefix",
3209 "start_after",
3210 "startAfter",
3211 "limit",
3212 ];
3213
3214 #[allow(clippy::enum_variant_names)]
3215 enum GeneratedField {
3216 SstRetentionWatermark,
3217 Prefix,
3218 StartAfter,
3219 Limit,
3220 }
3221 impl<'de> serde::Deserialize<'de> for GeneratedField {
3222 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3223 where
3224 D: serde::Deserializer<'de>,
3225 {
3226 struct GeneratedVisitor;
3227
3228 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3229 type Value = GeneratedField;
3230
3231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3232 write!(formatter, "expected one of: {:?}", &FIELDS)
3233 }
3234
3235 #[allow(unused_variables)]
3236 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3237 where
3238 E: serde::de::Error,
3239 {
3240 match value {
3241 "sstRetentionWatermark" | "sst_retention_watermark" => Ok(GeneratedField::SstRetentionWatermark),
3242 "prefix" => Ok(GeneratedField::Prefix),
3243 "startAfter" | "start_after" => Ok(GeneratedField::StartAfter),
3244 "limit" => Ok(GeneratedField::Limit),
3245 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3246 }
3247 }
3248 }
3249 deserializer.deserialize_identifier(GeneratedVisitor)
3250 }
3251 }
3252 struct GeneratedVisitor;
3253 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3254 type Value = FullScanTask;
3255
3256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3257 formatter.write_str("struct hummock.FullScanTask")
3258 }
3259
3260 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FullScanTask, V::Error>
3261 where
3262 V: serde::de::MapAccess<'de>,
3263 {
3264 let mut sst_retention_watermark__ = None;
3265 let mut prefix__ = None;
3266 let mut start_after__ = None;
3267 let mut limit__ = None;
3268 while let Some(k) = map_.next_key()? {
3269 match k {
3270 GeneratedField::SstRetentionWatermark => {
3271 if sst_retention_watermark__.is_some() {
3272 return Err(serde::de::Error::duplicate_field("sstRetentionWatermark"));
3273 }
3274 sst_retention_watermark__ =
3275 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3276 ;
3277 }
3278 GeneratedField::Prefix => {
3279 if prefix__.is_some() {
3280 return Err(serde::de::Error::duplicate_field("prefix"));
3281 }
3282 prefix__ = map_.next_value()?;
3283 }
3284 GeneratedField::StartAfter => {
3285 if start_after__.is_some() {
3286 return Err(serde::de::Error::duplicate_field("startAfter"));
3287 }
3288 start_after__ = map_.next_value()?;
3289 }
3290 GeneratedField::Limit => {
3291 if limit__.is_some() {
3292 return Err(serde::de::Error::duplicate_field("limit"));
3293 }
3294 limit__ =
3295 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3296 ;
3297 }
3298 }
3299 }
3300 Ok(FullScanTask {
3301 sst_retention_watermark: sst_retention_watermark__.unwrap_or_default(),
3302 prefix: prefix__,
3303 start_after: start_after__,
3304 limit: limit__,
3305 })
3306 }
3307 }
3308 deserializer.deserialize_struct("hummock.FullScanTask", FIELDS, GeneratedVisitor)
3309 }
3310}
3311impl serde::Serialize for GetAssignedCompactTaskNumRequest {
3312 #[allow(deprecated)]
3313 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3314 where
3315 S: serde::Serializer,
3316 {
3317 use serde::ser::SerializeStruct;
3318 let len = 0;
3319 let struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumRequest", len)?;
3320 struct_ser.end()
3321 }
3322}
3323impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumRequest {
3324 #[allow(deprecated)]
3325 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3326 where
3327 D: serde::Deserializer<'de>,
3328 {
3329 const FIELDS: &[&str] = &[
3330 ];
3331
3332 #[allow(clippy::enum_variant_names)]
3333 enum GeneratedField {
3334 }
3335 impl<'de> serde::Deserialize<'de> for GeneratedField {
3336 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3337 where
3338 D: serde::Deserializer<'de>,
3339 {
3340 struct GeneratedVisitor;
3341
3342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3343 type Value = GeneratedField;
3344
3345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3346 write!(formatter, "expected one of: {:?}", &FIELDS)
3347 }
3348
3349 #[allow(unused_variables)]
3350 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3351 where
3352 E: serde::de::Error,
3353 {
3354 Err(serde::de::Error::unknown_field(value, FIELDS))
3355 }
3356 }
3357 deserializer.deserialize_identifier(GeneratedVisitor)
3358 }
3359 }
3360 struct GeneratedVisitor;
3361 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3362 type Value = GetAssignedCompactTaskNumRequest;
3363
3364 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3365 formatter.write_str("struct hummock.GetAssignedCompactTaskNumRequest")
3366 }
3367
3368 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumRequest, V::Error>
3369 where
3370 V: serde::de::MapAccess<'de>,
3371 {
3372 while map_.next_key::<GeneratedField>()?.is_some() {
3373 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3374 }
3375 Ok(GetAssignedCompactTaskNumRequest {
3376 })
3377 }
3378 }
3379 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumRequest", FIELDS, GeneratedVisitor)
3380 }
3381}
3382impl serde::Serialize for GetAssignedCompactTaskNumResponse {
3383 #[allow(deprecated)]
3384 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3385 where
3386 S: serde::Serializer,
3387 {
3388 use serde::ser::SerializeStruct;
3389 let mut len = 0;
3390 if self.num_tasks != 0 {
3391 len += 1;
3392 }
3393 let mut struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumResponse", len)?;
3394 if self.num_tasks != 0 {
3395 struct_ser.serialize_field("numTasks", &self.num_tasks)?;
3396 }
3397 struct_ser.end()
3398 }
3399}
3400impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumResponse {
3401 #[allow(deprecated)]
3402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3403 where
3404 D: serde::Deserializer<'de>,
3405 {
3406 const FIELDS: &[&str] = &[
3407 "num_tasks",
3408 "numTasks",
3409 ];
3410
3411 #[allow(clippy::enum_variant_names)]
3412 enum GeneratedField {
3413 NumTasks,
3414 }
3415 impl<'de> serde::Deserialize<'de> for GeneratedField {
3416 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3417 where
3418 D: serde::Deserializer<'de>,
3419 {
3420 struct GeneratedVisitor;
3421
3422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3423 type Value = GeneratedField;
3424
3425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3426 write!(formatter, "expected one of: {:?}", &FIELDS)
3427 }
3428
3429 #[allow(unused_variables)]
3430 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3431 where
3432 E: serde::de::Error,
3433 {
3434 match value {
3435 "numTasks" | "num_tasks" => Ok(GeneratedField::NumTasks),
3436 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3437 }
3438 }
3439 }
3440 deserializer.deserialize_identifier(GeneratedVisitor)
3441 }
3442 }
3443 struct GeneratedVisitor;
3444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3445 type Value = GetAssignedCompactTaskNumResponse;
3446
3447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3448 formatter.write_str("struct hummock.GetAssignedCompactTaskNumResponse")
3449 }
3450
3451 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumResponse, V::Error>
3452 where
3453 V: serde::de::MapAccess<'de>,
3454 {
3455 let mut num_tasks__ = None;
3456 while let Some(k) = map_.next_key()? {
3457 match k {
3458 GeneratedField::NumTasks => {
3459 if num_tasks__.is_some() {
3460 return Err(serde::de::Error::duplicate_field("numTasks"));
3461 }
3462 num_tasks__ =
3463 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3464 ;
3465 }
3466 }
3467 }
3468 Ok(GetAssignedCompactTaskNumResponse {
3469 num_tasks: num_tasks__.unwrap_or_default(),
3470 })
3471 }
3472 }
3473 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumResponse", FIELDS, GeneratedVisitor)
3474 }
3475}
3476impl serde::Serialize for GetCompactionScoreRequest {
3477 #[allow(deprecated)]
3478 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3479 where
3480 S: serde::Serializer,
3481 {
3482 use serde::ser::SerializeStruct;
3483 let mut len = 0;
3484 if self.compaction_group_id != 0 {
3485 len += 1;
3486 }
3487 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreRequest", len)?;
3488 if self.compaction_group_id != 0 {
3489 #[allow(clippy::needless_borrow)]
3490 #[allow(clippy::needless_borrows_for_generic_args)]
3491 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3492 }
3493 struct_ser.end()
3494 }
3495}
3496impl<'de> serde::Deserialize<'de> for GetCompactionScoreRequest {
3497 #[allow(deprecated)]
3498 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3499 where
3500 D: serde::Deserializer<'de>,
3501 {
3502 const FIELDS: &[&str] = &[
3503 "compaction_group_id",
3504 "compactionGroupId",
3505 ];
3506
3507 #[allow(clippy::enum_variant_names)]
3508 enum GeneratedField {
3509 CompactionGroupId,
3510 }
3511 impl<'de> serde::Deserialize<'de> for GeneratedField {
3512 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3513 where
3514 D: serde::Deserializer<'de>,
3515 {
3516 struct GeneratedVisitor;
3517
3518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3519 type Value = GeneratedField;
3520
3521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3522 write!(formatter, "expected one of: {:?}", &FIELDS)
3523 }
3524
3525 #[allow(unused_variables)]
3526 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3527 where
3528 E: serde::de::Error,
3529 {
3530 match value {
3531 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3532 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3533 }
3534 }
3535 }
3536 deserializer.deserialize_identifier(GeneratedVisitor)
3537 }
3538 }
3539 struct GeneratedVisitor;
3540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3541 type Value = GetCompactionScoreRequest;
3542
3543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3544 formatter.write_str("struct hummock.GetCompactionScoreRequest")
3545 }
3546
3547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreRequest, V::Error>
3548 where
3549 V: serde::de::MapAccess<'de>,
3550 {
3551 let mut compaction_group_id__ = None;
3552 while let Some(k) = map_.next_key()? {
3553 match k {
3554 GeneratedField::CompactionGroupId => {
3555 if compaction_group_id__.is_some() {
3556 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3557 }
3558 compaction_group_id__ =
3559 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3560 ;
3561 }
3562 }
3563 }
3564 Ok(GetCompactionScoreRequest {
3565 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3566 })
3567 }
3568 }
3569 deserializer.deserialize_struct("hummock.GetCompactionScoreRequest", FIELDS, GeneratedVisitor)
3570 }
3571}
3572impl serde::Serialize for GetCompactionScoreResponse {
3573 #[allow(deprecated)]
3574 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3575 where
3576 S: serde::Serializer,
3577 {
3578 use serde::ser::SerializeStruct;
3579 let mut len = 0;
3580 if self.compaction_group_id != 0 {
3581 len += 1;
3582 }
3583 if !self.scores.is_empty() {
3584 len += 1;
3585 }
3586 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse", len)?;
3587 if self.compaction_group_id != 0 {
3588 #[allow(clippy::needless_borrow)]
3589 #[allow(clippy::needless_borrows_for_generic_args)]
3590 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3591 }
3592 if !self.scores.is_empty() {
3593 struct_ser.serialize_field("scores", &self.scores)?;
3594 }
3595 struct_ser.end()
3596 }
3597}
3598impl<'de> serde::Deserialize<'de> for GetCompactionScoreResponse {
3599 #[allow(deprecated)]
3600 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3601 where
3602 D: serde::Deserializer<'de>,
3603 {
3604 const FIELDS: &[&str] = &[
3605 "compaction_group_id",
3606 "compactionGroupId",
3607 "scores",
3608 ];
3609
3610 #[allow(clippy::enum_variant_names)]
3611 enum GeneratedField {
3612 CompactionGroupId,
3613 Scores,
3614 }
3615 impl<'de> serde::Deserialize<'de> for GeneratedField {
3616 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3617 where
3618 D: serde::Deserializer<'de>,
3619 {
3620 struct GeneratedVisitor;
3621
3622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3623 type Value = GeneratedField;
3624
3625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3626 write!(formatter, "expected one of: {:?}", &FIELDS)
3627 }
3628
3629 #[allow(unused_variables)]
3630 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3631 where
3632 E: serde::de::Error,
3633 {
3634 match value {
3635 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3636 "scores" => Ok(GeneratedField::Scores),
3637 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3638 }
3639 }
3640 }
3641 deserializer.deserialize_identifier(GeneratedVisitor)
3642 }
3643 }
3644 struct GeneratedVisitor;
3645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3646 type Value = GetCompactionScoreResponse;
3647
3648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3649 formatter.write_str("struct hummock.GetCompactionScoreResponse")
3650 }
3651
3652 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreResponse, V::Error>
3653 where
3654 V: serde::de::MapAccess<'de>,
3655 {
3656 let mut compaction_group_id__ = None;
3657 let mut scores__ = None;
3658 while let Some(k) = map_.next_key()? {
3659 match k {
3660 GeneratedField::CompactionGroupId => {
3661 if compaction_group_id__.is_some() {
3662 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3663 }
3664 compaction_group_id__ =
3665 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3666 ;
3667 }
3668 GeneratedField::Scores => {
3669 if scores__.is_some() {
3670 return Err(serde::de::Error::duplicate_field("scores"));
3671 }
3672 scores__ = Some(map_.next_value()?);
3673 }
3674 }
3675 }
3676 Ok(GetCompactionScoreResponse {
3677 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3678 scores: scores__.unwrap_or_default(),
3679 })
3680 }
3681 }
3682 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse", FIELDS, GeneratedVisitor)
3683 }
3684}
3685impl serde::Serialize for get_compaction_score_response::PickerInfo {
3686 #[allow(deprecated)]
3687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3688 where
3689 S: serde::Serializer,
3690 {
3691 use serde::ser::SerializeStruct;
3692 let mut len = 0;
3693 if self.score != 0 {
3694 len += 1;
3695 }
3696 if self.select_level != 0 {
3697 len += 1;
3698 }
3699 if self.target_level != 0 {
3700 len += 1;
3701 }
3702 if !self.picker_type.is_empty() {
3703 len += 1;
3704 }
3705 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", len)?;
3706 if self.score != 0 {
3707 #[allow(clippy::needless_borrow)]
3708 #[allow(clippy::needless_borrows_for_generic_args)]
3709 struct_ser.serialize_field("score", ToString::to_string(&self.score).as_str())?;
3710 }
3711 if self.select_level != 0 {
3712 #[allow(clippy::needless_borrow)]
3713 #[allow(clippy::needless_borrows_for_generic_args)]
3714 struct_ser.serialize_field("selectLevel", ToString::to_string(&self.select_level).as_str())?;
3715 }
3716 if self.target_level != 0 {
3717 #[allow(clippy::needless_borrow)]
3718 #[allow(clippy::needless_borrows_for_generic_args)]
3719 struct_ser.serialize_field("targetLevel", ToString::to_string(&self.target_level).as_str())?;
3720 }
3721 if !self.picker_type.is_empty() {
3722 struct_ser.serialize_field("pickerType", &self.picker_type)?;
3723 }
3724 struct_ser.end()
3725 }
3726}
3727impl<'de> serde::Deserialize<'de> for get_compaction_score_response::PickerInfo {
3728 #[allow(deprecated)]
3729 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3730 where
3731 D: serde::Deserializer<'de>,
3732 {
3733 const FIELDS: &[&str] = &[
3734 "score",
3735 "select_level",
3736 "selectLevel",
3737 "target_level",
3738 "targetLevel",
3739 "picker_type",
3740 "pickerType",
3741 ];
3742
3743 #[allow(clippy::enum_variant_names)]
3744 enum GeneratedField {
3745 Score,
3746 SelectLevel,
3747 TargetLevel,
3748 PickerType,
3749 }
3750 impl<'de> serde::Deserialize<'de> for GeneratedField {
3751 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3752 where
3753 D: serde::Deserializer<'de>,
3754 {
3755 struct GeneratedVisitor;
3756
3757 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3758 type Value = GeneratedField;
3759
3760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3761 write!(formatter, "expected one of: {:?}", &FIELDS)
3762 }
3763
3764 #[allow(unused_variables)]
3765 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3766 where
3767 E: serde::de::Error,
3768 {
3769 match value {
3770 "score" => Ok(GeneratedField::Score),
3771 "selectLevel" | "select_level" => Ok(GeneratedField::SelectLevel),
3772 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
3773 "pickerType" | "picker_type" => Ok(GeneratedField::PickerType),
3774 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3775 }
3776 }
3777 }
3778 deserializer.deserialize_identifier(GeneratedVisitor)
3779 }
3780 }
3781 struct GeneratedVisitor;
3782 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3783 type Value = get_compaction_score_response::PickerInfo;
3784
3785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3786 formatter.write_str("struct hummock.GetCompactionScoreResponse.PickerInfo")
3787 }
3788
3789 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_compaction_score_response::PickerInfo, V::Error>
3790 where
3791 V: serde::de::MapAccess<'de>,
3792 {
3793 let mut score__ = None;
3794 let mut select_level__ = None;
3795 let mut target_level__ = None;
3796 let mut picker_type__ = None;
3797 while let Some(k) = map_.next_key()? {
3798 match k {
3799 GeneratedField::Score => {
3800 if score__.is_some() {
3801 return Err(serde::de::Error::duplicate_field("score"));
3802 }
3803 score__ =
3804 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3805 ;
3806 }
3807 GeneratedField::SelectLevel => {
3808 if select_level__.is_some() {
3809 return Err(serde::de::Error::duplicate_field("selectLevel"));
3810 }
3811 select_level__ =
3812 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3813 ;
3814 }
3815 GeneratedField::TargetLevel => {
3816 if target_level__.is_some() {
3817 return Err(serde::de::Error::duplicate_field("targetLevel"));
3818 }
3819 target_level__ =
3820 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3821 ;
3822 }
3823 GeneratedField::PickerType => {
3824 if picker_type__.is_some() {
3825 return Err(serde::de::Error::duplicate_field("pickerType"));
3826 }
3827 picker_type__ = Some(map_.next_value()?);
3828 }
3829 }
3830 }
3831 Ok(get_compaction_score_response::PickerInfo {
3832 score: score__.unwrap_or_default(),
3833 select_level: select_level__.unwrap_or_default(),
3834 target_level: target_level__.unwrap_or_default(),
3835 picker_type: picker_type__.unwrap_or_default(),
3836 })
3837 }
3838 }
3839 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", FIELDS, GeneratedVisitor)
3840 }
3841}
3842impl serde::Serialize for GetCurrentVersionRequest {
3843 #[allow(deprecated)]
3844 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3845 where
3846 S: serde::Serializer,
3847 {
3848 use serde::ser::SerializeStruct;
3849 let len = 0;
3850 let struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionRequest", len)?;
3851 struct_ser.end()
3852 }
3853}
3854impl<'de> serde::Deserialize<'de> for GetCurrentVersionRequest {
3855 #[allow(deprecated)]
3856 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3857 where
3858 D: serde::Deserializer<'de>,
3859 {
3860 const FIELDS: &[&str] = &[
3861 ];
3862
3863 #[allow(clippy::enum_variant_names)]
3864 enum GeneratedField {
3865 }
3866 impl<'de> serde::Deserialize<'de> for GeneratedField {
3867 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3868 where
3869 D: serde::Deserializer<'de>,
3870 {
3871 struct GeneratedVisitor;
3872
3873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3874 type Value = GeneratedField;
3875
3876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3877 write!(formatter, "expected one of: {:?}", &FIELDS)
3878 }
3879
3880 #[allow(unused_variables)]
3881 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3882 where
3883 E: serde::de::Error,
3884 {
3885 Err(serde::de::Error::unknown_field(value, FIELDS))
3886 }
3887 }
3888 deserializer.deserialize_identifier(GeneratedVisitor)
3889 }
3890 }
3891 struct GeneratedVisitor;
3892 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3893 type Value = GetCurrentVersionRequest;
3894
3895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3896 formatter.write_str("struct hummock.GetCurrentVersionRequest")
3897 }
3898
3899 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionRequest, V::Error>
3900 where
3901 V: serde::de::MapAccess<'de>,
3902 {
3903 while map_.next_key::<GeneratedField>()?.is_some() {
3904 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3905 }
3906 Ok(GetCurrentVersionRequest {
3907 })
3908 }
3909 }
3910 deserializer.deserialize_struct("hummock.GetCurrentVersionRequest", FIELDS, GeneratedVisitor)
3911 }
3912}
3913impl serde::Serialize for GetCurrentVersionResponse {
3914 #[allow(deprecated)]
3915 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3916 where
3917 S: serde::Serializer,
3918 {
3919 use serde::ser::SerializeStruct;
3920 let mut len = 0;
3921 if self.status.is_some() {
3922 len += 1;
3923 }
3924 if self.current_version.is_some() {
3925 len += 1;
3926 }
3927 let mut struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionResponse", len)?;
3928 if let Some(v) = self.status.as_ref() {
3929 struct_ser.serialize_field("status", v)?;
3930 }
3931 if let Some(v) = self.current_version.as_ref() {
3932 struct_ser.serialize_field("currentVersion", v)?;
3933 }
3934 struct_ser.end()
3935 }
3936}
3937impl<'de> serde::Deserialize<'de> for GetCurrentVersionResponse {
3938 #[allow(deprecated)]
3939 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3940 where
3941 D: serde::Deserializer<'de>,
3942 {
3943 const FIELDS: &[&str] = &[
3944 "status",
3945 "current_version",
3946 "currentVersion",
3947 ];
3948
3949 #[allow(clippy::enum_variant_names)]
3950 enum GeneratedField {
3951 Status,
3952 CurrentVersion,
3953 }
3954 impl<'de> serde::Deserialize<'de> for GeneratedField {
3955 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3956 where
3957 D: serde::Deserializer<'de>,
3958 {
3959 struct GeneratedVisitor;
3960
3961 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3962 type Value = GeneratedField;
3963
3964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3965 write!(formatter, "expected one of: {:?}", &FIELDS)
3966 }
3967
3968 #[allow(unused_variables)]
3969 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3970 where
3971 E: serde::de::Error,
3972 {
3973 match value {
3974 "status" => Ok(GeneratedField::Status),
3975 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
3976 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3977 }
3978 }
3979 }
3980 deserializer.deserialize_identifier(GeneratedVisitor)
3981 }
3982 }
3983 struct GeneratedVisitor;
3984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3985 type Value = GetCurrentVersionResponse;
3986
3987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3988 formatter.write_str("struct hummock.GetCurrentVersionResponse")
3989 }
3990
3991 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionResponse, V::Error>
3992 where
3993 V: serde::de::MapAccess<'de>,
3994 {
3995 let mut status__ = None;
3996 let mut current_version__ = None;
3997 while let Some(k) = map_.next_key()? {
3998 match k {
3999 GeneratedField::Status => {
4000 if status__.is_some() {
4001 return Err(serde::de::Error::duplicate_field("status"));
4002 }
4003 status__ = map_.next_value()?;
4004 }
4005 GeneratedField::CurrentVersion => {
4006 if current_version__.is_some() {
4007 return Err(serde::de::Error::duplicate_field("currentVersion"));
4008 }
4009 current_version__ = map_.next_value()?;
4010 }
4011 }
4012 }
4013 Ok(GetCurrentVersionResponse {
4014 status: status__,
4015 current_version: current_version__,
4016 })
4017 }
4018 }
4019 deserializer.deserialize_struct("hummock.GetCurrentVersionResponse", FIELDS, GeneratedVisitor)
4020 }
4021}
4022impl serde::Serialize for GetNewObjectIdsRequest {
4023 #[allow(deprecated)]
4024 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4025 where
4026 S: serde::Serializer,
4027 {
4028 use serde::ser::SerializeStruct;
4029 let mut len = 0;
4030 if self.number != 0 {
4031 len += 1;
4032 }
4033 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsRequest", len)?;
4034 if self.number != 0 {
4035 struct_ser.serialize_field("number", &self.number)?;
4036 }
4037 struct_ser.end()
4038 }
4039}
4040impl<'de> serde::Deserialize<'de> for GetNewObjectIdsRequest {
4041 #[allow(deprecated)]
4042 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4043 where
4044 D: serde::Deserializer<'de>,
4045 {
4046 const FIELDS: &[&str] = &[
4047 "number",
4048 ];
4049
4050 #[allow(clippy::enum_variant_names)]
4051 enum GeneratedField {
4052 Number,
4053 }
4054 impl<'de> serde::Deserialize<'de> for GeneratedField {
4055 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4056 where
4057 D: serde::Deserializer<'de>,
4058 {
4059 struct GeneratedVisitor;
4060
4061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4062 type Value = GeneratedField;
4063
4064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4065 write!(formatter, "expected one of: {:?}", &FIELDS)
4066 }
4067
4068 #[allow(unused_variables)]
4069 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4070 where
4071 E: serde::de::Error,
4072 {
4073 match value {
4074 "number" => Ok(GeneratedField::Number),
4075 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4076 }
4077 }
4078 }
4079 deserializer.deserialize_identifier(GeneratedVisitor)
4080 }
4081 }
4082 struct GeneratedVisitor;
4083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4084 type Value = GetNewObjectIdsRequest;
4085
4086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4087 formatter.write_str("struct hummock.GetNewObjectIdsRequest")
4088 }
4089
4090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsRequest, V::Error>
4091 where
4092 V: serde::de::MapAccess<'de>,
4093 {
4094 let mut number__ = None;
4095 while let Some(k) = map_.next_key()? {
4096 match k {
4097 GeneratedField::Number => {
4098 if number__.is_some() {
4099 return Err(serde::de::Error::duplicate_field("number"));
4100 }
4101 number__ =
4102 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4103 ;
4104 }
4105 }
4106 }
4107 Ok(GetNewObjectIdsRequest {
4108 number: number__.unwrap_or_default(),
4109 })
4110 }
4111 }
4112 deserializer.deserialize_struct("hummock.GetNewObjectIdsRequest", FIELDS, GeneratedVisitor)
4113 }
4114}
4115impl serde::Serialize for GetNewObjectIdsResponse {
4116 #[allow(deprecated)]
4117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4118 where
4119 S: serde::Serializer,
4120 {
4121 use serde::ser::SerializeStruct;
4122 let mut len = 0;
4123 if self.status.is_some() {
4124 len += 1;
4125 }
4126 if self.start_id != 0 {
4127 len += 1;
4128 }
4129 if self.end_id != 0 {
4130 len += 1;
4131 }
4132 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsResponse", len)?;
4133 if let Some(v) = self.status.as_ref() {
4134 struct_ser.serialize_field("status", v)?;
4135 }
4136 if self.start_id != 0 {
4137 #[allow(clippy::needless_borrow)]
4138 #[allow(clippy::needless_borrows_for_generic_args)]
4139 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
4140 }
4141 if self.end_id != 0 {
4142 #[allow(clippy::needless_borrow)]
4143 #[allow(clippy::needless_borrows_for_generic_args)]
4144 struct_ser.serialize_field("endId", ToString::to_string(&self.end_id).as_str())?;
4145 }
4146 struct_ser.end()
4147 }
4148}
4149impl<'de> serde::Deserialize<'de> for GetNewObjectIdsResponse {
4150 #[allow(deprecated)]
4151 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4152 where
4153 D: serde::Deserializer<'de>,
4154 {
4155 const FIELDS: &[&str] = &[
4156 "status",
4157 "start_id",
4158 "startId",
4159 "end_id",
4160 "endId",
4161 ];
4162
4163 #[allow(clippy::enum_variant_names)]
4164 enum GeneratedField {
4165 Status,
4166 StartId,
4167 EndId,
4168 }
4169 impl<'de> serde::Deserialize<'de> for GeneratedField {
4170 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4171 where
4172 D: serde::Deserializer<'de>,
4173 {
4174 struct GeneratedVisitor;
4175
4176 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4177 type Value = GeneratedField;
4178
4179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4180 write!(formatter, "expected one of: {:?}", &FIELDS)
4181 }
4182
4183 #[allow(unused_variables)]
4184 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4185 where
4186 E: serde::de::Error,
4187 {
4188 match value {
4189 "status" => Ok(GeneratedField::Status),
4190 "startId" | "start_id" => Ok(GeneratedField::StartId),
4191 "endId" | "end_id" => Ok(GeneratedField::EndId),
4192 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4193 }
4194 }
4195 }
4196 deserializer.deserialize_identifier(GeneratedVisitor)
4197 }
4198 }
4199 struct GeneratedVisitor;
4200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4201 type Value = GetNewObjectIdsResponse;
4202
4203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4204 formatter.write_str("struct hummock.GetNewObjectIdsResponse")
4205 }
4206
4207 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsResponse, V::Error>
4208 where
4209 V: serde::de::MapAccess<'de>,
4210 {
4211 let mut status__ = None;
4212 let mut start_id__ = None;
4213 let mut end_id__ = None;
4214 while let Some(k) = map_.next_key()? {
4215 match k {
4216 GeneratedField::Status => {
4217 if status__.is_some() {
4218 return Err(serde::de::Error::duplicate_field("status"));
4219 }
4220 status__ = map_.next_value()?;
4221 }
4222 GeneratedField::StartId => {
4223 if start_id__.is_some() {
4224 return Err(serde::de::Error::duplicate_field("startId"));
4225 }
4226 start_id__ =
4227 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4228 ;
4229 }
4230 GeneratedField::EndId => {
4231 if end_id__.is_some() {
4232 return Err(serde::de::Error::duplicate_field("endId"));
4233 }
4234 end_id__ =
4235 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4236 ;
4237 }
4238 }
4239 }
4240 Ok(GetNewObjectIdsResponse {
4241 status: status__,
4242 start_id: start_id__.unwrap_or_default(),
4243 end_id: end_id__.unwrap_or_default(),
4244 })
4245 }
4246 }
4247 deserializer.deserialize_struct("hummock.GetNewObjectIdsResponse", FIELDS, GeneratedVisitor)
4248 }
4249}
4250impl serde::Serialize for GetVersionByEpochRequest {
4251 #[allow(deprecated)]
4252 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4253 where
4254 S: serde::Serializer,
4255 {
4256 use serde::ser::SerializeStruct;
4257 let mut len = 0;
4258 if self.epoch != 0 {
4259 len += 1;
4260 }
4261 if self.table_id != 0 {
4262 len += 1;
4263 }
4264 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochRequest", len)?;
4265 if self.epoch != 0 {
4266 #[allow(clippy::needless_borrow)]
4267 #[allow(clippy::needless_borrows_for_generic_args)]
4268 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
4269 }
4270 if self.table_id != 0 {
4271 struct_ser.serialize_field("tableId", &self.table_id)?;
4272 }
4273 struct_ser.end()
4274 }
4275}
4276impl<'de> serde::Deserialize<'de> for GetVersionByEpochRequest {
4277 #[allow(deprecated)]
4278 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4279 where
4280 D: serde::Deserializer<'de>,
4281 {
4282 const FIELDS: &[&str] = &[
4283 "epoch",
4284 "table_id",
4285 "tableId",
4286 ];
4287
4288 #[allow(clippy::enum_variant_names)]
4289 enum GeneratedField {
4290 Epoch,
4291 TableId,
4292 }
4293 impl<'de> serde::Deserialize<'de> for GeneratedField {
4294 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4295 where
4296 D: serde::Deserializer<'de>,
4297 {
4298 struct GeneratedVisitor;
4299
4300 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4301 type Value = GeneratedField;
4302
4303 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4304 write!(formatter, "expected one of: {:?}", &FIELDS)
4305 }
4306
4307 #[allow(unused_variables)]
4308 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4309 where
4310 E: serde::de::Error,
4311 {
4312 match value {
4313 "epoch" => Ok(GeneratedField::Epoch),
4314 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4315 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4316 }
4317 }
4318 }
4319 deserializer.deserialize_identifier(GeneratedVisitor)
4320 }
4321 }
4322 struct GeneratedVisitor;
4323 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4324 type Value = GetVersionByEpochRequest;
4325
4326 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4327 formatter.write_str("struct hummock.GetVersionByEpochRequest")
4328 }
4329
4330 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochRequest, V::Error>
4331 where
4332 V: serde::de::MapAccess<'de>,
4333 {
4334 let mut epoch__ = None;
4335 let mut table_id__ = None;
4336 while let Some(k) = map_.next_key()? {
4337 match k {
4338 GeneratedField::Epoch => {
4339 if epoch__.is_some() {
4340 return Err(serde::de::Error::duplicate_field("epoch"));
4341 }
4342 epoch__ =
4343 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4344 ;
4345 }
4346 GeneratedField::TableId => {
4347 if table_id__.is_some() {
4348 return Err(serde::de::Error::duplicate_field("tableId"));
4349 }
4350 table_id__ =
4351 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4352 ;
4353 }
4354 }
4355 }
4356 Ok(GetVersionByEpochRequest {
4357 epoch: epoch__.unwrap_or_default(),
4358 table_id: table_id__.unwrap_or_default(),
4359 })
4360 }
4361 }
4362 deserializer.deserialize_struct("hummock.GetVersionByEpochRequest", FIELDS, GeneratedVisitor)
4363 }
4364}
4365impl serde::Serialize for GetVersionByEpochResponse {
4366 #[allow(deprecated)]
4367 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4368 where
4369 S: serde::Serializer,
4370 {
4371 use serde::ser::SerializeStruct;
4372 let mut len = 0;
4373 if self.version.is_some() {
4374 len += 1;
4375 }
4376 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochResponse", len)?;
4377 if let Some(v) = self.version.as_ref() {
4378 struct_ser.serialize_field("version", v)?;
4379 }
4380 struct_ser.end()
4381 }
4382}
4383impl<'de> serde::Deserialize<'de> for GetVersionByEpochResponse {
4384 #[allow(deprecated)]
4385 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4386 where
4387 D: serde::Deserializer<'de>,
4388 {
4389 const FIELDS: &[&str] = &[
4390 "version",
4391 ];
4392
4393 #[allow(clippy::enum_variant_names)]
4394 enum GeneratedField {
4395 Version,
4396 }
4397 impl<'de> serde::Deserialize<'de> for GeneratedField {
4398 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4399 where
4400 D: serde::Deserializer<'de>,
4401 {
4402 struct GeneratedVisitor;
4403
4404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4405 type Value = GeneratedField;
4406
4407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4408 write!(formatter, "expected one of: {:?}", &FIELDS)
4409 }
4410
4411 #[allow(unused_variables)]
4412 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4413 where
4414 E: serde::de::Error,
4415 {
4416 match value {
4417 "version" => Ok(GeneratedField::Version),
4418 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4419 }
4420 }
4421 }
4422 deserializer.deserialize_identifier(GeneratedVisitor)
4423 }
4424 }
4425 struct GeneratedVisitor;
4426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4427 type Value = GetVersionByEpochResponse;
4428
4429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4430 formatter.write_str("struct hummock.GetVersionByEpochResponse")
4431 }
4432
4433 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochResponse, V::Error>
4434 where
4435 V: serde::de::MapAccess<'de>,
4436 {
4437 let mut version__ = None;
4438 while let Some(k) = map_.next_key()? {
4439 match k {
4440 GeneratedField::Version => {
4441 if version__.is_some() {
4442 return Err(serde::de::Error::duplicate_field("version"));
4443 }
4444 version__ = map_.next_value()?;
4445 }
4446 }
4447 }
4448 Ok(GetVersionByEpochResponse {
4449 version: version__,
4450 })
4451 }
4452 }
4453 deserializer.deserialize_struct("hummock.GetVersionByEpochResponse", FIELDS, GeneratedVisitor)
4454 }
4455}
4456impl serde::Serialize for GroupConstruct {
4457 #[allow(deprecated)]
4458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4459 where
4460 S: serde::Serializer,
4461 {
4462 use serde::ser::SerializeStruct;
4463 let mut len = 0;
4464 if self.group_config.is_some() {
4465 len += 1;
4466 }
4467 if self.parent_group_id != 0 {
4468 len += 1;
4469 }
4470 if !self.table_ids.is_empty() {
4471 len += 1;
4472 }
4473 if self.group_id != 0 {
4474 len += 1;
4475 }
4476 if self.new_sst_start_id != 0 {
4477 len += 1;
4478 }
4479 if self.version != 0 {
4480 len += 1;
4481 }
4482 if self.split_key.is_some() {
4483 len += 1;
4484 }
4485 let mut struct_ser = serializer.serialize_struct("hummock.GroupConstruct", len)?;
4486 if let Some(v) = self.group_config.as_ref() {
4487 struct_ser.serialize_field("groupConfig", v)?;
4488 }
4489 if self.parent_group_id != 0 {
4490 #[allow(clippy::needless_borrow)]
4491 #[allow(clippy::needless_borrows_for_generic_args)]
4492 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
4493 }
4494 if !self.table_ids.is_empty() {
4495 struct_ser.serialize_field("tableIds", &self.table_ids)?;
4496 }
4497 if self.group_id != 0 {
4498 #[allow(clippy::needless_borrow)]
4499 #[allow(clippy::needless_borrows_for_generic_args)]
4500 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
4501 }
4502 if self.new_sst_start_id != 0 {
4503 #[allow(clippy::needless_borrow)]
4504 #[allow(clippy::needless_borrows_for_generic_args)]
4505 struct_ser.serialize_field("newSstStartId", ToString::to_string(&self.new_sst_start_id).as_str())?;
4506 }
4507 if self.version != 0 {
4508 let v = CompatibilityVersion::try_from(self.version)
4509 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
4510 struct_ser.serialize_field("version", &v)?;
4511 }
4512 if let Some(v) = self.split_key.as_ref() {
4513 #[allow(clippy::needless_borrow)]
4514 #[allow(clippy::needless_borrows_for_generic_args)]
4515 struct_ser.serialize_field("splitKey", pbjson::private::base64::encode(&v).as_str())?;
4516 }
4517 struct_ser.end()
4518 }
4519}
4520impl<'de> serde::Deserialize<'de> for GroupConstruct {
4521 #[allow(deprecated)]
4522 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4523 where
4524 D: serde::Deserializer<'de>,
4525 {
4526 const FIELDS: &[&str] = &[
4527 "group_config",
4528 "groupConfig",
4529 "parent_group_id",
4530 "parentGroupId",
4531 "table_ids",
4532 "tableIds",
4533 "group_id",
4534 "groupId",
4535 "new_sst_start_id",
4536 "newSstStartId",
4537 "version",
4538 "split_key",
4539 "splitKey",
4540 ];
4541
4542 #[allow(clippy::enum_variant_names)]
4543 enum GeneratedField {
4544 GroupConfig,
4545 ParentGroupId,
4546 TableIds,
4547 GroupId,
4548 NewSstStartId,
4549 Version,
4550 SplitKey,
4551 }
4552 impl<'de> serde::Deserialize<'de> for GeneratedField {
4553 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4554 where
4555 D: serde::Deserializer<'de>,
4556 {
4557 struct GeneratedVisitor;
4558
4559 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4560 type Value = GeneratedField;
4561
4562 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4563 write!(formatter, "expected one of: {:?}", &FIELDS)
4564 }
4565
4566 #[allow(unused_variables)]
4567 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4568 where
4569 E: serde::de::Error,
4570 {
4571 match value {
4572 "groupConfig" | "group_config" => Ok(GeneratedField::GroupConfig),
4573 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
4574 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4575 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
4576 "newSstStartId" | "new_sst_start_id" => Ok(GeneratedField::NewSstStartId),
4577 "version" => Ok(GeneratedField::Version),
4578 "splitKey" | "split_key" => Ok(GeneratedField::SplitKey),
4579 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4580 }
4581 }
4582 }
4583 deserializer.deserialize_identifier(GeneratedVisitor)
4584 }
4585 }
4586 struct GeneratedVisitor;
4587 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4588 type Value = GroupConstruct;
4589
4590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4591 formatter.write_str("struct hummock.GroupConstruct")
4592 }
4593
4594 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupConstruct, V::Error>
4595 where
4596 V: serde::de::MapAccess<'de>,
4597 {
4598 let mut group_config__ = None;
4599 let mut parent_group_id__ = None;
4600 let mut table_ids__ = None;
4601 let mut group_id__ = None;
4602 let mut new_sst_start_id__ = None;
4603 let mut version__ = None;
4604 let mut split_key__ = None;
4605 while let Some(k) = map_.next_key()? {
4606 match k {
4607 GeneratedField::GroupConfig => {
4608 if group_config__.is_some() {
4609 return Err(serde::de::Error::duplicate_field("groupConfig"));
4610 }
4611 group_config__ = map_.next_value()?;
4612 }
4613 GeneratedField::ParentGroupId => {
4614 if parent_group_id__.is_some() {
4615 return Err(serde::de::Error::duplicate_field("parentGroupId"));
4616 }
4617 parent_group_id__ =
4618 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4619 ;
4620 }
4621 GeneratedField::TableIds => {
4622 if table_ids__.is_some() {
4623 return Err(serde::de::Error::duplicate_field("tableIds"));
4624 }
4625 table_ids__ =
4626 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4627 .into_iter().map(|x| x.0).collect())
4628 ;
4629 }
4630 GeneratedField::GroupId => {
4631 if group_id__.is_some() {
4632 return Err(serde::de::Error::duplicate_field("groupId"));
4633 }
4634 group_id__ =
4635 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4636 ;
4637 }
4638 GeneratedField::NewSstStartId => {
4639 if new_sst_start_id__.is_some() {
4640 return Err(serde::de::Error::duplicate_field("newSstStartId"));
4641 }
4642 new_sst_start_id__ =
4643 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4644 ;
4645 }
4646 GeneratedField::Version => {
4647 if version__.is_some() {
4648 return Err(serde::de::Error::duplicate_field("version"));
4649 }
4650 version__ = Some(map_.next_value::<CompatibilityVersion>()? as i32);
4651 }
4652 GeneratedField::SplitKey => {
4653 if split_key__.is_some() {
4654 return Err(serde::de::Error::duplicate_field("splitKey"));
4655 }
4656 split_key__ =
4657 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
4658 ;
4659 }
4660 }
4661 }
4662 Ok(GroupConstruct {
4663 group_config: group_config__,
4664 parent_group_id: parent_group_id__.unwrap_or_default(),
4665 table_ids: table_ids__.unwrap_or_default(),
4666 group_id: group_id__.unwrap_or_default(),
4667 new_sst_start_id: new_sst_start_id__.unwrap_or_default(),
4668 version: version__.unwrap_or_default(),
4669 split_key: split_key__,
4670 })
4671 }
4672 }
4673 deserializer.deserialize_struct("hummock.GroupConstruct", FIELDS, GeneratedVisitor)
4674 }
4675}
4676impl serde::Serialize for GroupDelta {
4677 #[allow(deprecated)]
4678 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4679 where
4680 S: serde::Serializer,
4681 {
4682 use serde::ser::SerializeStruct;
4683 let mut len = 0;
4684 if self.delta_type.is_some() {
4685 len += 1;
4686 }
4687 let mut struct_ser = serializer.serialize_struct("hummock.GroupDelta", len)?;
4688 if let Some(v) = self.delta_type.as_ref() {
4689 match v {
4690 group_delta::DeltaType::IntraLevel(v) => {
4691 struct_ser.serialize_field("intraLevel", v)?;
4692 }
4693 group_delta::DeltaType::GroupConstruct(v) => {
4694 struct_ser.serialize_field("groupConstruct", v)?;
4695 }
4696 group_delta::DeltaType::GroupDestroy(v) => {
4697 struct_ser.serialize_field("groupDestroy", v)?;
4698 }
4699 group_delta::DeltaType::GroupMerge(v) => {
4700 struct_ser.serialize_field("groupMerge", v)?;
4701 }
4702 group_delta::DeltaType::NewL0SubLevel(v) => {
4703 struct_ser.serialize_field("newL0SubLevel", v)?;
4704 }
4705 }
4706 }
4707 struct_ser.end()
4708 }
4709}
4710impl<'de> serde::Deserialize<'de> for GroupDelta {
4711 #[allow(deprecated)]
4712 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4713 where
4714 D: serde::Deserializer<'de>,
4715 {
4716 const FIELDS: &[&str] = &[
4717 "intra_level",
4718 "intraLevel",
4719 "group_construct",
4720 "groupConstruct",
4721 "group_destroy",
4722 "groupDestroy",
4723 "group_merge",
4724 "groupMerge",
4725 "new_l0_sub_level",
4726 "newL0SubLevel",
4727 ];
4728
4729 #[allow(clippy::enum_variant_names)]
4730 enum GeneratedField {
4731 IntraLevel,
4732 GroupConstruct,
4733 GroupDestroy,
4734 GroupMerge,
4735 NewL0SubLevel,
4736 }
4737 impl<'de> serde::Deserialize<'de> for GeneratedField {
4738 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4739 where
4740 D: serde::Deserializer<'de>,
4741 {
4742 struct GeneratedVisitor;
4743
4744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4745 type Value = GeneratedField;
4746
4747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4748 write!(formatter, "expected one of: {:?}", &FIELDS)
4749 }
4750
4751 #[allow(unused_variables)]
4752 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4753 where
4754 E: serde::de::Error,
4755 {
4756 match value {
4757 "intraLevel" | "intra_level" => Ok(GeneratedField::IntraLevel),
4758 "groupConstruct" | "group_construct" => Ok(GeneratedField::GroupConstruct),
4759 "groupDestroy" | "group_destroy" => Ok(GeneratedField::GroupDestroy),
4760 "groupMerge" | "group_merge" => Ok(GeneratedField::GroupMerge),
4761 "newL0SubLevel" | "new_l0_sub_level" => Ok(GeneratedField::NewL0SubLevel),
4762 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4763 }
4764 }
4765 }
4766 deserializer.deserialize_identifier(GeneratedVisitor)
4767 }
4768 }
4769 struct GeneratedVisitor;
4770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4771 type Value = GroupDelta;
4772
4773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4774 formatter.write_str("struct hummock.GroupDelta")
4775 }
4776
4777 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDelta, V::Error>
4778 where
4779 V: serde::de::MapAccess<'de>,
4780 {
4781 let mut delta_type__ = None;
4782 while let Some(k) = map_.next_key()? {
4783 match k {
4784 GeneratedField::IntraLevel => {
4785 if delta_type__.is_some() {
4786 return Err(serde::de::Error::duplicate_field("intraLevel"));
4787 }
4788 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::IntraLevel)
4789;
4790 }
4791 GeneratedField::GroupConstruct => {
4792 if delta_type__.is_some() {
4793 return Err(serde::de::Error::duplicate_field("groupConstruct"));
4794 }
4795 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupConstruct)
4796;
4797 }
4798 GeneratedField::GroupDestroy => {
4799 if delta_type__.is_some() {
4800 return Err(serde::de::Error::duplicate_field("groupDestroy"));
4801 }
4802 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupDestroy)
4803;
4804 }
4805 GeneratedField::GroupMerge => {
4806 if delta_type__.is_some() {
4807 return Err(serde::de::Error::duplicate_field("groupMerge"));
4808 }
4809 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupMerge)
4810;
4811 }
4812 GeneratedField::NewL0SubLevel => {
4813 if delta_type__.is_some() {
4814 return Err(serde::de::Error::duplicate_field("newL0SubLevel"));
4815 }
4816 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::NewL0SubLevel)
4817;
4818 }
4819 }
4820 }
4821 Ok(GroupDelta {
4822 delta_type: delta_type__,
4823 })
4824 }
4825 }
4826 deserializer.deserialize_struct("hummock.GroupDelta", FIELDS, GeneratedVisitor)
4827 }
4828}
4829impl serde::Serialize for GroupDestroy {
4830 #[allow(deprecated)]
4831 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4832 where
4833 S: serde::Serializer,
4834 {
4835 use serde::ser::SerializeStruct;
4836 let len = 0;
4837 let struct_ser = serializer.serialize_struct("hummock.GroupDestroy", len)?;
4838 struct_ser.end()
4839 }
4840}
4841impl<'de> serde::Deserialize<'de> for GroupDestroy {
4842 #[allow(deprecated)]
4843 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4844 where
4845 D: serde::Deserializer<'de>,
4846 {
4847 const FIELDS: &[&str] = &[
4848 ];
4849
4850 #[allow(clippy::enum_variant_names)]
4851 enum GeneratedField {
4852 }
4853 impl<'de> serde::Deserialize<'de> for GeneratedField {
4854 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4855 where
4856 D: serde::Deserializer<'de>,
4857 {
4858 struct GeneratedVisitor;
4859
4860 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4861 type Value = GeneratedField;
4862
4863 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4864 write!(formatter, "expected one of: {:?}", &FIELDS)
4865 }
4866
4867 #[allow(unused_variables)]
4868 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4869 where
4870 E: serde::de::Error,
4871 {
4872 Err(serde::de::Error::unknown_field(value, FIELDS))
4873 }
4874 }
4875 deserializer.deserialize_identifier(GeneratedVisitor)
4876 }
4877 }
4878 struct GeneratedVisitor;
4879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4880 type Value = GroupDestroy;
4881
4882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4883 formatter.write_str("struct hummock.GroupDestroy")
4884 }
4885
4886 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDestroy, V::Error>
4887 where
4888 V: serde::de::MapAccess<'de>,
4889 {
4890 while map_.next_key::<GeneratedField>()?.is_some() {
4891 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4892 }
4893 Ok(GroupDestroy {
4894 })
4895 }
4896 }
4897 deserializer.deserialize_struct("hummock.GroupDestroy", FIELDS, GeneratedVisitor)
4898 }
4899}
4900impl serde::Serialize for GroupMerge {
4901 #[allow(deprecated)]
4902 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4903 where
4904 S: serde::Serializer,
4905 {
4906 use serde::ser::SerializeStruct;
4907 let mut len = 0;
4908 if self.left_group_id != 0 {
4909 len += 1;
4910 }
4911 if self.right_group_id != 0 {
4912 len += 1;
4913 }
4914 let mut struct_ser = serializer.serialize_struct("hummock.GroupMerge", len)?;
4915 if self.left_group_id != 0 {
4916 #[allow(clippy::needless_borrow)]
4917 #[allow(clippy::needless_borrows_for_generic_args)]
4918 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
4919 }
4920 if self.right_group_id != 0 {
4921 #[allow(clippy::needless_borrow)]
4922 #[allow(clippy::needless_borrows_for_generic_args)]
4923 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
4924 }
4925 struct_ser.end()
4926 }
4927}
4928impl<'de> serde::Deserialize<'de> for GroupMerge {
4929 #[allow(deprecated)]
4930 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4931 where
4932 D: serde::Deserializer<'de>,
4933 {
4934 const FIELDS: &[&str] = &[
4935 "left_group_id",
4936 "leftGroupId",
4937 "right_group_id",
4938 "rightGroupId",
4939 ];
4940
4941 #[allow(clippy::enum_variant_names)]
4942 enum GeneratedField {
4943 LeftGroupId,
4944 RightGroupId,
4945 }
4946 impl<'de> serde::Deserialize<'de> for GeneratedField {
4947 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4948 where
4949 D: serde::Deserializer<'de>,
4950 {
4951 struct GeneratedVisitor;
4952
4953 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4954 type Value = GeneratedField;
4955
4956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4957 write!(formatter, "expected one of: {:?}", &FIELDS)
4958 }
4959
4960 #[allow(unused_variables)]
4961 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4962 where
4963 E: serde::de::Error,
4964 {
4965 match value {
4966 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
4967 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
4968 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4969 }
4970 }
4971 }
4972 deserializer.deserialize_identifier(GeneratedVisitor)
4973 }
4974 }
4975 struct GeneratedVisitor;
4976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4977 type Value = GroupMerge;
4978
4979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4980 formatter.write_str("struct hummock.GroupMerge")
4981 }
4982
4983 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupMerge, V::Error>
4984 where
4985 V: serde::de::MapAccess<'de>,
4986 {
4987 let mut left_group_id__ = None;
4988 let mut right_group_id__ = None;
4989 while let Some(k) = map_.next_key()? {
4990 match k {
4991 GeneratedField::LeftGroupId => {
4992 if left_group_id__.is_some() {
4993 return Err(serde::de::Error::duplicate_field("leftGroupId"));
4994 }
4995 left_group_id__ =
4996 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4997 ;
4998 }
4999 GeneratedField::RightGroupId => {
5000 if right_group_id__.is_some() {
5001 return Err(serde::de::Error::duplicate_field("rightGroupId"));
5002 }
5003 right_group_id__ =
5004 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5005 ;
5006 }
5007 }
5008 }
5009 Ok(GroupMerge {
5010 left_group_id: left_group_id__.unwrap_or_default(),
5011 right_group_id: right_group_id__.unwrap_or_default(),
5012 })
5013 }
5014 }
5015 deserializer.deserialize_struct("hummock.GroupMerge", FIELDS, GeneratedVisitor)
5016 }
5017}
5018impl serde::Serialize for HummockPinnedSnapshot {
5019 #[allow(deprecated)]
5020 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5021 where
5022 S: serde::Serializer,
5023 {
5024 use serde::ser::SerializeStruct;
5025 let mut len = 0;
5026 if self.context_id != 0 {
5027 len += 1;
5028 }
5029 if self.minimal_pinned_snapshot != 0 {
5030 len += 1;
5031 }
5032 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedSnapshot", len)?;
5033 if self.context_id != 0 {
5034 struct_ser.serialize_field("contextId", &self.context_id)?;
5035 }
5036 if self.minimal_pinned_snapshot != 0 {
5037 #[allow(clippy::needless_borrow)]
5038 #[allow(clippy::needless_borrows_for_generic_args)]
5039 struct_ser.serialize_field("minimalPinnedSnapshot", ToString::to_string(&self.minimal_pinned_snapshot).as_str())?;
5040 }
5041 struct_ser.end()
5042 }
5043}
5044impl<'de> serde::Deserialize<'de> for HummockPinnedSnapshot {
5045 #[allow(deprecated)]
5046 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5047 where
5048 D: serde::Deserializer<'de>,
5049 {
5050 const FIELDS: &[&str] = &[
5051 "context_id",
5052 "contextId",
5053 "minimal_pinned_snapshot",
5054 "minimalPinnedSnapshot",
5055 ];
5056
5057 #[allow(clippy::enum_variant_names)]
5058 enum GeneratedField {
5059 ContextId,
5060 MinimalPinnedSnapshot,
5061 }
5062 impl<'de> serde::Deserialize<'de> for GeneratedField {
5063 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5064 where
5065 D: serde::Deserializer<'de>,
5066 {
5067 struct GeneratedVisitor;
5068
5069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5070 type Value = GeneratedField;
5071
5072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5073 write!(formatter, "expected one of: {:?}", &FIELDS)
5074 }
5075
5076 #[allow(unused_variables)]
5077 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5078 where
5079 E: serde::de::Error,
5080 {
5081 match value {
5082 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
5083 "minimalPinnedSnapshot" | "minimal_pinned_snapshot" => Ok(GeneratedField::MinimalPinnedSnapshot),
5084 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5085 }
5086 }
5087 }
5088 deserializer.deserialize_identifier(GeneratedVisitor)
5089 }
5090 }
5091 struct GeneratedVisitor;
5092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5093 type Value = HummockPinnedSnapshot;
5094
5095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5096 formatter.write_str("struct hummock.HummockPinnedSnapshot")
5097 }
5098
5099 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedSnapshot, V::Error>
5100 where
5101 V: serde::de::MapAccess<'de>,
5102 {
5103 let mut context_id__ = None;
5104 let mut minimal_pinned_snapshot__ = None;
5105 while let Some(k) = map_.next_key()? {
5106 match k {
5107 GeneratedField::ContextId => {
5108 if context_id__.is_some() {
5109 return Err(serde::de::Error::duplicate_field("contextId"));
5110 }
5111 context_id__ =
5112 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5113 ;
5114 }
5115 GeneratedField::MinimalPinnedSnapshot => {
5116 if minimal_pinned_snapshot__.is_some() {
5117 return Err(serde::de::Error::duplicate_field("minimalPinnedSnapshot"));
5118 }
5119 minimal_pinned_snapshot__ =
5120 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5121 ;
5122 }
5123 }
5124 }
5125 Ok(HummockPinnedSnapshot {
5126 context_id: context_id__.unwrap_or_default(),
5127 minimal_pinned_snapshot: minimal_pinned_snapshot__.unwrap_or_default(),
5128 })
5129 }
5130 }
5131 deserializer.deserialize_struct("hummock.HummockPinnedSnapshot", FIELDS, GeneratedVisitor)
5132 }
5133}
5134impl serde::Serialize for HummockPinnedVersion {
5135 #[allow(deprecated)]
5136 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5137 where
5138 S: serde::Serializer,
5139 {
5140 use serde::ser::SerializeStruct;
5141 let mut len = 0;
5142 if self.context_id != 0 {
5143 len += 1;
5144 }
5145 if self.min_pinned_id != 0 {
5146 len += 1;
5147 }
5148 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedVersion", len)?;
5149 if self.context_id != 0 {
5150 struct_ser.serialize_field("contextId", &self.context_id)?;
5151 }
5152 if self.min_pinned_id != 0 {
5153 #[allow(clippy::needless_borrow)]
5154 #[allow(clippy::needless_borrows_for_generic_args)]
5155 struct_ser.serialize_field("minPinnedId", ToString::to_string(&self.min_pinned_id).as_str())?;
5156 }
5157 struct_ser.end()
5158 }
5159}
5160impl<'de> serde::Deserialize<'de> for HummockPinnedVersion {
5161 #[allow(deprecated)]
5162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5163 where
5164 D: serde::Deserializer<'de>,
5165 {
5166 const FIELDS: &[&str] = &[
5167 "context_id",
5168 "contextId",
5169 "min_pinned_id",
5170 "minPinnedId",
5171 ];
5172
5173 #[allow(clippy::enum_variant_names)]
5174 enum GeneratedField {
5175 ContextId,
5176 MinPinnedId,
5177 }
5178 impl<'de> serde::Deserialize<'de> for GeneratedField {
5179 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5180 where
5181 D: serde::Deserializer<'de>,
5182 {
5183 struct GeneratedVisitor;
5184
5185 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5186 type Value = GeneratedField;
5187
5188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5189 write!(formatter, "expected one of: {:?}", &FIELDS)
5190 }
5191
5192 #[allow(unused_variables)]
5193 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5194 where
5195 E: serde::de::Error,
5196 {
5197 match value {
5198 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
5199 "minPinnedId" | "min_pinned_id" => Ok(GeneratedField::MinPinnedId),
5200 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5201 }
5202 }
5203 }
5204 deserializer.deserialize_identifier(GeneratedVisitor)
5205 }
5206 }
5207 struct GeneratedVisitor;
5208 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5209 type Value = HummockPinnedVersion;
5210
5211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5212 formatter.write_str("struct hummock.HummockPinnedVersion")
5213 }
5214
5215 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedVersion, V::Error>
5216 where
5217 V: serde::de::MapAccess<'de>,
5218 {
5219 let mut context_id__ = None;
5220 let mut min_pinned_id__ = None;
5221 while let Some(k) = map_.next_key()? {
5222 match k {
5223 GeneratedField::ContextId => {
5224 if context_id__.is_some() {
5225 return Err(serde::de::Error::duplicate_field("contextId"));
5226 }
5227 context_id__ =
5228 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5229 ;
5230 }
5231 GeneratedField::MinPinnedId => {
5232 if min_pinned_id__.is_some() {
5233 return Err(serde::de::Error::duplicate_field("minPinnedId"));
5234 }
5235 min_pinned_id__ =
5236 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5237 ;
5238 }
5239 }
5240 }
5241 Ok(HummockPinnedVersion {
5242 context_id: context_id__.unwrap_or_default(),
5243 min_pinned_id: min_pinned_id__.unwrap_or_default(),
5244 })
5245 }
5246 }
5247 deserializer.deserialize_struct("hummock.HummockPinnedVersion", FIELDS, GeneratedVisitor)
5248 }
5249}
5250impl serde::Serialize for HummockVersion {
5251 #[allow(deprecated)]
5252 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5253 where
5254 S: serde::Serializer,
5255 {
5256 use serde::ser::SerializeStruct;
5257 let mut len = 0;
5258 if self.id != 0 {
5259 len += 1;
5260 }
5261 if !self.levels.is_empty() {
5262 len += 1;
5263 }
5264 if self.max_committed_epoch != 0 {
5265 len += 1;
5266 }
5267 if !self.table_watermarks.is_empty() {
5268 len += 1;
5269 }
5270 if !self.table_change_logs.is_empty() {
5271 len += 1;
5272 }
5273 if !self.state_table_info.is_empty() {
5274 len += 1;
5275 }
5276 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion", len)?;
5277 if self.id != 0 {
5278 #[allow(clippy::needless_borrow)]
5279 #[allow(clippy::needless_borrows_for_generic_args)]
5280 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
5281 }
5282 if !self.levels.is_empty() {
5283 struct_ser.serialize_field("levels", &self.levels)?;
5284 }
5285 if self.max_committed_epoch != 0 {
5286 #[allow(clippy::needless_borrow)]
5287 #[allow(clippy::needless_borrows_for_generic_args)]
5288 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
5289 }
5290 if !self.table_watermarks.is_empty() {
5291 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
5292 }
5293 if !self.table_change_logs.is_empty() {
5294 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
5295 }
5296 if !self.state_table_info.is_empty() {
5297 struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
5298 }
5299 struct_ser.end()
5300 }
5301}
5302impl<'de> serde::Deserialize<'de> for HummockVersion {
5303 #[allow(deprecated)]
5304 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5305 where
5306 D: serde::Deserializer<'de>,
5307 {
5308 const FIELDS: &[&str] = &[
5309 "id",
5310 "levels",
5311 "max_committed_epoch",
5312 "maxCommittedEpoch",
5313 "table_watermarks",
5314 "tableWatermarks",
5315 "table_change_logs",
5316 "tableChangeLogs",
5317 "state_table_info",
5318 "stateTableInfo",
5319 ];
5320
5321 #[allow(clippy::enum_variant_names)]
5322 enum GeneratedField {
5323 Id,
5324 Levels,
5325 MaxCommittedEpoch,
5326 TableWatermarks,
5327 TableChangeLogs,
5328 StateTableInfo,
5329 }
5330 impl<'de> serde::Deserialize<'de> for GeneratedField {
5331 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5332 where
5333 D: serde::Deserializer<'de>,
5334 {
5335 struct GeneratedVisitor;
5336
5337 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5338 type Value = GeneratedField;
5339
5340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5341 write!(formatter, "expected one of: {:?}", &FIELDS)
5342 }
5343
5344 #[allow(unused_variables)]
5345 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5346 where
5347 E: serde::de::Error,
5348 {
5349 match value {
5350 "id" => Ok(GeneratedField::Id),
5351 "levels" => Ok(GeneratedField::Levels),
5352 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
5353 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
5354 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
5355 "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
5356 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5357 }
5358 }
5359 }
5360 deserializer.deserialize_identifier(GeneratedVisitor)
5361 }
5362 }
5363 struct GeneratedVisitor;
5364 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5365 type Value = HummockVersion;
5366
5367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5368 formatter.write_str("struct hummock.HummockVersion")
5369 }
5370
5371 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersion, V::Error>
5372 where
5373 V: serde::de::MapAccess<'de>,
5374 {
5375 let mut id__ = None;
5376 let mut levels__ = None;
5377 let mut max_committed_epoch__ = None;
5378 let mut table_watermarks__ = None;
5379 let mut table_change_logs__ = None;
5380 let mut state_table_info__ = None;
5381 while let Some(k) = map_.next_key()? {
5382 match k {
5383 GeneratedField::Id => {
5384 if id__.is_some() {
5385 return Err(serde::de::Error::duplicate_field("id"));
5386 }
5387 id__ =
5388 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5389 ;
5390 }
5391 GeneratedField::Levels => {
5392 if levels__.is_some() {
5393 return Err(serde::de::Error::duplicate_field("levels"));
5394 }
5395 levels__ = Some(
5396 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
5397 .into_iter().map(|(k,v)| (k.0, v)).collect()
5398 );
5399 }
5400 GeneratedField::MaxCommittedEpoch => {
5401 if max_committed_epoch__.is_some() {
5402 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
5403 }
5404 max_committed_epoch__ =
5405 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5406 ;
5407 }
5408 GeneratedField::TableWatermarks => {
5409 if table_watermarks__.is_some() {
5410 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
5411 }
5412 table_watermarks__ = Some(
5413 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5414 .into_iter().map(|(k,v)| (k.0, v)).collect()
5415 );
5416 }
5417 GeneratedField::TableChangeLogs => {
5418 if table_change_logs__.is_some() {
5419 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
5420 }
5421 table_change_logs__ = Some(
5422 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5423 .into_iter().map(|(k,v)| (k.0, v)).collect()
5424 );
5425 }
5426 GeneratedField::StateTableInfo => {
5427 if state_table_info__.is_some() {
5428 return Err(serde::de::Error::duplicate_field("stateTableInfo"));
5429 }
5430 state_table_info__ = Some(
5431 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5432 .into_iter().map(|(k,v)| (k.0, v)).collect()
5433 );
5434 }
5435 }
5436 }
5437 Ok(HummockVersion {
5438 id: id__.unwrap_or_default(),
5439 levels: levels__.unwrap_or_default(),
5440 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
5441 table_watermarks: table_watermarks__.unwrap_or_default(),
5442 table_change_logs: table_change_logs__.unwrap_or_default(),
5443 state_table_info: state_table_info__.unwrap_or_default(),
5444 })
5445 }
5446 }
5447 deserializer.deserialize_struct("hummock.HummockVersion", FIELDS, GeneratedVisitor)
5448 }
5449}
5450impl serde::Serialize for hummock_version::Levels {
5451 #[allow(deprecated)]
5452 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5453 where
5454 S: serde::Serializer,
5455 {
5456 use serde::ser::SerializeStruct;
5457 let mut len = 0;
5458 if !self.levels.is_empty() {
5459 len += 1;
5460 }
5461 if self.l0.is_some() {
5462 len += 1;
5463 }
5464 if self.group_id != 0 {
5465 len += 1;
5466 }
5467 if self.parent_group_id != 0 {
5468 len += 1;
5469 }
5470 if !self.member_table_ids.is_empty() {
5471 len += 1;
5472 }
5473 if self.compaction_group_version_id != 0 {
5474 len += 1;
5475 }
5476 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion.Levels", len)?;
5477 if !self.levels.is_empty() {
5478 struct_ser.serialize_field("levels", &self.levels)?;
5479 }
5480 if let Some(v) = self.l0.as_ref() {
5481 struct_ser.serialize_field("l0", v)?;
5482 }
5483 if self.group_id != 0 {
5484 #[allow(clippy::needless_borrow)]
5485 #[allow(clippy::needless_borrows_for_generic_args)]
5486 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
5487 }
5488 if self.parent_group_id != 0 {
5489 #[allow(clippy::needless_borrow)]
5490 #[allow(clippy::needless_borrows_for_generic_args)]
5491 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
5492 }
5493 if !self.member_table_ids.is_empty() {
5494 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
5495 }
5496 if self.compaction_group_version_id != 0 {
5497 #[allow(clippy::needless_borrow)]
5498 #[allow(clippy::needless_borrows_for_generic_args)]
5499 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
5500 }
5501 struct_ser.end()
5502 }
5503}
5504impl<'de> serde::Deserialize<'de> for hummock_version::Levels {
5505 #[allow(deprecated)]
5506 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5507 where
5508 D: serde::Deserializer<'de>,
5509 {
5510 const FIELDS: &[&str] = &[
5511 "levels",
5512 "l0",
5513 "group_id",
5514 "groupId",
5515 "parent_group_id",
5516 "parentGroupId",
5517 "member_table_ids",
5518 "memberTableIds",
5519 "compaction_group_version_id",
5520 "compactionGroupVersionId",
5521 ];
5522
5523 #[allow(clippy::enum_variant_names)]
5524 enum GeneratedField {
5525 Levels,
5526 L0,
5527 GroupId,
5528 ParentGroupId,
5529 MemberTableIds,
5530 CompactionGroupVersionId,
5531 }
5532 impl<'de> serde::Deserialize<'de> for GeneratedField {
5533 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5534 where
5535 D: serde::Deserializer<'de>,
5536 {
5537 struct GeneratedVisitor;
5538
5539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5540 type Value = GeneratedField;
5541
5542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5543 write!(formatter, "expected one of: {:?}", &FIELDS)
5544 }
5545
5546 #[allow(unused_variables)]
5547 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5548 where
5549 E: serde::de::Error,
5550 {
5551 match value {
5552 "levels" => Ok(GeneratedField::Levels),
5553 "l0" => Ok(GeneratedField::L0),
5554 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
5555 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
5556 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
5557 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
5558 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5559 }
5560 }
5561 }
5562 deserializer.deserialize_identifier(GeneratedVisitor)
5563 }
5564 }
5565 struct GeneratedVisitor;
5566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5567 type Value = hummock_version::Levels;
5568
5569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5570 formatter.write_str("struct hummock.HummockVersion.Levels")
5571 }
5572
5573 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version::Levels, V::Error>
5574 where
5575 V: serde::de::MapAccess<'de>,
5576 {
5577 let mut levels__ = None;
5578 let mut l0__ = None;
5579 let mut group_id__ = None;
5580 let mut parent_group_id__ = None;
5581 let mut member_table_ids__ = None;
5582 let mut compaction_group_version_id__ = None;
5583 while let Some(k) = map_.next_key()? {
5584 match k {
5585 GeneratedField::Levels => {
5586 if levels__.is_some() {
5587 return Err(serde::de::Error::duplicate_field("levels"));
5588 }
5589 levels__ = Some(map_.next_value()?);
5590 }
5591 GeneratedField::L0 => {
5592 if l0__.is_some() {
5593 return Err(serde::de::Error::duplicate_field("l0"));
5594 }
5595 l0__ = map_.next_value()?;
5596 }
5597 GeneratedField::GroupId => {
5598 if group_id__.is_some() {
5599 return Err(serde::de::Error::duplicate_field("groupId"));
5600 }
5601 group_id__ =
5602 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5603 ;
5604 }
5605 GeneratedField::ParentGroupId => {
5606 if parent_group_id__.is_some() {
5607 return Err(serde::de::Error::duplicate_field("parentGroupId"));
5608 }
5609 parent_group_id__ =
5610 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5611 ;
5612 }
5613 GeneratedField::MemberTableIds => {
5614 if member_table_ids__.is_some() {
5615 return Err(serde::de::Error::duplicate_field("memberTableIds"));
5616 }
5617 member_table_ids__ =
5618 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5619 .into_iter().map(|x| x.0).collect())
5620 ;
5621 }
5622 GeneratedField::CompactionGroupVersionId => {
5623 if compaction_group_version_id__.is_some() {
5624 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
5625 }
5626 compaction_group_version_id__ =
5627 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5628 ;
5629 }
5630 }
5631 }
5632 Ok(hummock_version::Levels {
5633 levels: levels__.unwrap_or_default(),
5634 l0: l0__,
5635 group_id: group_id__.unwrap_or_default(),
5636 parent_group_id: parent_group_id__.unwrap_or_default(),
5637 member_table_ids: member_table_ids__.unwrap_or_default(),
5638 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
5639 })
5640 }
5641 }
5642 deserializer.deserialize_struct("hummock.HummockVersion.Levels", FIELDS, GeneratedVisitor)
5643 }
5644}
5645impl serde::Serialize for HummockVersionArchive {
5646 #[allow(deprecated)]
5647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5648 where
5649 S: serde::Serializer,
5650 {
5651 use serde::ser::SerializeStruct;
5652 let mut len = 0;
5653 if self.version.is_some() {
5654 len += 1;
5655 }
5656 if !self.version_deltas.is_empty() {
5657 len += 1;
5658 }
5659 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionArchive", len)?;
5660 if let Some(v) = self.version.as_ref() {
5661 struct_ser.serialize_field("version", v)?;
5662 }
5663 if !self.version_deltas.is_empty() {
5664 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
5665 }
5666 struct_ser.end()
5667 }
5668}
5669impl<'de> serde::Deserialize<'de> for HummockVersionArchive {
5670 #[allow(deprecated)]
5671 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5672 where
5673 D: serde::Deserializer<'de>,
5674 {
5675 const FIELDS: &[&str] = &[
5676 "version",
5677 "version_deltas",
5678 "versionDeltas",
5679 ];
5680
5681 #[allow(clippy::enum_variant_names)]
5682 enum GeneratedField {
5683 Version,
5684 VersionDeltas,
5685 }
5686 impl<'de> serde::Deserialize<'de> for GeneratedField {
5687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5688 where
5689 D: serde::Deserializer<'de>,
5690 {
5691 struct GeneratedVisitor;
5692
5693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5694 type Value = GeneratedField;
5695
5696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5697 write!(formatter, "expected one of: {:?}", &FIELDS)
5698 }
5699
5700 #[allow(unused_variables)]
5701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5702 where
5703 E: serde::de::Error,
5704 {
5705 match value {
5706 "version" => Ok(GeneratedField::Version),
5707 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
5708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5709 }
5710 }
5711 }
5712 deserializer.deserialize_identifier(GeneratedVisitor)
5713 }
5714 }
5715 struct GeneratedVisitor;
5716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5717 type Value = HummockVersionArchive;
5718
5719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5720 formatter.write_str("struct hummock.HummockVersionArchive")
5721 }
5722
5723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionArchive, V::Error>
5724 where
5725 V: serde::de::MapAccess<'de>,
5726 {
5727 let mut version__ = None;
5728 let mut version_deltas__ = None;
5729 while let Some(k) = map_.next_key()? {
5730 match k {
5731 GeneratedField::Version => {
5732 if version__.is_some() {
5733 return Err(serde::de::Error::duplicate_field("version"));
5734 }
5735 version__ = map_.next_value()?;
5736 }
5737 GeneratedField::VersionDeltas => {
5738 if version_deltas__.is_some() {
5739 return Err(serde::de::Error::duplicate_field("versionDeltas"));
5740 }
5741 version_deltas__ = Some(map_.next_value()?);
5742 }
5743 }
5744 }
5745 Ok(HummockVersionArchive {
5746 version: version__,
5747 version_deltas: version_deltas__.unwrap_or_default(),
5748 })
5749 }
5750 }
5751 deserializer.deserialize_struct("hummock.HummockVersionArchive", FIELDS, GeneratedVisitor)
5752 }
5753}
5754impl serde::Serialize for HummockVersionCheckpoint {
5755 #[allow(deprecated)]
5756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5757 where
5758 S: serde::Serializer,
5759 {
5760 use serde::ser::SerializeStruct;
5761 let mut len = 0;
5762 if self.version.is_some() {
5763 len += 1;
5764 }
5765 if !self.stale_objects.is_empty() {
5766 len += 1;
5767 }
5768 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint", len)?;
5769 if let Some(v) = self.version.as_ref() {
5770 struct_ser.serialize_field("version", v)?;
5771 }
5772 if !self.stale_objects.is_empty() {
5773 struct_ser.serialize_field("staleObjects", &self.stale_objects)?;
5774 }
5775 struct_ser.end()
5776 }
5777}
5778impl<'de> serde::Deserialize<'de> for HummockVersionCheckpoint {
5779 #[allow(deprecated)]
5780 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5781 where
5782 D: serde::Deserializer<'de>,
5783 {
5784 const FIELDS: &[&str] = &[
5785 "version",
5786 "stale_objects",
5787 "staleObjects",
5788 ];
5789
5790 #[allow(clippy::enum_variant_names)]
5791 enum GeneratedField {
5792 Version,
5793 StaleObjects,
5794 }
5795 impl<'de> serde::Deserialize<'de> for GeneratedField {
5796 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5797 where
5798 D: serde::Deserializer<'de>,
5799 {
5800 struct GeneratedVisitor;
5801
5802 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5803 type Value = GeneratedField;
5804
5805 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5806 write!(formatter, "expected one of: {:?}", &FIELDS)
5807 }
5808
5809 #[allow(unused_variables)]
5810 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5811 where
5812 E: serde::de::Error,
5813 {
5814 match value {
5815 "version" => Ok(GeneratedField::Version),
5816 "staleObjects" | "stale_objects" => Ok(GeneratedField::StaleObjects),
5817 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5818 }
5819 }
5820 }
5821 deserializer.deserialize_identifier(GeneratedVisitor)
5822 }
5823 }
5824 struct GeneratedVisitor;
5825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5826 type Value = HummockVersionCheckpoint;
5827
5828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5829 formatter.write_str("struct hummock.HummockVersionCheckpoint")
5830 }
5831
5832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpoint, V::Error>
5833 where
5834 V: serde::de::MapAccess<'de>,
5835 {
5836 let mut version__ = None;
5837 let mut stale_objects__ = None;
5838 while let Some(k) = map_.next_key()? {
5839 match k {
5840 GeneratedField::Version => {
5841 if version__.is_some() {
5842 return Err(serde::de::Error::duplicate_field("version"));
5843 }
5844 version__ = map_.next_value()?;
5845 }
5846 GeneratedField::StaleObjects => {
5847 if stale_objects__.is_some() {
5848 return Err(serde::de::Error::duplicate_field("staleObjects"));
5849 }
5850 stale_objects__ = Some(
5851 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
5852 .into_iter().map(|(k,v)| (k.0, v)).collect()
5853 );
5854 }
5855 }
5856 }
5857 Ok(HummockVersionCheckpoint {
5858 version: version__,
5859 stale_objects: stale_objects__.unwrap_or_default(),
5860 })
5861 }
5862 }
5863 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint", FIELDS, GeneratedVisitor)
5864 }
5865}
5866impl serde::Serialize for hummock_version_checkpoint::StaleObjects {
5867 #[allow(deprecated)]
5868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5869 where
5870 S: serde::Serializer,
5871 {
5872 use serde::ser::SerializeStruct;
5873 let mut len = 0;
5874 if !self.id.is_empty() {
5875 len += 1;
5876 }
5877 if self.total_file_size != 0 {
5878 len += 1;
5879 }
5880 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", len)?;
5881 if !self.id.is_empty() {
5882 struct_ser.serialize_field("id", &self.id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
5883 }
5884 if self.total_file_size != 0 {
5885 #[allow(clippy::needless_borrow)]
5886 #[allow(clippy::needless_borrows_for_generic_args)]
5887 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
5888 }
5889 struct_ser.end()
5890 }
5891}
5892impl<'de> serde::Deserialize<'de> for hummock_version_checkpoint::StaleObjects {
5893 #[allow(deprecated)]
5894 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5895 where
5896 D: serde::Deserializer<'de>,
5897 {
5898 const FIELDS: &[&str] = &[
5899 "id",
5900 "total_file_size",
5901 "totalFileSize",
5902 ];
5903
5904 #[allow(clippy::enum_variant_names)]
5905 enum GeneratedField {
5906 Id,
5907 TotalFileSize,
5908 }
5909 impl<'de> serde::Deserialize<'de> for GeneratedField {
5910 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5911 where
5912 D: serde::Deserializer<'de>,
5913 {
5914 struct GeneratedVisitor;
5915
5916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5917 type Value = GeneratedField;
5918
5919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5920 write!(formatter, "expected one of: {:?}", &FIELDS)
5921 }
5922
5923 #[allow(unused_variables)]
5924 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5925 where
5926 E: serde::de::Error,
5927 {
5928 match value {
5929 "id" => Ok(GeneratedField::Id),
5930 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
5931 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5932 }
5933 }
5934 }
5935 deserializer.deserialize_identifier(GeneratedVisitor)
5936 }
5937 }
5938 struct GeneratedVisitor;
5939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5940 type Value = hummock_version_checkpoint::StaleObjects;
5941
5942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5943 formatter.write_str("struct hummock.HummockVersionCheckpoint.StaleObjects")
5944 }
5945
5946 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_checkpoint::StaleObjects, V::Error>
5947 where
5948 V: serde::de::MapAccess<'de>,
5949 {
5950 let mut id__ = None;
5951 let mut total_file_size__ = None;
5952 while let Some(k) = map_.next_key()? {
5953 match k {
5954 GeneratedField::Id => {
5955 if id__.is_some() {
5956 return Err(serde::de::Error::duplicate_field("id"));
5957 }
5958 id__ =
5959 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5960 .into_iter().map(|x| x.0).collect())
5961 ;
5962 }
5963 GeneratedField::TotalFileSize => {
5964 if total_file_size__.is_some() {
5965 return Err(serde::de::Error::duplicate_field("totalFileSize"));
5966 }
5967 total_file_size__ =
5968 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5969 ;
5970 }
5971 }
5972 }
5973 Ok(hummock_version_checkpoint::StaleObjects {
5974 id: id__.unwrap_or_default(),
5975 total_file_size: total_file_size__.unwrap_or_default(),
5976 })
5977 }
5978 }
5979 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", FIELDS, GeneratedVisitor)
5980 }
5981}
5982impl serde::Serialize for HummockVersionDelta {
5983 #[allow(deprecated)]
5984 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5985 where
5986 S: serde::Serializer,
5987 {
5988 use serde::ser::SerializeStruct;
5989 let mut len = 0;
5990 if self.id != 0 {
5991 len += 1;
5992 }
5993 if self.prev_id != 0 {
5994 len += 1;
5995 }
5996 if !self.group_deltas.is_empty() {
5997 len += 1;
5998 }
5999 if self.max_committed_epoch != 0 {
6000 len += 1;
6001 }
6002 if self.trivial_move {
6003 len += 1;
6004 }
6005 if !self.new_table_watermarks.is_empty() {
6006 len += 1;
6007 }
6008 if !self.removed_table_ids.is_empty() {
6009 len += 1;
6010 }
6011 if !self.change_log_delta.is_empty() {
6012 len += 1;
6013 }
6014 if !self.state_table_info_delta.is_empty() {
6015 len += 1;
6016 }
6017 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta", len)?;
6018 if self.id != 0 {
6019 #[allow(clippy::needless_borrow)]
6020 #[allow(clippy::needless_borrows_for_generic_args)]
6021 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6022 }
6023 if self.prev_id != 0 {
6024 #[allow(clippy::needless_borrow)]
6025 #[allow(clippy::needless_borrows_for_generic_args)]
6026 struct_ser.serialize_field("prevId", ToString::to_string(&self.prev_id).as_str())?;
6027 }
6028 if !self.group_deltas.is_empty() {
6029 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
6030 }
6031 if self.max_committed_epoch != 0 {
6032 #[allow(clippy::needless_borrow)]
6033 #[allow(clippy::needless_borrows_for_generic_args)]
6034 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
6035 }
6036 if self.trivial_move {
6037 struct_ser.serialize_field("trivialMove", &self.trivial_move)?;
6038 }
6039 if !self.new_table_watermarks.is_empty() {
6040 struct_ser.serialize_field("newTableWatermarks", &self.new_table_watermarks)?;
6041 }
6042 if !self.removed_table_ids.is_empty() {
6043 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids)?;
6044 }
6045 if !self.change_log_delta.is_empty() {
6046 struct_ser.serialize_field("changeLogDelta", &self.change_log_delta)?;
6047 }
6048 if !self.state_table_info_delta.is_empty() {
6049 struct_ser.serialize_field("stateTableInfoDelta", &self.state_table_info_delta)?;
6050 }
6051 struct_ser.end()
6052 }
6053}
6054impl<'de> serde::Deserialize<'de> for HummockVersionDelta {
6055 #[allow(deprecated)]
6056 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6057 where
6058 D: serde::Deserializer<'de>,
6059 {
6060 const FIELDS: &[&str] = &[
6061 "id",
6062 "prev_id",
6063 "prevId",
6064 "group_deltas",
6065 "groupDeltas",
6066 "max_committed_epoch",
6067 "maxCommittedEpoch",
6068 "trivial_move",
6069 "trivialMove",
6070 "new_table_watermarks",
6071 "newTableWatermarks",
6072 "removed_table_ids",
6073 "removedTableIds",
6074 "change_log_delta",
6075 "changeLogDelta",
6076 "state_table_info_delta",
6077 "stateTableInfoDelta",
6078 ];
6079
6080 #[allow(clippy::enum_variant_names)]
6081 enum GeneratedField {
6082 Id,
6083 PrevId,
6084 GroupDeltas,
6085 MaxCommittedEpoch,
6086 TrivialMove,
6087 NewTableWatermarks,
6088 RemovedTableIds,
6089 ChangeLogDelta,
6090 StateTableInfoDelta,
6091 }
6092 impl<'de> serde::Deserialize<'de> for GeneratedField {
6093 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6094 where
6095 D: serde::Deserializer<'de>,
6096 {
6097 struct GeneratedVisitor;
6098
6099 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6100 type Value = GeneratedField;
6101
6102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6103 write!(formatter, "expected one of: {:?}", &FIELDS)
6104 }
6105
6106 #[allow(unused_variables)]
6107 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6108 where
6109 E: serde::de::Error,
6110 {
6111 match value {
6112 "id" => Ok(GeneratedField::Id),
6113 "prevId" | "prev_id" => Ok(GeneratedField::PrevId),
6114 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
6115 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
6116 "trivialMove" | "trivial_move" => Ok(GeneratedField::TrivialMove),
6117 "newTableWatermarks" | "new_table_watermarks" => Ok(GeneratedField::NewTableWatermarks),
6118 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
6119 "changeLogDelta" | "change_log_delta" => Ok(GeneratedField::ChangeLogDelta),
6120 "stateTableInfoDelta" | "state_table_info_delta" => Ok(GeneratedField::StateTableInfoDelta),
6121 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6122 }
6123 }
6124 }
6125 deserializer.deserialize_identifier(GeneratedVisitor)
6126 }
6127 }
6128 struct GeneratedVisitor;
6129 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6130 type Value = HummockVersionDelta;
6131
6132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6133 formatter.write_str("struct hummock.HummockVersionDelta")
6134 }
6135
6136 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDelta, V::Error>
6137 where
6138 V: serde::de::MapAccess<'de>,
6139 {
6140 let mut id__ = None;
6141 let mut prev_id__ = None;
6142 let mut group_deltas__ = None;
6143 let mut max_committed_epoch__ = None;
6144 let mut trivial_move__ = None;
6145 let mut new_table_watermarks__ = None;
6146 let mut removed_table_ids__ = None;
6147 let mut change_log_delta__ = None;
6148 let mut state_table_info_delta__ = None;
6149 while let Some(k) = map_.next_key()? {
6150 match k {
6151 GeneratedField::Id => {
6152 if id__.is_some() {
6153 return Err(serde::de::Error::duplicate_field("id"));
6154 }
6155 id__ =
6156 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6157 ;
6158 }
6159 GeneratedField::PrevId => {
6160 if prev_id__.is_some() {
6161 return Err(serde::de::Error::duplicate_field("prevId"));
6162 }
6163 prev_id__ =
6164 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6165 ;
6166 }
6167 GeneratedField::GroupDeltas => {
6168 if group_deltas__.is_some() {
6169 return Err(serde::de::Error::duplicate_field("groupDeltas"));
6170 }
6171 group_deltas__ = Some(
6172 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6173 .into_iter().map(|(k,v)| (k.0, v)).collect()
6174 );
6175 }
6176 GeneratedField::MaxCommittedEpoch => {
6177 if max_committed_epoch__.is_some() {
6178 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
6179 }
6180 max_committed_epoch__ =
6181 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6182 ;
6183 }
6184 GeneratedField::TrivialMove => {
6185 if trivial_move__.is_some() {
6186 return Err(serde::de::Error::duplicate_field("trivialMove"));
6187 }
6188 trivial_move__ = Some(map_.next_value()?);
6189 }
6190 GeneratedField::NewTableWatermarks => {
6191 if new_table_watermarks__.is_some() {
6192 return Err(serde::de::Error::duplicate_field("newTableWatermarks"));
6193 }
6194 new_table_watermarks__ = Some(
6195 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6196 .into_iter().map(|(k,v)| (k.0, v)).collect()
6197 );
6198 }
6199 GeneratedField::RemovedTableIds => {
6200 if removed_table_ids__.is_some() {
6201 return Err(serde::de::Error::duplicate_field("removedTableIds"));
6202 }
6203 removed_table_ids__ =
6204 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6205 .into_iter().map(|x| x.0).collect())
6206 ;
6207 }
6208 GeneratedField::ChangeLogDelta => {
6209 if change_log_delta__.is_some() {
6210 return Err(serde::de::Error::duplicate_field("changeLogDelta"));
6211 }
6212 change_log_delta__ = Some(
6213 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6214 .into_iter().map(|(k,v)| (k.0, v)).collect()
6215 );
6216 }
6217 GeneratedField::StateTableInfoDelta => {
6218 if state_table_info_delta__.is_some() {
6219 return Err(serde::de::Error::duplicate_field("stateTableInfoDelta"));
6220 }
6221 state_table_info_delta__ = Some(
6222 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6223 .into_iter().map(|(k,v)| (k.0, v)).collect()
6224 );
6225 }
6226 }
6227 }
6228 Ok(HummockVersionDelta {
6229 id: id__.unwrap_or_default(),
6230 prev_id: prev_id__.unwrap_or_default(),
6231 group_deltas: group_deltas__.unwrap_or_default(),
6232 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
6233 trivial_move: trivial_move__.unwrap_or_default(),
6234 new_table_watermarks: new_table_watermarks__.unwrap_or_default(),
6235 removed_table_ids: removed_table_ids__.unwrap_or_default(),
6236 change_log_delta: change_log_delta__.unwrap_or_default(),
6237 state_table_info_delta: state_table_info_delta__.unwrap_or_default(),
6238 })
6239 }
6240 }
6241 deserializer.deserialize_struct("hummock.HummockVersionDelta", FIELDS, GeneratedVisitor)
6242 }
6243}
6244impl serde::Serialize for hummock_version_delta::ChangeLogDelta {
6245 #[allow(deprecated)]
6246 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6247 where
6248 S: serde::Serializer,
6249 {
6250 use serde::ser::SerializeStruct;
6251 let mut len = 0;
6252 if self.new_log.is_some() {
6253 len += 1;
6254 }
6255 if self.truncate_epoch != 0 {
6256 len += 1;
6257 }
6258 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", len)?;
6259 if let Some(v) = self.new_log.as_ref() {
6260 struct_ser.serialize_field("newLog", v)?;
6261 }
6262 if self.truncate_epoch != 0 {
6263 #[allow(clippy::needless_borrow)]
6264 #[allow(clippy::needless_borrows_for_generic_args)]
6265 struct_ser.serialize_field("truncateEpoch", ToString::to_string(&self.truncate_epoch).as_str())?;
6266 }
6267 struct_ser.end()
6268 }
6269}
6270impl<'de> serde::Deserialize<'de> for hummock_version_delta::ChangeLogDelta {
6271 #[allow(deprecated)]
6272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6273 where
6274 D: serde::Deserializer<'de>,
6275 {
6276 const FIELDS: &[&str] = &[
6277 "new_log",
6278 "newLog",
6279 "truncate_epoch",
6280 "truncateEpoch",
6281 ];
6282
6283 #[allow(clippy::enum_variant_names)]
6284 enum GeneratedField {
6285 NewLog,
6286 TruncateEpoch,
6287 }
6288 impl<'de> serde::Deserialize<'de> for GeneratedField {
6289 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6290 where
6291 D: serde::Deserializer<'de>,
6292 {
6293 struct GeneratedVisitor;
6294
6295 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6296 type Value = GeneratedField;
6297
6298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6299 write!(formatter, "expected one of: {:?}", &FIELDS)
6300 }
6301
6302 #[allow(unused_variables)]
6303 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6304 where
6305 E: serde::de::Error,
6306 {
6307 match value {
6308 "newLog" | "new_log" => Ok(GeneratedField::NewLog),
6309 "truncateEpoch" | "truncate_epoch" => Ok(GeneratedField::TruncateEpoch),
6310 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6311 }
6312 }
6313 }
6314 deserializer.deserialize_identifier(GeneratedVisitor)
6315 }
6316 }
6317 struct GeneratedVisitor;
6318 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6319 type Value = hummock_version_delta::ChangeLogDelta;
6320
6321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6322 formatter.write_str("struct hummock.HummockVersionDelta.ChangeLogDelta")
6323 }
6324
6325 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::ChangeLogDelta, V::Error>
6326 where
6327 V: serde::de::MapAccess<'de>,
6328 {
6329 let mut new_log__ = None;
6330 let mut truncate_epoch__ = None;
6331 while let Some(k) = map_.next_key()? {
6332 match k {
6333 GeneratedField::NewLog => {
6334 if new_log__.is_some() {
6335 return Err(serde::de::Error::duplicate_field("newLog"));
6336 }
6337 new_log__ = map_.next_value()?;
6338 }
6339 GeneratedField::TruncateEpoch => {
6340 if truncate_epoch__.is_some() {
6341 return Err(serde::de::Error::duplicate_field("truncateEpoch"));
6342 }
6343 truncate_epoch__ =
6344 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6345 ;
6346 }
6347 }
6348 }
6349 Ok(hummock_version_delta::ChangeLogDelta {
6350 new_log: new_log__,
6351 truncate_epoch: truncate_epoch__.unwrap_or_default(),
6352 })
6353 }
6354 }
6355 deserializer.deserialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", FIELDS, GeneratedVisitor)
6356 }
6357}
6358impl serde::Serialize for hummock_version_delta::GroupDeltas {
6359 #[allow(deprecated)]
6360 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6361 where
6362 S: serde::Serializer,
6363 {
6364 use serde::ser::SerializeStruct;
6365 let mut len = 0;
6366 if !self.group_deltas.is_empty() {
6367 len += 1;
6368 }
6369 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.GroupDeltas", len)?;
6370 if !self.group_deltas.is_empty() {
6371 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
6372 }
6373 struct_ser.end()
6374 }
6375}
6376impl<'de> serde::Deserialize<'de> for hummock_version_delta::GroupDeltas {
6377 #[allow(deprecated)]
6378 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6379 where
6380 D: serde::Deserializer<'de>,
6381 {
6382 const FIELDS: &[&str] = &[
6383 "group_deltas",
6384 "groupDeltas",
6385 ];
6386
6387 #[allow(clippy::enum_variant_names)]
6388 enum GeneratedField {
6389 GroupDeltas,
6390 }
6391 impl<'de> serde::Deserialize<'de> for GeneratedField {
6392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6393 where
6394 D: serde::Deserializer<'de>,
6395 {
6396 struct GeneratedVisitor;
6397
6398 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6399 type Value = GeneratedField;
6400
6401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6402 write!(formatter, "expected one of: {:?}", &FIELDS)
6403 }
6404
6405 #[allow(unused_variables)]
6406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6407 where
6408 E: serde::de::Error,
6409 {
6410 match value {
6411 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
6412 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6413 }
6414 }
6415 }
6416 deserializer.deserialize_identifier(GeneratedVisitor)
6417 }
6418 }
6419 struct GeneratedVisitor;
6420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6421 type Value = hummock_version_delta::GroupDeltas;
6422
6423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6424 formatter.write_str("struct hummock.HummockVersionDelta.GroupDeltas")
6425 }
6426
6427 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::GroupDeltas, V::Error>
6428 where
6429 V: serde::de::MapAccess<'de>,
6430 {
6431 let mut group_deltas__ = None;
6432 while let Some(k) = map_.next_key()? {
6433 match k {
6434 GeneratedField::GroupDeltas => {
6435 if group_deltas__.is_some() {
6436 return Err(serde::de::Error::duplicate_field("groupDeltas"));
6437 }
6438 group_deltas__ = Some(map_.next_value()?);
6439 }
6440 }
6441 }
6442 Ok(hummock_version_delta::GroupDeltas {
6443 group_deltas: group_deltas__.unwrap_or_default(),
6444 })
6445 }
6446 }
6447 deserializer.deserialize_struct("hummock.HummockVersionDelta.GroupDeltas", FIELDS, GeneratedVisitor)
6448 }
6449}
6450impl serde::Serialize for HummockVersionDeltas {
6451 #[allow(deprecated)]
6452 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6453 where
6454 S: serde::Serializer,
6455 {
6456 use serde::ser::SerializeStruct;
6457 let mut len = 0;
6458 if !self.version_deltas.is_empty() {
6459 len += 1;
6460 }
6461 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDeltas", len)?;
6462 if !self.version_deltas.is_empty() {
6463 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
6464 }
6465 struct_ser.end()
6466 }
6467}
6468impl<'de> serde::Deserialize<'de> for HummockVersionDeltas {
6469 #[allow(deprecated)]
6470 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6471 where
6472 D: serde::Deserializer<'de>,
6473 {
6474 const FIELDS: &[&str] = &[
6475 "version_deltas",
6476 "versionDeltas",
6477 ];
6478
6479 #[allow(clippy::enum_variant_names)]
6480 enum GeneratedField {
6481 VersionDeltas,
6482 }
6483 impl<'de> serde::Deserialize<'de> for GeneratedField {
6484 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6485 where
6486 D: serde::Deserializer<'de>,
6487 {
6488 struct GeneratedVisitor;
6489
6490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6491 type Value = GeneratedField;
6492
6493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6494 write!(formatter, "expected one of: {:?}", &FIELDS)
6495 }
6496
6497 #[allow(unused_variables)]
6498 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6499 where
6500 E: serde::de::Error,
6501 {
6502 match value {
6503 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
6504 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6505 }
6506 }
6507 }
6508 deserializer.deserialize_identifier(GeneratedVisitor)
6509 }
6510 }
6511 struct GeneratedVisitor;
6512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6513 type Value = HummockVersionDeltas;
6514
6515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6516 formatter.write_str("struct hummock.HummockVersionDeltas")
6517 }
6518
6519 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDeltas, V::Error>
6520 where
6521 V: serde::de::MapAccess<'de>,
6522 {
6523 let mut version_deltas__ = None;
6524 while let Some(k) = map_.next_key()? {
6525 match k {
6526 GeneratedField::VersionDeltas => {
6527 if version_deltas__.is_some() {
6528 return Err(serde::de::Error::duplicate_field("versionDeltas"));
6529 }
6530 version_deltas__ = Some(map_.next_value()?);
6531 }
6532 }
6533 }
6534 Ok(HummockVersionDeltas {
6535 version_deltas: version_deltas__.unwrap_or_default(),
6536 })
6537 }
6538 }
6539 deserializer.deserialize_struct("hummock.HummockVersionDeltas", FIELDS, GeneratedVisitor)
6540 }
6541}
6542impl serde::Serialize for HummockVersionStats {
6543 #[allow(deprecated)]
6544 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6545 where
6546 S: serde::Serializer,
6547 {
6548 use serde::ser::SerializeStruct;
6549 let mut len = 0;
6550 if self.hummock_version_id != 0 {
6551 len += 1;
6552 }
6553 if !self.table_stats.is_empty() {
6554 len += 1;
6555 }
6556 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionStats", len)?;
6557 if self.hummock_version_id != 0 {
6558 #[allow(clippy::needless_borrow)]
6559 #[allow(clippy::needless_borrows_for_generic_args)]
6560 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
6561 }
6562 if !self.table_stats.is_empty() {
6563 struct_ser.serialize_field("tableStats", &self.table_stats)?;
6564 }
6565 struct_ser.end()
6566 }
6567}
6568impl<'de> serde::Deserialize<'de> for HummockVersionStats {
6569 #[allow(deprecated)]
6570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6571 where
6572 D: serde::Deserializer<'de>,
6573 {
6574 const FIELDS: &[&str] = &[
6575 "hummock_version_id",
6576 "hummockVersionId",
6577 "table_stats",
6578 "tableStats",
6579 ];
6580
6581 #[allow(clippy::enum_variant_names)]
6582 enum GeneratedField {
6583 HummockVersionId,
6584 TableStats,
6585 }
6586 impl<'de> serde::Deserialize<'de> for GeneratedField {
6587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6588 where
6589 D: serde::Deserializer<'de>,
6590 {
6591 struct GeneratedVisitor;
6592
6593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6594 type Value = GeneratedField;
6595
6596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6597 write!(formatter, "expected one of: {:?}", &FIELDS)
6598 }
6599
6600 #[allow(unused_variables)]
6601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6602 where
6603 E: serde::de::Error,
6604 {
6605 match value {
6606 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
6607 "tableStats" | "table_stats" => Ok(GeneratedField::TableStats),
6608 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6609 }
6610 }
6611 }
6612 deserializer.deserialize_identifier(GeneratedVisitor)
6613 }
6614 }
6615 struct GeneratedVisitor;
6616 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6617 type Value = HummockVersionStats;
6618
6619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6620 formatter.write_str("struct hummock.HummockVersionStats")
6621 }
6622
6623 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionStats, V::Error>
6624 where
6625 V: serde::de::MapAccess<'de>,
6626 {
6627 let mut hummock_version_id__ = None;
6628 let mut table_stats__ = None;
6629 while let Some(k) = map_.next_key()? {
6630 match k {
6631 GeneratedField::HummockVersionId => {
6632 if hummock_version_id__.is_some() {
6633 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
6634 }
6635 hummock_version_id__ =
6636 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6637 ;
6638 }
6639 GeneratedField::TableStats => {
6640 if table_stats__.is_some() {
6641 return Err(serde::de::Error::duplicate_field("tableStats"));
6642 }
6643 table_stats__ = Some(
6644 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6645 .into_iter().map(|(k,v)| (k.0, v)).collect()
6646 );
6647 }
6648 }
6649 }
6650 Ok(HummockVersionStats {
6651 hummock_version_id: hummock_version_id__.unwrap_or_default(),
6652 table_stats: table_stats__.unwrap_or_default(),
6653 })
6654 }
6655 }
6656 deserializer.deserialize_struct("hummock.HummockVersionStats", FIELDS, GeneratedVisitor)
6657 }
6658}
6659impl serde::Serialize for InitMetadataForReplayRequest {
6660 #[allow(deprecated)]
6661 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6662 where
6663 S: serde::Serializer,
6664 {
6665 use serde::ser::SerializeStruct;
6666 let mut len = 0;
6667 if !self.tables.is_empty() {
6668 len += 1;
6669 }
6670 if !self.compaction_groups.is_empty() {
6671 len += 1;
6672 }
6673 let mut struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayRequest", len)?;
6674 if !self.tables.is_empty() {
6675 struct_ser.serialize_field("tables", &self.tables)?;
6676 }
6677 if !self.compaction_groups.is_empty() {
6678 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
6679 }
6680 struct_ser.end()
6681 }
6682}
6683impl<'de> serde::Deserialize<'de> for InitMetadataForReplayRequest {
6684 #[allow(deprecated)]
6685 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6686 where
6687 D: serde::Deserializer<'de>,
6688 {
6689 const FIELDS: &[&str] = &[
6690 "tables",
6691 "compaction_groups",
6692 "compactionGroups",
6693 ];
6694
6695 #[allow(clippy::enum_variant_names)]
6696 enum GeneratedField {
6697 Tables,
6698 CompactionGroups,
6699 }
6700 impl<'de> serde::Deserialize<'de> for GeneratedField {
6701 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6702 where
6703 D: serde::Deserializer<'de>,
6704 {
6705 struct GeneratedVisitor;
6706
6707 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6708 type Value = GeneratedField;
6709
6710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6711 write!(formatter, "expected one of: {:?}", &FIELDS)
6712 }
6713
6714 #[allow(unused_variables)]
6715 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6716 where
6717 E: serde::de::Error,
6718 {
6719 match value {
6720 "tables" => Ok(GeneratedField::Tables),
6721 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
6722 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6723 }
6724 }
6725 }
6726 deserializer.deserialize_identifier(GeneratedVisitor)
6727 }
6728 }
6729 struct GeneratedVisitor;
6730 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6731 type Value = InitMetadataForReplayRequest;
6732
6733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6734 formatter.write_str("struct hummock.InitMetadataForReplayRequest")
6735 }
6736
6737 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayRequest, V::Error>
6738 where
6739 V: serde::de::MapAccess<'de>,
6740 {
6741 let mut tables__ = None;
6742 let mut compaction_groups__ = None;
6743 while let Some(k) = map_.next_key()? {
6744 match k {
6745 GeneratedField::Tables => {
6746 if tables__.is_some() {
6747 return Err(serde::de::Error::duplicate_field("tables"));
6748 }
6749 tables__ = Some(map_.next_value()?);
6750 }
6751 GeneratedField::CompactionGroups => {
6752 if compaction_groups__.is_some() {
6753 return Err(serde::de::Error::duplicate_field("compactionGroups"));
6754 }
6755 compaction_groups__ = Some(map_.next_value()?);
6756 }
6757 }
6758 }
6759 Ok(InitMetadataForReplayRequest {
6760 tables: tables__.unwrap_or_default(),
6761 compaction_groups: compaction_groups__.unwrap_or_default(),
6762 })
6763 }
6764 }
6765 deserializer.deserialize_struct("hummock.InitMetadataForReplayRequest", FIELDS, GeneratedVisitor)
6766 }
6767}
6768impl serde::Serialize for InitMetadataForReplayResponse {
6769 #[allow(deprecated)]
6770 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6771 where
6772 S: serde::Serializer,
6773 {
6774 use serde::ser::SerializeStruct;
6775 let len = 0;
6776 let struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayResponse", len)?;
6777 struct_ser.end()
6778 }
6779}
6780impl<'de> serde::Deserialize<'de> for InitMetadataForReplayResponse {
6781 #[allow(deprecated)]
6782 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6783 where
6784 D: serde::Deserializer<'de>,
6785 {
6786 const FIELDS: &[&str] = &[
6787 ];
6788
6789 #[allow(clippy::enum_variant_names)]
6790 enum GeneratedField {
6791 }
6792 impl<'de> serde::Deserialize<'de> for GeneratedField {
6793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6794 where
6795 D: serde::Deserializer<'de>,
6796 {
6797 struct GeneratedVisitor;
6798
6799 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6800 type Value = GeneratedField;
6801
6802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6803 write!(formatter, "expected one of: {:?}", &FIELDS)
6804 }
6805
6806 #[allow(unused_variables)]
6807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6808 where
6809 E: serde::de::Error,
6810 {
6811 Err(serde::de::Error::unknown_field(value, FIELDS))
6812 }
6813 }
6814 deserializer.deserialize_identifier(GeneratedVisitor)
6815 }
6816 }
6817 struct GeneratedVisitor;
6818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6819 type Value = InitMetadataForReplayResponse;
6820
6821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6822 formatter.write_str("struct hummock.InitMetadataForReplayResponse")
6823 }
6824
6825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayResponse, V::Error>
6826 where
6827 V: serde::de::MapAccess<'de>,
6828 {
6829 while map_.next_key::<GeneratedField>()?.is_some() {
6830 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6831 }
6832 Ok(InitMetadataForReplayResponse {
6833 })
6834 }
6835 }
6836 deserializer.deserialize_struct("hummock.InitMetadataForReplayResponse", FIELDS, GeneratedVisitor)
6837 }
6838}
6839impl serde::Serialize for InputLevel {
6840 #[allow(deprecated)]
6841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6842 where
6843 S: serde::Serializer,
6844 {
6845 use serde::ser::SerializeStruct;
6846 let mut len = 0;
6847 if self.level_idx != 0 {
6848 len += 1;
6849 }
6850 if self.level_type != 0 {
6851 len += 1;
6852 }
6853 if !self.table_infos.is_empty() {
6854 len += 1;
6855 }
6856 let mut struct_ser = serializer.serialize_struct("hummock.InputLevel", len)?;
6857 if self.level_idx != 0 {
6858 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
6859 }
6860 if self.level_type != 0 {
6861 let v = LevelType::try_from(self.level_type)
6862 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
6863 struct_ser.serialize_field("levelType", &v)?;
6864 }
6865 if !self.table_infos.is_empty() {
6866 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
6867 }
6868 struct_ser.end()
6869 }
6870}
6871impl<'de> serde::Deserialize<'de> for InputLevel {
6872 #[allow(deprecated)]
6873 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6874 where
6875 D: serde::Deserializer<'de>,
6876 {
6877 const FIELDS: &[&str] = &[
6878 "level_idx",
6879 "levelIdx",
6880 "level_type",
6881 "levelType",
6882 "table_infos",
6883 "tableInfos",
6884 ];
6885
6886 #[allow(clippy::enum_variant_names)]
6887 enum GeneratedField {
6888 LevelIdx,
6889 LevelType,
6890 TableInfos,
6891 }
6892 impl<'de> serde::Deserialize<'de> for GeneratedField {
6893 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6894 where
6895 D: serde::Deserializer<'de>,
6896 {
6897 struct GeneratedVisitor;
6898
6899 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6900 type Value = GeneratedField;
6901
6902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6903 write!(formatter, "expected one of: {:?}", &FIELDS)
6904 }
6905
6906 #[allow(unused_variables)]
6907 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6908 where
6909 E: serde::de::Error,
6910 {
6911 match value {
6912 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
6913 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
6914 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
6915 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6916 }
6917 }
6918 }
6919 deserializer.deserialize_identifier(GeneratedVisitor)
6920 }
6921 }
6922 struct GeneratedVisitor;
6923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6924 type Value = InputLevel;
6925
6926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6927 formatter.write_str("struct hummock.InputLevel")
6928 }
6929
6930 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputLevel, V::Error>
6931 where
6932 V: serde::de::MapAccess<'de>,
6933 {
6934 let mut level_idx__ = None;
6935 let mut level_type__ = None;
6936 let mut table_infos__ = None;
6937 while let Some(k) = map_.next_key()? {
6938 match k {
6939 GeneratedField::LevelIdx => {
6940 if level_idx__.is_some() {
6941 return Err(serde::de::Error::duplicate_field("levelIdx"));
6942 }
6943 level_idx__ =
6944 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6945 ;
6946 }
6947 GeneratedField::LevelType => {
6948 if level_type__.is_some() {
6949 return Err(serde::de::Error::duplicate_field("levelType"));
6950 }
6951 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
6952 }
6953 GeneratedField::TableInfos => {
6954 if table_infos__.is_some() {
6955 return Err(serde::de::Error::duplicate_field("tableInfos"));
6956 }
6957 table_infos__ = Some(map_.next_value()?);
6958 }
6959 }
6960 }
6961 Ok(InputLevel {
6962 level_idx: level_idx__.unwrap_or_default(),
6963 level_type: level_type__.unwrap_or_default(),
6964 table_infos: table_infos__.unwrap_or_default(),
6965 })
6966 }
6967 }
6968 deserializer.deserialize_struct("hummock.InputLevel", FIELDS, GeneratedVisitor)
6969 }
6970}
6971impl serde::Serialize for IntraLevelDelta {
6972 #[allow(deprecated)]
6973 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6974 where
6975 S: serde::Serializer,
6976 {
6977 use serde::ser::SerializeStruct;
6978 let mut len = 0;
6979 if self.level_idx != 0 {
6980 len += 1;
6981 }
6982 if self.l0_sub_level_id != 0 {
6983 len += 1;
6984 }
6985 if !self.removed_table_ids.is_empty() {
6986 len += 1;
6987 }
6988 if !self.inserted_table_infos.is_empty() {
6989 len += 1;
6990 }
6991 if self.vnode_partition_count != 0 {
6992 len += 1;
6993 }
6994 if self.compaction_group_version_id != 0 {
6995 len += 1;
6996 }
6997 let mut struct_ser = serializer.serialize_struct("hummock.IntraLevelDelta", len)?;
6998 if self.level_idx != 0 {
6999 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7000 }
7001 if self.l0_sub_level_id != 0 {
7002 #[allow(clippy::needless_borrow)]
7003 #[allow(clippy::needless_borrows_for_generic_args)]
7004 struct_ser.serialize_field("l0SubLevelId", ToString::to_string(&self.l0_sub_level_id).as_str())?;
7005 }
7006 if !self.removed_table_ids.is_empty() {
7007 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
7008 }
7009 if !self.inserted_table_infos.is_empty() {
7010 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
7011 }
7012 if self.vnode_partition_count != 0 {
7013 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
7014 }
7015 if self.compaction_group_version_id != 0 {
7016 #[allow(clippy::needless_borrow)]
7017 #[allow(clippy::needless_borrows_for_generic_args)]
7018 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
7019 }
7020 struct_ser.end()
7021 }
7022}
7023impl<'de> serde::Deserialize<'de> for IntraLevelDelta {
7024 #[allow(deprecated)]
7025 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7026 where
7027 D: serde::Deserializer<'de>,
7028 {
7029 const FIELDS: &[&str] = &[
7030 "level_idx",
7031 "levelIdx",
7032 "l0_sub_level_id",
7033 "l0SubLevelId",
7034 "removed_table_ids",
7035 "removedTableIds",
7036 "inserted_table_infos",
7037 "insertedTableInfos",
7038 "vnode_partition_count",
7039 "vnodePartitionCount",
7040 "compaction_group_version_id",
7041 "compactionGroupVersionId",
7042 ];
7043
7044 #[allow(clippy::enum_variant_names)]
7045 enum GeneratedField {
7046 LevelIdx,
7047 L0SubLevelId,
7048 RemovedTableIds,
7049 InsertedTableInfos,
7050 VnodePartitionCount,
7051 CompactionGroupVersionId,
7052 }
7053 impl<'de> serde::Deserialize<'de> for GeneratedField {
7054 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7055 where
7056 D: serde::Deserializer<'de>,
7057 {
7058 struct GeneratedVisitor;
7059
7060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7061 type Value = GeneratedField;
7062
7063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7064 write!(formatter, "expected one of: {:?}", &FIELDS)
7065 }
7066
7067 #[allow(unused_variables)]
7068 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7069 where
7070 E: serde::de::Error,
7071 {
7072 match value {
7073 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7074 "l0SubLevelId" | "l0_sub_level_id" => Ok(GeneratedField::L0SubLevelId),
7075 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
7076 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
7077 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
7078 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
7079 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7080 }
7081 }
7082 }
7083 deserializer.deserialize_identifier(GeneratedVisitor)
7084 }
7085 }
7086 struct GeneratedVisitor;
7087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7088 type Value = IntraLevelDelta;
7089
7090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7091 formatter.write_str("struct hummock.IntraLevelDelta")
7092 }
7093
7094 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntraLevelDelta, V::Error>
7095 where
7096 V: serde::de::MapAccess<'de>,
7097 {
7098 let mut level_idx__ = None;
7099 let mut l0_sub_level_id__ = None;
7100 let mut removed_table_ids__ = None;
7101 let mut inserted_table_infos__ = None;
7102 let mut vnode_partition_count__ = None;
7103 let mut compaction_group_version_id__ = None;
7104 while let Some(k) = map_.next_key()? {
7105 match k {
7106 GeneratedField::LevelIdx => {
7107 if level_idx__.is_some() {
7108 return Err(serde::de::Error::duplicate_field("levelIdx"));
7109 }
7110 level_idx__ =
7111 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7112 ;
7113 }
7114 GeneratedField::L0SubLevelId => {
7115 if l0_sub_level_id__.is_some() {
7116 return Err(serde::de::Error::duplicate_field("l0SubLevelId"));
7117 }
7118 l0_sub_level_id__ =
7119 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7120 ;
7121 }
7122 GeneratedField::RemovedTableIds => {
7123 if removed_table_ids__.is_some() {
7124 return Err(serde::de::Error::duplicate_field("removedTableIds"));
7125 }
7126 removed_table_ids__ =
7127 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7128 .into_iter().map(|x| x.0).collect())
7129 ;
7130 }
7131 GeneratedField::InsertedTableInfos => {
7132 if inserted_table_infos__.is_some() {
7133 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
7134 }
7135 inserted_table_infos__ = Some(map_.next_value()?);
7136 }
7137 GeneratedField::VnodePartitionCount => {
7138 if vnode_partition_count__.is_some() {
7139 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
7140 }
7141 vnode_partition_count__ =
7142 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7143 ;
7144 }
7145 GeneratedField::CompactionGroupVersionId => {
7146 if compaction_group_version_id__.is_some() {
7147 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
7148 }
7149 compaction_group_version_id__ =
7150 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7151 ;
7152 }
7153 }
7154 }
7155 Ok(IntraLevelDelta {
7156 level_idx: level_idx__.unwrap_or_default(),
7157 l0_sub_level_id: l0_sub_level_id__.unwrap_or_default(),
7158 removed_table_ids: removed_table_ids__.unwrap_or_default(),
7159 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
7160 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
7161 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
7162 })
7163 }
7164 }
7165 deserializer.deserialize_struct("hummock.IntraLevelDelta", FIELDS, GeneratedVisitor)
7166 }
7167}
7168impl serde::Serialize for KeyRange {
7169 #[allow(deprecated)]
7170 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7171 where
7172 S: serde::Serializer,
7173 {
7174 use serde::ser::SerializeStruct;
7175 let mut len = 0;
7176 if !self.left.is_empty() {
7177 len += 1;
7178 }
7179 if !self.right.is_empty() {
7180 len += 1;
7181 }
7182 if self.right_exclusive {
7183 len += 1;
7184 }
7185 let mut struct_ser = serializer.serialize_struct("hummock.KeyRange", len)?;
7186 if !self.left.is_empty() {
7187 #[allow(clippy::needless_borrow)]
7188 #[allow(clippy::needless_borrows_for_generic_args)]
7189 struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
7190 }
7191 if !self.right.is_empty() {
7192 #[allow(clippy::needless_borrow)]
7193 #[allow(clippy::needless_borrows_for_generic_args)]
7194 struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
7195 }
7196 if self.right_exclusive {
7197 struct_ser.serialize_field("rightExclusive", &self.right_exclusive)?;
7198 }
7199 struct_ser.end()
7200 }
7201}
7202impl<'de> serde::Deserialize<'de> for KeyRange {
7203 #[allow(deprecated)]
7204 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7205 where
7206 D: serde::Deserializer<'de>,
7207 {
7208 const FIELDS: &[&str] = &[
7209 "left",
7210 "right",
7211 "right_exclusive",
7212 "rightExclusive",
7213 ];
7214
7215 #[allow(clippy::enum_variant_names)]
7216 enum GeneratedField {
7217 Left,
7218 Right,
7219 RightExclusive,
7220 }
7221 impl<'de> serde::Deserialize<'de> for GeneratedField {
7222 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7223 where
7224 D: serde::Deserializer<'de>,
7225 {
7226 struct GeneratedVisitor;
7227
7228 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7229 type Value = GeneratedField;
7230
7231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7232 write!(formatter, "expected one of: {:?}", &FIELDS)
7233 }
7234
7235 #[allow(unused_variables)]
7236 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7237 where
7238 E: serde::de::Error,
7239 {
7240 match value {
7241 "left" => Ok(GeneratedField::Left),
7242 "right" => Ok(GeneratedField::Right),
7243 "rightExclusive" | "right_exclusive" => Ok(GeneratedField::RightExclusive),
7244 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7245 }
7246 }
7247 }
7248 deserializer.deserialize_identifier(GeneratedVisitor)
7249 }
7250 }
7251 struct GeneratedVisitor;
7252 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7253 type Value = KeyRange;
7254
7255 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7256 formatter.write_str("struct hummock.KeyRange")
7257 }
7258
7259 fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
7260 where
7261 V: serde::de::MapAccess<'de>,
7262 {
7263 let mut left__ = None;
7264 let mut right__ = None;
7265 let mut right_exclusive__ = None;
7266 while let Some(k) = map_.next_key()? {
7267 match k {
7268 GeneratedField::Left => {
7269 if left__.is_some() {
7270 return Err(serde::de::Error::duplicate_field("left"));
7271 }
7272 left__ =
7273 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7274 ;
7275 }
7276 GeneratedField::Right => {
7277 if right__.is_some() {
7278 return Err(serde::de::Error::duplicate_field("right"));
7279 }
7280 right__ =
7281 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7282 ;
7283 }
7284 GeneratedField::RightExclusive => {
7285 if right_exclusive__.is_some() {
7286 return Err(serde::de::Error::duplicate_field("rightExclusive"));
7287 }
7288 right_exclusive__ = Some(map_.next_value()?);
7289 }
7290 }
7291 }
7292 Ok(KeyRange {
7293 left: left__.unwrap_or_default(),
7294 right: right__.unwrap_or_default(),
7295 right_exclusive: right_exclusive__.unwrap_or_default(),
7296 })
7297 }
7298 }
7299 deserializer.deserialize_struct("hummock.KeyRange", FIELDS, GeneratedVisitor)
7300 }
7301}
7302impl serde::Serialize for Level {
7303 #[allow(deprecated)]
7304 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7305 where
7306 S: serde::Serializer,
7307 {
7308 use serde::ser::SerializeStruct;
7309 let mut len = 0;
7310 if self.level_idx != 0 {
7311 len += 1;
7312 }
7313 if self.level_type != 0 {
7314 len += 1;
7315 }
7316 if !self.table_infos.is_empty() {
7317 len += 1;
7318 }
7319 if self.total_file_size != 0 {
7320 len += 1;
7321 }
7322 if self.sub_level_id != 0 {
7323 len += 1;
7324 }
7325 if self.uncompressed_file_size != 0 {
7326 len += 1;
7327 }
7328 if self.vnode_partition_count != 0 {
7329 len += 1;
7330 }
7331 let mut struct_ser = serializer.serialize_struct("hummock.Level", len)?;
7332 if self.level_idx != 0 {
7333 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7334 }
7335 if self.level_type != 0 {
7336 let v = LevelType::try_from(self.level_type)
7337 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
7338 struct_ser.serialize_field("levelType", &v)?;
7339 }
7340 if !self.table_infos.is_empty() {
7341 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
7342 }
7343 if self.total_file_size != 0 {
7344 #[allow(clippy::needless_borrow)]
7345 #[allow(clippy::needless_borrows_for_generic_args)]
7346 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
7347 }
7348 if self.sub_level_id != 0 {
7349 #[allow(clippy::needless_borrow)]
7350 #[allow(clippy::needless_borrows_for_generic_args)]
7351 struct_ser.serialize_field("subLevelId", ToString::to_string(&self.sub_level_id).as_str())?;
7352 }
7353 if self.uncompressed_file_size != 0 {
7354 #[allow(clippy::needless_borrow)]
7355 #[allow(clippy::needless_borrows_for_generic_args)]
7356 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
7357 }
7358 if self.vnode_partition_count != 0 {
7359 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
7360 }
7361 struct_ser.end()
7362 }
7363}
7364impl<'de> serde::Deserialize<'de> for Level {
7365 #[allow(deprecated)]
7366 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7367 where
7368 D: serde::Deserializer<'de>,
7369 {
7370 const FIELDS: &[&str] = &[
7371 "level_idx",
7372 "levelIdx",
7373 "level_type",
7374 "levelType",
7375 "table_infos",
7376 "tableInfos",
7377 "total_file_size",
7378 "totalFileSize",
7379 "sub_level_id",
7380 "subLevelId",
7381 "uncompressed_file_size",
7382 "uncompressedFileSize",
7383 "vnode_partition_count",
7384 "vnodePartitionCount",
7385 ];
7386
7387 #[allow(clippy::enum_variant_names)]
7388 enum GeneratedField {
7389 LevelIdx,
7390 LevelType,
7391 TableInfos,
7392 TotalFileSize,
7393 SubLevelId,
7394 UncompressedFileSize,
7395 VnodePartitionCount,
7396 }
7397 impl<'de> serde::Deserialize<'de> for GeneratedField {
7398 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7399 where
7400 D: serde::Deserializer<'de>,
7401 {
7402 struct GeneratedVisitor;
7403
7404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7405 type Value = GeneratedField;
7406
7407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7408 write!(formatter, "expected one of: {:?}", &FIELDS)
7409 }
7410
7411 #[allow(unused_variables)]
7412 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7413 where
7414 E: serde::de::Error,
7415 {
7416 match value {
7417 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7418 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
7419 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
7420 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7421 "subLevelId" | "sub_level_id" => Ok(GeneratedField::SubLevelId),
7422 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
7423 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
7424 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7425 }
7426 }
7427 }
7428 deserializer.deserialize_identifier(GeneratedVisitor)
7429 }
7430 }
7431 struct GeneratedVisitor;
7432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7433 type Value = Level;
7434
7435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7436 formatter.write_str("struct hummock.Level")
7437 }
7438
7439 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Level, V::Error>
7440 where
7441 V: serde::de::MapAccess<'de>,
7442 {
7443 let mut level_idx__ = None;
7444 let mut level_type__ = None;
7445 let mut table_infos__ = None;
7446 let mut total_file_size__ = None;
7447 let mut sub_level_id__ = None;
7448 let mut uncompressed_file_size__ = None;
7449 let mut vnode_partition_count__ = None;
7450 while let Some(k) = map_.next_key()? {
7451 match k {
7452 GeneratedField::LevelIdx => {
7453 if level_idx__.is_some() {
7454 return Err(serde::de::Error::duplicate_field("levelIdx"));
7455 }
7456 level_idx__ =
7457 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7458 ;
7459 }
7460 GeneratedField::LevelType => {
7461 if level_type__.is_some() {
7462 return Err(serde::de::Error::duplicate_field("levelType"));
7463 }
7464 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
7465 }
7466 GeneratedField::TableInfos => {
7467 if table_infos__.is_some() {
7468 return Err(serde::de::Error::duplicate_field("tableInfos"));
7469 }
7470 table_infos__ = Some(map_.next_value()?);
7471 }
7472 GeneratedField::TotalFileSize => {
7473 if total_file_size__.is_some() {
7474 return Err(serde::de::Error::duplicate_field("totalFileSize"));
7475 }
7476 total_file_size__ =
7477 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7478 ;
7479 }
7480 GeneratedField::SubLevelId => {
7481 if sub_level_id__.is_some() {
7482 return Err(serde::de::Error::duplicate_field("subLevelId"));
7483 }
7484 sub_level_id__ =
7485 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7486 ;
7487 }
7488 GeneratedField::UncompressedFileSize => {
7489 if uncompressed_file_size__.is_some() {
7490 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
7491 }
7492 uncompressed_file_size__ =
7493 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7494 ;
7495 }
7496 GeneratedField::VnodePartitionCount => {
7497 if vnode_partition_count__.is_some() {
7498 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
7499 }
7500 vnode_partition_count__ =
7501 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7502 ;
7503 }
7504 }
7505 }
7506 Ok(Level {
7507 level_idx: level_idx__.unwrap_or_default(),
7508 level_type: level_type__.unwrap_or_default(),
7509 table_infos: table_infos__.unwrap_or_default(),
7510 total_file_size: total_file_size__.unwrap_or_default(),
7511 sub_level_id: sub_level_id__.unwrap_or_default(),
7512 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
7513 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
7514 })
7515 }
7516 }
7517 deserializer.deserialize_struct("hummock.Level", FIELDS, GeneratedVisitor)
7518 }
7519}
7520impl serde::Serialize for LevelHandler {
7521 #[allow(deprecated)]
7522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7523 where
7524 S: serde::Serializer,
7525 {
7526 use serde::ser::SerializeStruct;
7527 let mut len = 0;
7528 if self.level != 0 {
7529 len += 1;
7530 }
7531 if !self.tasks.is_empty() {
7532 len += 1;
7533 }
7534 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler", len)?;
7535 if self.level != 0 {
7536 struct_ser.serialize_field("level", &self.level)?;
7537 }
7538 if !self.tasks.is_empty() {
7539 struct_ser.serialize_field("tasks", &self.tasks)?;
7540 }
7541 struct_ser.end()
7542 }
7543}
7544impl<'de> serde::Deserialize<'de> for LevelHandler {
7545 #[allow(deprecated)]
7546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7547 where
7548 D: serde::Deserializer<'de>,
7549 {
7550 const FIELDS: &[&str] = &[
7551 "level",
7552 "tasks",
7553 ];
7554
7555 #[allow(clippy::enum_variant_names)]
7556 enum GeneratedField {
7557 Level,
7558 Tasks,
7559 }
7560 impl<'de> serde::Deserialize<'de> for GeneratedField {
7561 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7562 where
7563 D: serde::Deserializer<'de>,
7564 {
7565 struct GeneratedVisitor;
7566
7567 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7568 type Value = GeneratedField;
7569
7570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7571 write!(formatter, "expected one of: {:?}", &FIELDS)
7572 }
7573
7574 #[allow(unused_variables)]
7575 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7576 where
7577 E: serde::de::Error,
7578 {
7579 match value {
7580 "level" => Ok(GeneratedField::Level),
7581 "tasks" => Ok(GeneratedField::Tasks),
7582 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7583 }
7584 }
7585 }
7586 deserializer.deserialize_identifier(GeneratedVisitor)
7587 }
7588 }
7589 struct GeneratedVisitor;
7590 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7591 type Value = LevelHandler;
7592
7593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7594 formatter.write_str("struct hummock.LevelHandler")
7595 }
7596
7597 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LevelHandler, V::Error>
7598 where
7599 V: serde::de::MapAccess<'de>,
7600 {
7601 let mut level__ = None;
7602 let mut tasks__ = None;
7603 while let Some(k) = map_.next_key()? {
7604 match k {
7605 GeneratedField::Level => {
7606 if level__.is_some() {
7607 return Err(serde::de::Error::duplicate_field("level"));
7608 }
7609 level__ =
7610 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7611 ;
7612 }
7613 GeneratedField::Tasks => {
7614 if tasks__.is_some() {
7615 return Err(serde::de::Error::duplicate_field("tasks"));
7616 }
7617 tasks__ = Some(map_.next_value()?);
7618 }
7619 }
7620 }
7621 Ok(LevelHandler {
7622 level: level__.unwrap_or_default(),
7623 tasks: tasks__.unwrap_or_default(),
7624 })
7625 }
7626 }
7627 deserializer.deserialize_struct("hummock.LevelHandler", FIELDS, GeneratedVisitor)
7628 }
7629}
7630impl serde::Serialize for level_handler::RunningCompactTask {
7631 #[allow(deprecated)]
7632 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7633 where
7634 S: serde::Serializer,
7635 {
7636 use serde::ser::SerializeStruct;
7637 let mut len = 0;
7638 if self.task_id != 0 {
7639 len += 1;
7640 }
7641 if !self.ssts.is_empty() {
7642 len += 1;
7643 }
7644 if self.total_file_size != 0 {
7645 len += 1;
7646 }
7647 if self.target_level != 0 {
7648 len += 1;
7649 }
7650 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler.RunningCompactTask", len)?;
7651 if self.task_id != 0 {
7652 #[allow(clippy::needless_borrow)]
7653 #[allow(clippy::needless_borrows_for_generic_args)]
7654 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
7655 }
7656 if !self.ssts.is_empty() {
7657 struct_ser.serialize_field("ssts", &self.ssts.iter().map(ToString::to_string).collect::<Vec<_>>())?;
7658 }
7659 if self.total_file_size != 0 {
7660 #[allow(clippy::needless_borrow)]
7661 #[allow(clippy::needless_borrows_for_generic_args)]
7662 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
7663 }
7664 if self.target_level != 0 {
7665 struct_ser.serialize_field("targetLevel", &self.target_level)?;
7666 }
7667 struct_ser.end()
7668 }
7669}
7670impl<'de> serde::Deserialize<'de> for level_handler::RunningCompactTask {
7671 #[allow(deprecated)]
7672 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7673 where
7674 D: serde::Deserializer<'de>,
7675 {
7676 const FIELDS: &[&str] = &[
7677 "task_id",
7678 "taskId",
7679 "ssts",
7680 "total_file_size",
7681 "totalFileSize",
7682 "target_level",
7683 "targetLevel",
7684 ];
7685
7686 #[allow(clippy::enum_variant_names)]
7687 enum GeneratedField {
7688 TaskId,
7689 Ssts,
7690 TotalFileSize,
7691 TargetLevel,
7692 }
7693 impl<'de> serde::Deserialize<'de> for GeneratedField {
7694 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7695 where
7696 D: serde::Deserializer<'de>,
7697 {
7698 struct GeneratedVisitor;
7699
7700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7701 type Value = GeneratedField;
7702
7703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7704 write!(formatter, "expected one of: {:?}", &FIELDS)
7705 }
7706
7707 #[allow(unused_variables)]
7708 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7709 where
7710 E: serde::de::Error,
7711 {
7712 match value {
7713 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7714 "ssts" => Ok(GeneratedField::Ssts),
7715 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7716 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
7717 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7718 }
7719 }
7720 }
7721 deserializer.deserialize_identifier(GeneratedVisitor)
7722 }
7723 }
7724 struct GeneratedVisitor;
7725 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7726 type Value = level_handler::RunningCompactTask;
7727
7728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7729 formatter.write_str("struct hummock.LevelHandler.RunningCompactTask")
7730 }
7731
7732 fn visit_map<V>(self, mut map_: V) -> std::result::Result<level_handler::RunningCompactTask, V::Error>
7733 where
7734 V: serde::de::MapAccess<'de>,
7735 {
7736 let mut task_id__ = None;
7737 let mut ssts__ = None;
7738 let mut total_file_size__ = None;
7739 let mut target_level__ = None;
7740 while let Some(k) = map_.next_key()? {
7741 match k {
7742 GeneratedField::TaskId => {
7743 if task_id__.is_some() {
7744 return Err(serde::de::Error::duplicate_field("taskId"));
7745 }
7746 task_id__ =
7747 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7748 ;
7749 }
7750 GeneratedField::Ssts => {
7751 if ssts__.is_some() {
7752 return Err(serde::de::Error::duplicate_field("ssts"));
7753 }
7754 ssts__ =
7755 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7756 .into_iter().map(|x| x.0).collect())
7757 ;
7758 }
7759 GeneratedField::TotalFileSize => {
7760 if total_file_size__.is_some() {
7761 return Err(serde::de::Error::duplicate_field("totalFileSize"));
7762 }
7763 total_file_size__ =
7764 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7765 ;
7766 }
7767 GeneratedField::TargetLevel => {
7768 if target_level__.is_some() {
7769 return Err(serde::de::Error::duplicate_field("targetLevel"));
7770 }
7771 target_level__ =
7772 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7773 ;
7774 }
7775 }
7776 }
7777 Ok(level_handler::RunningCompactTask {
7778 task_id: task_id__.unwrap_or_default(),
7779 ssts: ssts__.unwrap_or_default(),
7780 total_file_size: total_file_size__.unwrap_or_default(),
7781 target_level: target_level__.unwrap_or_default(),
7782 })
7783 }
7784 }
7785 deserializer.deserialize_struct("hummock.LevelHandler.RunningCompactTask", FIELDS, GeneratedVisitor)
7786 }
7787}
7788impl serde::Serialize for LevelType {
7789 #[allow(deprecated)]
7790 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7791 where
7792 S: serde::Serializer,
7793 {
7794 let variant = match self {
7795 Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
7796 Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
7797 Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
7798 };
7799 serializer.serialize_str(variant)
7800 }
7801}
7802impl<'de> serde::Deserialize<'de> for LevelType {
7803 #[allow(deprecated)]
7804 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7805 where
7806 D: serde::Deserializer<'de>,
7807 {
7808 const FIELDS: &[&str] = &[
7809 "LEVEL_TYPE_UNSPECIFIED",
7810 "LEVEL_TYPE_NONOVERLAPPING",
7811 "LEVEL_TYPE_OVERLAPPING",
7812 ];
7813
7814 struct GeneratedVisitor;
7815
7816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7817 type Value = LevelType;
7818
7819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7820 write!(formatter, "expected one of: {:?}", &FIELDS)
7821 }
7822
7823 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7824 where
7825 E: serde::de::Error,
7826 {
7827 i32::try_from(v)
7828 .ok()
7829 .and_then(|x| x.try_into().ok())
7830 .ok_or_else(|| {
7831 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7832 })
7833 }
7834
7835 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7836 where
7837 E: serde::de::Error,
7838 {
7839 i32::try_from(v)
7840 .ok()
7841 .and_then(|x| x.try_into().ok())
7842 .ok_or_else(|| {
7843 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7844 })
7845 }
7846
7847 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7848 where
7849 E: serde::de::Error,
7850 {
7851 match value {
7852 "LEVEL_TYPE_UNSPECIFIED" => Ok(LevelType::Unspecified),
7853 "LEVEL_TYPE_NONOVERLAPPING" => Ok(LevelType::Nonoverlapping),
7854 "LEVEL_TYPE_OVERLAPPING" => Ok(LevelType::Overlapping),
7855 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7856 }
7857 }
7858 }
7859 deserializer.deserialize_any(GeneratedVisitor)
7860 }
7861}
7862impl serde::Serialize for ListActiveWriteLimitRequest {
7863 #[allow(deprecated)]
7864 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7865 where
7866 S: serde::Serializer,
7867 {
7868 use serde::ser::SerializeStruct;
7869 let len = 0;
7870 let struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitRequest", len)?;
7871 struct_ser.end()
7872 }
7873}
7874impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitRequest {
7875 #[allow(deprecated)]
7876 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7877 where
7878 D: serde::Deserializer<'de>,
7879 {
7880 const FIELDS: &[&str] = &[
7881 ];
7882
7883 #[allow(clippy::enum_variant_names)]
7884 enum GeneratedField {
7885 }
7886 impl<'de> serde::Deserialize<'de> for GeneratedField {
7887 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7888 where
7889 D: serde::Deserializer<'de>,
7890 {
7891 struct GeneratedVisitor;
7892
7893 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7894 type Value = GeneratedField;
7895
7896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7897 write!(formatter, "expected one of: {:?}", &FIELDS)
7898 }
7899
7900 #[allow(unused_variables)]
7901 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7902 where
7903 E: serde::de::Error,
7904 {
7905 Err(serde::de::Error::unknown_field(value, FIELDS))
7906 }
7907 }
7908 deserializer.deserialize_identifier(GeneratedVisitor)
7909 }
7910 }
7911 struct GeneratedVisitor;
7912 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7913 type Value = ListActiveWriteLimitRequest;
7914
7915 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7916 formatter.write_str("struct hummock.ListActiveWriteLimitRequest")
7917 }
7918
7919 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitRequest, V::Error>
7920 where
7921 V: serde::de::MapAccess<'de>,
7922 {
7923 while map_.next_key::<GeneratedField>()?.is_some() {
7924 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7925 }
7926 Ok(ListActiveWriteLimitRequest {
7927 })
7928 }
7929 }
7930 deserializer.deserialize_struct("hummock.ListActiveWriteLimitRequest", FIELDS, GeneratedVisitor)
7931 }
7932}
7933impl serde::Serialize for ListActiveWriteLimitResponse {
7934 #[allow(deprecated)]
7935 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7936 where
7937 S: serde::Serializer,
7938 {
7939 use serde::ser::SerializeStruct;
7940 let mut len = 0;
7941 if !self.write_limits.is_empty() {
7942 len += 1;
7943 }
7944 let mut struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitResponse", len)?;
7945 if !self.write_limits.is_empty() {
7946 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
7947 }
7948 struct_ser.end()
7949 }
7950}
7951impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitResponse {
7952 #[allow(deprecated)]
7953 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7954 where
7955 D: serde::Deserializer<'de>,
7956 {
7957 const FIELDS: &[&str] = &[
7958 "write_limits",
7959 "writeLimits",
7960 ];
7961
7962 #[allow(clippy::enum_variant_names)]
7963 enum GeneratedField {
7964 WriteLimits,
7965 }
7966 impl<'de> serde::Deserialize<'de> for GeneratedField {
7967 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7968 where
7969 D: serde::Deserializer<'de>,
7970 {
7971 struct GeneratedVisitor;
7972
7973 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7974 type Value = GeneratedField;
7975
7976 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7977 write!(formatter, "expected one of: {:?}", &FIELDS)
7978 }
7979
7980 #[allow(unused_variables)]
7981 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7982 where
7983 E: serde::de::Error,
7984 {
7985 match value {
7986 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
7987 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7988 }
7989 }
7990 }
7991 deserializer.deserialize_identifier(GeneratedVisitor)
7992 }
7993 }
7994 struct GeneratedVisitor;
7995 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7996 type Value = ListActiveWriteLimitResponse;
7997
7998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7999 formatter.write_str("struct hummock.ListActiveWriteLimitResponse")
8000 }
8001
8002 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitResponse, V::Error>
8003 where
8004 V: serde::de::MapAccess<'de>,
8005 {
8006 let mut write_limits__ = None;
8007 while let Some(k) = map_.next_key()? {
8008 match k {
8009 GeneratedField::WriteLimits => {
8010 if write_limits__.is_some() {
8011 return Err(serde::de::Error::duplicate_field("writeLimits"));
8012 }
8013 write_limits__ = Some(
8014 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
8015 .into_iter().map(|(k,v)| (k.0, v)).collect()
8016 );
8017 }
8018 }
8019 }
8020 Ok(ListActiveWriteLimitResponse {
8021 write_limits: write_limits__.unwrap_or_default(),
8022 })
8023 }
8024 }
8025 deserializer.deserialize_struct("hummock.ListActiveWriteLimitResponse", FIELDS, GeneratedVisitor)
8026 }
8027}
8028impl serde::Serialize for ListBranchedObjectRequest {
8029 #[allow(deprecated)]
8030 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8031 where
8032 S: serde::Serializer,
8033 {
8034 use serde::ser::SerializeStruct;
8035 let len = 0;
8036 let struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectRequest", len)?;
8037 struct_ser.end()
8038 }
8039}
8040impl<'de> serde::Deserialize<'de> for ListBranchedObjectRequest {
8041 #[allow(deprecated)]
8042 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8043 where
8044 D: serde::Deserializer<'de>,
8045 {
8046 const FIELDS: &[&str] = &[
8047 ];
8048
8049 #[allow(clippy::enum_variant_names)]
8050 enum GeneratedField {
8051 }
8052 impl<'de> serde::Deserialize<'de> for GeneratedField {
8053 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8054 where
8055 D: serde::Deserializer<'de>,
8056 {
8057 struct GeneratedVisitor;
8058
8059 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8060 type Value = GeneratedField;
8061
8062 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8063 write!(formatter, "expected one of: {:?}", &FIELDS)
8064 }
8065
8066 #[allow(unused_variables)]
8067 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8068 where
8069 E: serde::de::Error,
8070 {
8071 Err(serde::de::Error::unknown_field(value, FIELDS))
8072 }
8073 }
8074 deserializer.deserialize_identifier(GeneratedVisitor)
8075 }
8076 }
8077 struct GeneratedVisitor;
8078 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8079 type Value = ListBranchedObjectRequest;
8080
8081 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8082 formatter.write_str("struct hummock.ListBranchedObjectRequest")
8083 }
8084
8085 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectRequest, V::Error>
8086 where
8087 V: serde::de::MapAccess<'de>,
8088 {
8089 while map_.next_key::<GeneratedField>()?.is_some() {
8090 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8091 }
8092 Ok(ListBranchedObjectRequest {
8093 })
8094 }
8095 }
8096 deserializer.deserialize_struct("hummock.ListBranchedObjectRequest", FIELDS, GeneratedVisitor)
8097 }
8098}
8099impl serde::Serialize for ListBranchedObjectResponse {
8100 #[allow(deprecated)]
8101 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8102 where
8103 S: serde::Serializer,
8104 {
8105 use serde::ser::SerializeStruct;
8106 let mut len = 0;
8107 if !self.branched_objects.is_empty() {
8108 len += 1;
8109 }
8110 let mut struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectResponse", len)?;
8111 if !self.branched_objects.is_empty() {
8112 struct_ser.serialize_field("branchedObjects", &self.branched_objects)?;
8113 }
8114 struct_ser.end()
8115 }
8116}
8117impl<'de> serde::Deserialize<'de> for ListBranchedObjectResponse {
8118 #[allow(deprecated)]
8119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8120 where
8121 D: serde::Deserializer<'de>,
8122 {
8123 const FIELDS: &[&str] = &[
8124 "branched_objects",
8125 "branchedObjects",
8126 ];
8127
8128 #[allow(clippy::enum_variant_names)]
8129 enum GeneratedField {
8130 BranchedObjects,
8131 }
8132 impl<'de> serde::Deserialize<'de> for GeneratedField {
8133 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8134 where
8135 D: serde::Deserializer<'de>,
8136 {
8137 struct GeneratedVisitor;
8138
8139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8140 type Value = GeneratedField;
8141
8142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8143 write!(formatter, "expected one of: {:?}", &FIELDS)
8144 }
8145
8146 #[allow(unused_variables)]
8147 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8148 where
8149 E: serde::de::Error,
8150 {
8151 match value {
8152 "branchedObjects" | "branched_objects" => Ok(GeneratedField::BranchedObjects),
8153 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8154 }
8155 }
8156 }
8157 deserializer.deserialize_identifier(GeneratedVisitor)
8158 }
8159 }
8160 struct GeneratedVisitor;
8161 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8162 type Value = ListBranchedObjectResponse;
8163
8164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8165 formatter.write_str("struct hummock.ListBranchedObjectResponse")
8166 }
8167
8168 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectResponse, V::Error>
8169 where
8170 V: serde::de::MapAccess<'de>,
8171 {
8172 let mut branched_objects__ = None;
8173 while let Some(k) = map_.next_key()? {
8174 match k {
8175 GeneratedField::BranchedObjects => {
8176 if branched_objects__.is_some() {
8177 return Err(serde::de::Error::duplicate_field("branchedObjects"));
8178 }
8179 branched_objects__ = Some(map_.next_value()?);
8180 }
8181 }
8182 }
8183 Ok(ListBranchedObjectResponse {
8184 branched_objects: branched_objects__.unwrap_or_default(),
8185 })
8186 }
8187 }
8188 deserializer.deserialize_struct("hummock.ListBranchedObjectResponse", FIELDS, GeneratedVisitor)
8189 }
8190}
8191impl serde::Serialize for ListCompactTaskAssignmentRequest {
8192 #[allow(deprecated)]
8193 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8194 where
8195 S: serde::Serializer,
8196 {
8197 use serde::ser::SerializeStruct;
8198 let len = 0;
8199 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentRequest", len)?;
8200 struct_ser.end()
8201 }
8202}
8203impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentRequest {
8204 #[allow(deprecated)]
8205 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8206 where
8207 D: serde::Deserializer<'de>,
8208 {
8209 const FIELDS: &[&str] = &[
8210 ];
8211
8212 #[allow(clippy::enum_variant_names)]
8213 enum GeneratedField {
8214 }
8215 impl<'de> serde::Deserialize<'de> for GeneratedField {
8216 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8217 where
8218 D: serde::Deserializer<'de>,
8219 {
8220 struct GeneratedVisitor;
8221
8222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8223 type Value = GeneratedField;
8224
8225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8226 write!(formatter, "expected one of: {:?}", &FIELDS)
8227 }
8228
8229 #[allow(unused_variables)]
8230 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8231 where
8232 E: serde::de::Error,
8233 {
8234 Err(serde::de::Error::unknown_field(value, FIELDS))
8235 }
8236 }
8237 deserializer.deserialize_identifier(GeneratedVisitor)
8238 }
8239 }
8240 struct GeneratedVisitor;
8241 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8242 type Value = ListCompactTaskAssignmentRequest;
8243
8244 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8245 formatter.write_str("struct hummock.ListCompactTaskAssignmentRequest")
8246 }
8247
8248 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentRequest, V::Error>
8249 where
8250 V: serde::de::MapAccess<'de>,
8251 {
8252 while map_.next_key::<GeneratedField>()?.is_some() {
8253 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8254 }
8255 Ok(ListCompactTaskAssignmentRequest {
8256 })
8257 }
8258 }
8259 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentRequest", FIELDS, GeneratedVisitor)
8260 }
8261}
8262impl serde::Serialize for ListCompactTaskAssignmentResponse {
8263 #[allow(deprecated)]
8264 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8265 where
8266 S: serde::Serializer,
8267 {
8268 use serde::ser::SerializeStruct;
8269 let mut len = 0;
8270 if !self.task_assignment.is_empty() {
8271 len += 1;
8272 }
8273 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentResponse", len)?;
8274 if !self.task_assignment.is_empty() {
8275 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
8276 }
8277 struct_ser.end()
8278 }
8279}
8280impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentResponse {
8281 #[allow(deprecated)]
8282 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8283 where
8284 D: serde::Deserializer<'de>,
8285 {
8286 const FIELDS: &[&str] = &[
8287 "task_assignment",
8288 "taskAssignment",
8289 ];
8290
8291 #[allow(clippy::enum_variant_names)]
8292 enum GeneratedField {
8293 TaskAssignment,
8294 }
8295 impl<'de> serde::Deserialize<'de> for GeneratedField {
8296 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8297 where
8298 D: serde::Deserializer<'de>,
8299 {
8300 struct GeneratedVisitor;
8301
8302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8303 type Value = GeneratedField;
8304
8305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8306 write!(formatter, "expected one of: {:?}", &FIELDS)
8307 }
8308
8309 #[allow(unused_variables)]
8310 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8311 where
8312 E: serde::de::Error,
8313 {
8314 match value {
8315 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
8316 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8317 }
8318 }
8319 }
8320 deserializer.deserialize_identifier(GeneratedVisitor)
8321 }
8322 }
8323 struct GeneratedVisitor;
8324 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8325 type Value = ListCompactTaskAssignmentResponse;
8326
8327 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8328 formatter.write_str("struct hummock.ListCompactTaskAssignmentResponse")
8329 }
8330
8331 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentResponse, V::Error>
8332 where
8333 V: serde::de::MapAccess<'de>,
8334 {
8335 let mut task_assignment__ = None;
8336 while let Some(k) = map_.next_key()? {
8337 match k {
8338 GeneratedField::TaskAssignment => {
8339 if task_assignment__.is_some() {
8340 return Err(serde::de::Error::duplicate_field("taskAssignment"));
8341 }
8342 task_assignment__ = Some(map_.next_value()?);
8343 }
8344 }
8345 }
8346 Ok(ListCompactTaskAssignmentResponse {
8347 task_assignment: task_assignment__.unwrap_or_default(),
8348 })
8349 }
8350 }
8351 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentResponse", FIELDS, GeneratedVisitor)
8352 }
8353}
8354impl serde::Serialize for ListCompactTaskProgressRequest {
8355 #[allow(deprecated)]
8356 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8357 where
8358 S: serde::Serializer,
8359 {
8360 use serde::ser::SerializeStruct;
8361 let len = 0;
8362 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressRequest", len)?;
8363 struct_ser.end()
8364 }
8365}
8366impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressRequest {
8367 #[allow(deprecated)]
8368 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8369 where
8370 D: serde::Deserializer<'de>,
8371 {
8372 const FIELDS: &[&str] = &[
8373 ];
8374
8375 #[allow(clippy::enum_variant_names)]
8376 enum GeneratedField {
8377 }
8378 impl<'de> serde::Deserialize<'de> for GeneratedField {
8379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8380 where
8381 D: serde::Deserializer<'de>,
8382 {
8383 struct GeneratedVisitor;
8384
8385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8386 type Value = GeneratedField;
8387
8388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8389 write!(formatter, "expected one of: {:?}", &FIELDS)
8390 }
8391
8392 #[allow(unused_variables)]
8393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8394 where
8395 E: serde::de::Error,
8396 {
8397 Err(serde::de::Error::unknown_field(value, FIELDS))
8398 }
8399 }
8400 deserializer.deserialize_identifier(GeneratedVisitor)
8401 }
8402 }
8403 struct GeneratedVisitor;
8404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8405 type Value = ListCompactTaskProgressRequest;
8406
8407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8408 formatter.write_str("struct hummock.ListCompactTaskProgressRequest")
8409 }
8410
8411 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressRequest, V::Error>
8412 where
8413 V: serde::de::MapAccess<'de>,
8414 {
8415 while map_.next_key::<GeneratedField>()?.is_some() {
8416 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8417 }
8418 Ok(ListCompactTaskProgressRequest {
8419 })
8420 }
8421 }
8422 deserializer.deserialize_struct("hummock.ListCompactTaskProgressRequest", FIELDS, GeneratedVisitor)
8423 }
8424}
8425impl serde::Serialize for ListCompactTaskProgressResponse {
8426 #[allow(deprecated)]
8427 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8428 where
8429 S: serde::Serializer,
8430 {
8431 use serde::ser::SerializeStruct;
8432 let mut len = 0;
8433 if !self.task_progress.is_empty() {
8434 len += 1;
8435 }
8436 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressResponse", len)?;
8437 if !self.task_progress.is_empty() {
8438 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
8439 }
8440 struct_ser.end()
8441 }
8442}
8443impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressResponse {
8444 #[allow(deprecated)]
8445 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8446 where
8447 D: serde::Deserializer<'de>,
8448 {
8449 const FIELDS: &[&str] = &[
8450 "task_progress",
8451 "taskProgress",
8452 ];
8453
8454 #[allow(clippy::enum_variant_names)]
8455 enum GeneratedField {
8456 TaskProgress,
8457 }
8458 impl<'de> serde::Deserialize<'de> for GeneratedField {
8459 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8460 where
8461 D: serde::Deserializer<'de>,
8462 {
8463 struct GeneratedVisitor;
8464
8465 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8466 type Value = GeneratedField;
8467
8468 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8469 write!(formatter, "expected one of: {:?}", &FIELDS)
8470 }
8471
8472 #[allow(unused_variables)]
8473 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8474 where
8475 E: serde::de::Error,
8476 {
8477 match value {
8478 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
8479 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8480 }
8481 }
8482 }
8483 deserializer.deserialize_identifier(GeneratedVisitor)
8484 }
8485 }
8486 struct GeneratedVisitor;
8487 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8488 type Value = ListCompactTaskProgressResponse;
8489
8490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8491 formatter.write_str("struct hummock.ListCompactTaskProgressResponse")
8492 }
8493
8494 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressResponse, V::Error>
8495 where
8496 V: serde::de::MapAccess<'de>,
8497 {
8498 let mut task_progress__ = None;
8499 while let Some(k) = map_.next_key()? {
8500 match k {
8501 GeneratedField::TaskProgress => {
8502 if task_progress__.is_some() {
8503 return Err(serde::de::Error::duplicate_field("taskProgress"));
8504 }
8505 task_progress__ = Some(map_.next_value()?);
8506 }
8507 }
8508 }
8509 Ok(ListCompactTaskProgressResponse {
8510 task_progress: task_progress__.unwrap_or_default(),
8511 })
8512 }
8513 }
8514 deserializer.deserialize_struct("hummock.ListCompactTaskProgressResponse", FIELDS, GeneratedVisitor)
8515 }
8516}
8517impl serde::Serialize for ListHummockMetaConfigRequest {
8518 #[allow(deprecated)]
8519 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8520 where
8521 S: serde::Serializer,
8522 {
8523 use serde::ser::SerializeStruct;
8524 let len = 0;
8525 let struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigRequest", len)?;
8526 struct_ser.end()
8527 }
8528}
8529impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigRequest {
8530 #[allow(deprecated)]
8531 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8532 where
8533 D: serde::Deserializer<'de>,
8534 {
8535 const FIELDS: &[&str] = &[
8536 ];
8537
8538 #[allow(clippy::enum_variant_names)]
8539 enum GeneratedField {
8540 }
8541 impl<'de> serde::Deserialize<'de> for GeneratedField {
8542 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8543 where
8544 D: serde::Deserializer<'de>,
8545 {
8546 struct GeneratedVisitor;
8547
8548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8549 type Value = GeneratedField;
8550
8551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8552 write!(formatter, "expected one of: {:?}", &FIELDS)
8553 }
8554
8555 #[allow(unused_variables)]
8556 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8557 where
8558 E: serde::de::Error,
8559 {
8560 Err(serde::de::Error::unknown_field(value, FIELDS))
8561 }
8562 }
8563 deserializer.deserialize_identifier(GeneratedVisitor)
8564 }
8565 }
8566 struct GeneratedVisitor;
8567 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8568 type Value = ListHummockMetaConfigRequest;
8569
8570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8571 formatter.write_str("struct hummock.ListHummockMetaConfigRequest")
8572 }
8573
8574 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigRequest, V::Error>
8575 where
8576 V: serde::de::MapAccess<'de>,
8577 {
8578 while map_.next_key::<GeneratedField>()?.is_some() {
8579 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8580 }
8581 Ok(ListHummockMetaConfigRequest {
8582 })
8583 }
8584 }
8585 deserializer.deserialize_struct("hummock.ListHummockMetaConfigRequest", FIELDS, GeneratedVisitor)
8586 }
8587}
8588impl serde::Serialize for ListHummockMetaConfigResponse {
8589 #[allow(deprecated)]
8590 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8591 where
8592 S: serde::Serializer,
8593 {
8594 use serde::ser::SerializeStruct;
8595 let mut len = 0;
8596 if !self.configs.is_empty() {
8597 len += 1;
8598 }
8599 let mut struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigResponse", len)?;
8600 if !self.configs.is_empty() {
8601 struct_ser.serialize_field("configs", &self.configs)?;
8602 }
8603 struct_ser.end()
8604 }
8605}
8606impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigResponse {
8607 #[allow(deprecated)]
8608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8609 where
8610 D: serde::Deserializer<'de>,
8611 {
8612 const FIELDS: &[&str] = &[
8613 "configs",
8614 ];
8615
8616 #[allow(clippy::enum_variant_names)]
8617 enum GeneratedField {
8618 Configs,
8619 }
8620 impl<'de> serde::Deserialize<'de> for GeneratedField {
8621 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8622 where
8623 D: serde::Deserializer<'de>,
8624 {
8625 struct GeneratedVisitor;
8626
8627 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8628 type Value = GeneratedField;
8629
8630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8631 write!(formatter, "expected one of: {:?}", &FIELDS)
8632 }
8633
8634 #[allow(unused_variables)]
8635 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8636 where
8637 E: serde::de::Error,
8638 {
8639 match value {
8640 "configs" => Ok(GeneratedField::Configs),
8641 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8642 }
8643 }
8644 }
8645 deserializer.deserialize_identifier(GeneratedVisitor)
8646 }
8647 }
8648 struct GeneratedVisitor;
8649 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8650 type Value = ListHummockMetaConfigResponse;
8651
8652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8653 formatter.write_str("struct hummock.ListHummockMetaConfigResponse")
8654 }
8655
8656 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigResponse, V::Error>
8657 where
8658 V: serde::de::MapAccess<'de>,
8659 {
8660 let mut configs__ = None;
8661 while let Some(k) = map_.next_key()? {
8662 match k {
8663 GeneratedField::Configs => {
8664 if configs__.is_some() {
8665 return Err(serde::de::Error::duplicate_field("configs"));
8666 }
8667 configs__ = Some(
8668 map_.next_value::<std::collections::HashMap<_, _>>()?
8669 );
8670 }
8671 }
8672 }
8673 Ok(ListHummockMetaConfigResponse {
8674 configs: configs__.unwrap_or_default(),
8675 })
8676 }
8677 }
8678 deserializer.deserialize_struct("hummock.ListHummockMetaConfigResponse", FIELDS, GeneratedVisitor)
8679 }
8680}
8681impl serde::Serialize for ListVersionDeltasRequest {
8682 #[allow(deprecated)]
8683 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8684 where
8685 S: serde::Serializer,
8686 {
8687 use serde::ser::SerializeStruct;
8688 let mut len = 0;
8689 if self.start_id != 0 {
8690 len += 1;
8691 }
8692 if self.num_limit != 0 {
8693 len += 1;
8694 }
8695 if self.committed_epoch_limit != 0 {
8696 len += 1;
8697 }
8698 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasRequest", len)?;
8699 if self.start_id != 0 {
8700 #[allow(clippy::needless_borrow)]
8701 #[allow(clippy::needless_borrows_for_generic_args)]
8702 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
8703 }
8704 if self.num_limit != 0 {
8705 struct_ser.serialize_field("numLimit", &self.num_limit)?;
8706 }
8707 if self.committed_epoch_limit != 0 {
8708 #[allow(clippy::needless_borrow)]
8709 #[allow(clippy::needless_borrows_for_generic_args)]
8710 struct_ser.serialize_field("committedEpochLimit", ToString::to_string(&self.committed_epoch_limit).as_str())?;
8711 }
8712 struct_ser.end()
8713 }
8714}
8715impl<'de> serde::Deserialize<'de> for ListVersionDeltasRequest {
8716 #[allow(deprecated)]
8717 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8718 where
8719 D: serde::Deserializer<'de>,
8720 {
8721 const FIELDS: &[&str] = &[
8722 "start_id",
8723 "startId",
8724 "num_limit",
8725 "numLimit",
8726 "committed_epoch_limit",
8727 "committedEpochLimit",
8728 ];
8729
8730 #[allow(clippy::enum_variant_names)]
8731 enum GeneratedField {
8732 StartId,
8733 NumLimit,
8734 CommittedEpochLimit,
8735 }
8736 impl<'de> serde::Deserialize<'de> for GeneratedField {
8737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8738 where
8739 D: serde::Deserializer<'de>,
8740 {
8741 struct GeneratedVisitor;
8742
8743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8744 type Value = GeneratedField;
8745
8746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8747 write!(formatter, "expected one of: {:?}", &FIELDS)
8748 }
8749
8750 #[allow(unused_variables)]
8751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8752 where
8753 E: serde::de::Error,
8754 {
8755 match value {
8756 "startId" | "start_id" => Ok(GeneratedField::StartId),
8757 "numLimit" | "num_limit" => Ok(GeneratedField::NumLimit),
8758 "committedEpochLimit" | "committed_epoch_limit" => Ok(GeneratedField::CommittedEpochLimit),
8759 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8760 }
8761 }
8762 }
8763 deserializer.deserialize_identifier(GeneratedVisitor)
8764 }
8765 }
8766 struct GeneratedVisitor;
8767 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8768 type Value = ListVersionDeltasRequest;
8769
8770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8771 formatter.write_str("struct hummock.ListVersionDeltasRequest")
8772 }
8773
8774 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasRequest, V::Error>
8775 where
8776 V: serde::de::MapAccess<'de>,
8777 {
8778 let mut start_id__ = None;
8779 let mut num_limit__ = None;
8780 let mut committed_epoch_limit__ = None;
8781 while let Some(k) = map_.next_key()? {
8782 match k {
8783 GeneratedField::StartId => {
8784 if start_id__.is_some() {
8785 return Err(serde::de::Error::duplicate_field("startId"));
8786 }
8787 start_id__ =
8788 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8789 ;
8790 }
8791 GeneratedField::NumLimit => {
8792 if num_limit__.is_some() {
8793 return Err(serde::de::Error::duplicate_field("numLimit"));
8794 }
8795 num_limit__ =
8796 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8797 ;
8798 }
8799 GeneratedField::CommittedEpochLimit => {
8800 if committed_epoch_limit__.is_some() {
8801 return Err(serde::de::Error::duplicate_field("committedEpochLimit"));
8802 }
8803 committed_epoch_limit__ =
8804 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8805 ;
8806 }
8807 }
8808 }
8809 Ok(ListVersionDeltasRequest {
8810 start_id: start_id__.unwrap_or_default(),
8811 num_limit: num_limit__.unwrap_or_default(),
8812 committed_epoch_limit: committed_epoch_limit__.unwrap_or_default(),
8813 })
8814 }
8815 }
8816 deserializer.deserialize_struct("hummock.ListVersionDeltasRequest", FIELDS, GeneratedVisitor)
8817 }
8818}
8819impl serde::Serialize for ListVersionDeltasResponse {
8820 #[allow(deprecated)]
8821 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8822 where
8823 S: serde::Serializer,
8824 {
8825 use serde::ser::SerializeStruct;
8826 let mut len = 0;
8827 if self.version_deltas.is_some() {
8828 len += 1;
8829 }
8830 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasResponse", len)?;
8831 if let Some(v) = self.version_deltas.as_ref() {
8832 struct_ser.serialize_field("versionDeltas", v)?;
8833 }
8834 struct_ser.end()
8835 }
8836}
8837impl<'de> serde::Deserialize<'de> for ListVersionDeltasResponse {
8838 #[allow(deprecated)]
8839 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8840 where
8841 D: serde::Deserializer<'de>,
8842 {
8843 const FIELDS: &[&str] = &[
8844 "version_deltas",
8845 "versionDeltas",
8846 ];
8847
8848 #[allow(clippy::enum_variant_names)]
8849 enum GeneratedField {
8850 VersionDeltas,
8851 }
8852 impl<'de> serde::Deserialize<'de> for GeneratedField {
8853 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8854 where
8855 D: serde::Deserializer<'de>,
8856 {
8857 struct GeneratedVisitor;
8858
8859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8860 type Value = GeneratedField;
8861
8862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8863 write!(formatter, "expected one of: {:?}", &FIELDS)
8864 }
8865
8866 #[allow(unused_variables)]
8867 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8868 where
8869 E: serde::de::Error,
8870 {
8871 match value {
8872 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
8873 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8874 }
8875 }
8876 }
8877 deserializer.deserialize_identifier(GeneratedVisitor)
8878 }
8879 }
8880 struct GeneratedVisitor;
8881 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8882 type Value = ListVersionDeltasResponse;
8883
8884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8885 formatter.write_str("struct hummock.ListVersionDeltasResponse")
8886 }
8887
8888 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasResponse, V::Error>
8889 where
8890 V: serde::de::MapAccess<'de>,
8891 {
8892 let mut version_deltas__ = None;
8893 while let Some(k) = map_.next_key()? {
8894 match k {
8895 GeneratedField::VersionDeltas => {
8896 if version_deltas__.is_some() {
8897 return Err(serde::de::Error::duplicate_field("versionDeltas"));
8898 }
8899 version_deltas__ = map_.next_value()?;
8900 }
8901 }
8902 }
8903 Ok(ListVersionDeltasResponse {
8904 version_deltas: version_deltas__,
8905 })
8906 }
8907 }
8908 deserializer.deserialize_struct("hummock.ListVersionDeltasResponse", FIELDS, GeneratedVisitor)
8909 }
8910}
8911impl serde::Serialize for MergeCompactionGroupRequest {
8912 #[allow(deprecated)]
8913 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8914 where
8915 S: serde::Serializer,
8916 {
8917 use serde::ser::SerializeStruct;
8918 let mut len = 0;
8919 if self.left_group_id != 0 {
8920 len += 1;
8921 }
8922 if self.right_group_id != 0 {
8923 len += 1;
8924 }
8925 let mut struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupRequest", len)?;
8926 if self.left_group_id != 0 {
8927 #[allow(clippy::needless_borrow)]
8928 #[allow(clippy::needless_borrows_for_generic_args)]
8929 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
8930 }
8931 if self.right_group_id != 0 {
8932 #[allow(clippy::needless_borrow)]
8933 #[allow(clippy::needless_borrows_for_generic_args)]
8934 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
8935 }
8936 struct_ser.end()
8937 }
8938}
8939impl<'de> serde::Deserialize<'de> for MergeCompactionGroupRequest {
8940 #[allow(deprecated)]
8941 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8942 where
8943 D: serde::Deserializer<'de>,
8944 {
8945 const FIELDS: &[&str] = &[
8946 "left_group_id",
8947 "leftGroupId",
8948 "right_group_id",
8949 "rightGroupId",
8950 ];
8951
8952 #[allow(clippy::enum_variant_names)]
8953 enum GeneratedField {
8954 LeftGroupId,
8955 RightGroupId,
8956 }
8957 impl<'de> serde::Deserialize<'de> for GeneratedField {
8958 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8959 where
8960 D: serde::Deserializer<'de>,
8961 {
8962 struct GeneratedVisitor;
8963
8964 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8965 type Value = GeneratedField;
8966
8967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8968 write!(formatter, "expected one of: {:?}", &FIELDS)
8969 }
8970
8971 #[allow(unused_variables)]
8972 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8973 where
8974 E: serde::de::Error,
8975 {
8976 match value {
8977 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
8978 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
8979 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8980 }
8981 }
8982 }
8983 deserializer.deserialize_identifier(GeneratedVisitor)
8984 }
8985 }
8986 struct GeneratedVisitor;
8987 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8988 type Value = MergeCompactionGroupRequest;
8989
8990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8991 formatter.write_str("struct hummock.MergeCompactionGroupRequest")
8992 }
8993
8994 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupRequest, V::Error>
8995 where
8996 V: serde::de::MapAccess<'de>,
8997 {
8998 let mut left_group_id__ = None;
8999 let mut right_group_id__ = None;
9000 while let Some(k) = map_.next_key()? {
9001 match k {
9002 GeneratedField::LeftGroupId => {
9003 if left_group_id__.is_some() {
9004 return Err(serde::de::Error::duplicate_field("leftGroupId"));
9005 }
9006 left_group_id__ =
9007 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9008 ;
9009 }
9010 GeneratedField::RightGroupId => {
9011 if right_group_id__.is_some() {
9012 return Err(serde::de::Error::duplicate_field("rightGroupId"));
9013 }
9014 right_group_id__ =
9015 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9016 ;
9017 }
9018 }
9019 }
9020 Ok(MergeCompactionGroupRequest {
9021 left_group_id: left_group_id__.unwrap_or_default(),
9022 right_group_id: right_group_id__.unwrap_or_default(),
9023 })
9024 }
9025 }
9026 deserializer.deserialize_struct("hummock.MergeCompactionGroupRequest", FIELDS, GeneratedVisitor)
9027 }
9028}
9029impl serde::Serialize for MergeCompactionGroupResponse {
9030 #[allow(deprecated)]
9031 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9032 where
9033 S: serde::Serializer,
9034 {
9035 use serde::ser::SerializeStruct;
9036 let len = 0;
9037 let struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupResponse", len)?;
9038 struct_ser.end()
9039 }
9040}
9041impl<'de> serde::Deserialize<'de> for MergeCompactionGroupResponse {
9042 #[allow(deprecated)]
9043 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9044 where
9045 D: serde::Deserializer<'de>,
9046 {
9047 const FIELDS: &[&str] = &[
9048 ];
9049
9050 #[allow(clippy::enum_variant_names)]
9051 enum GeneratedField {
9052 }
9053 impl<'de> serde::Deserialize<'de> for GeneratedField {
9054 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9055 where
9056 D: serde::Deserializer<'de>,
9057 {
9058 struct GeneratedVisitor;
9059
9060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9061 type Value = GeneratedField;
9062
9063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9064 write!(formatter, "expected one of: {:?}", &FIELDS)
9065 }
9066
9067 #[allow(unused_variables)]
9068 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9069 where
9070 E: serde::de::Error,
9071 {
9072 Err(serde::de::Error::unknown_field(value, FIELDS))
9073 }
9074 }
9075 deserializer.deserialize_identifier(GeneratedVisitor)
9076 }
9077 }
9078 struct GeneratedVisitor;
9079 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9080 type Value = MergeCompactionGroupResponse;
9081
9082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9083 formatter.write_str("struct hummock.MergeCompactionGroupResponse")
9084 }
9085
9086 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupResponse, V::Error>
9087 where
9088 V: serde::de::MapAccess<'de>,
9089 {
9090 while map_.next_key::<GeneratedField>()?.is_some() {
9091 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9092 }
9093 Ok(MergeCompactionGroupResponse {
9094 })
9095 }
9096 }
9097 deserializer.deserialize_struct("hummock.MergeCompactionGroupResponse", FIELDS, GeneratedVisitor)
9098 }
9099}
9100impl serde::Serialize for NewL0SubLevel {
9101 #[allow(deprecated)]
9102 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9103 where
9104 S: serde::Serializer,
9105 {
9106 use serde::ser::SerializeStruct;
9107 let mut len = 0;
9108 if !self.inserted_table_infos.is_empty() {
9109 len += 1;
9110 }
9111 let mut struct_ser = serializer.serialize_struct("hummock.NewL0SubLevel", len)?;
9112 if !self.inserted_table_infos.is_empty() {
9113 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
9114 }
9115 struct_ser.end()
9116 }
9117}
9118impl<'de> serde::Deserialize<'de> for NewL0SubLevel {
9119 #[allow(deprecated)]
9120 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9121 where
9122 D: serde::Deserializer<'de>,
9123 {
9124 const FIELDS: &[&str] = &[
9125 "inserted_table_infos",
9126 "insertedTableInfos",
9127 ];
9128
9129 #[allow(clippy::enum_variant_names)]
9130 enum GeneratedField {
9131 InsertedTableInfos,
9132 }
9133 impl<'de> serde::Deserialize<'de> for GeneratedField {
9134 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9135 where
9136 D: serde::Deserializer<'de>,
9137 {
9138 struct GeneratedVisitor;
9139
9140 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9141 type Value = GeneratedField;
9142
9143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9144 write!(formatter, "expected one of: {:?}", &FIELDS)
9145 }
9146
9147 #[allow(unused_variables)]
9148 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9149 where
9150 E: serde::de::Error,
9151 {
9152 match value {
9153 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
9154 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9155 }
9156 }
9157 }
9158 deserializer.deserialize_identifier(GeneratedVisitor)
9159 }
9160 }
9161 struct GeneratedVisitor;
9162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9163 type Value = NewL0SubLevel;
9164
9165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9166 formatter.write_str("struct hummock.NewL0SubLevel")
9167 }
9168
9169 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NewL0SubLevel, V::Error>
9170 where
9171 V: serde::de::MapAccess<'de>,
9172 {
9173 let mut inserted_table_infos__ = None;
9174 while let Some(k) = map_.next_key()? {
9175 match k {
9176 GeneratedField::InsertedTableInfos => {
9177 if inserted_table_infos__.is_some() {
9178 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
9179 }
9180 inserted_table_infos__ = Some(map_.next_value()?);
9181 }
9182 }
9183 }
9184 Ok(NewL0SubLevel {
9185 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
9186 })
9187 }
9188 }
9189 deserializer.deserialize_struct("hummock.NewL0SubLevel", FIELDS, GeneratedVisitor)
9190 }
9191}
9192impl serde::Serialize for OverlappingLevel {
9193 #[allow(deprecated)]
9194 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9195 where
9196 S: serde::Serializer,
9197 {
9198 use serde::ser::SerializeStruct;
9199 let mut len = 0;
9200 if !self.sub_levels.is_empty() {
9201 len += 1;
9202 }
9203 if self.total_file_size != 0 {
9204 len += 1;
9205 }
9206 if self.uncompressed_file_size != 0 {
9207 len += 1;
9208 }
9209 let mut struct_ser = serializer.serialize_struct("hummock.OverlappingLevel", len)?;
9210 if !self.sub_levels.is_empty() {
9211 struct_ser.serialize_field("subLevels", &self.sub_levels)?;
9212 }
9213 if self.total_file_size != 0 {
9214 #[allow(clippy::needless_borrow)]
9215 #[allow(clippy::needless_borrows_for_generic_args)]
9216 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
9217 }
9218 if self.uncompressed_file_size != 0 {
9219 #[allow(clippy::needless_borrow)]
9220 #[allow(clippy::needless_borrows_for_generic_args)]
9221 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
9222 }
9223 struct_ser.end()
9224 }
9225}
9226impl<'de> serde::Deserialize<'de> for OverlappingLevel {
9227 #[allow(deprecated)]
9228 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9229 where
9230 D: serde::Deserializer<'de>,
9231 {
9232 const FIELDS: &[&str] = &[
9233 "sub_levels",
9234 "subLevels",
9235 "total_file_size",
9236 "totalFileSize",
9237 "uncompressed_file_size",
9238 "uncompressedFileSize",
9239 ];
9240
9241 #[allow(clippy::enum_variant_names)]
9242 enum GeneratedField {
9243 SubLevels,
9244 TotalFileSize,
9245 UncompressedFileSize,
9246 }
9247 impl<'de> serde::Deserialize<'de> for GeneratedField {
9248 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9249 where
9250 D: serde::Deserializer<'de>,
9251 {
9252 struct GeneratedVisitor;
9253
9254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9255 type Value = GeneratedField;
9256
9257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9258 write!(formatter, "expected one of: {:?}", &FIELDS)
9259 }
9260
9261 #[allow(unused_variables)]
9262 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9263 where
9264 E: serde::de::Error,
9265 {
9266 match value {
9267 "subLevels" | "sub_levels" => Ok(GeneratedField::SubLevels),
9268 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
9269 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
9270 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9271 }
9272 }
9273 }
9274 deserializer.deserialize_identifier(GeneratedVisitor)
9275 }
9276 }
9277 struct GeneratedVisitor;
9278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9279 type Value = OverlappingLevel;
9280
9281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9282 formatter.write_str("struct hummock.OverlappingLevel")
9283 }
9284
9285 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverlappingLevel, V::Error>
9286 where
9287 V: serde::de::MapAccess<'de>,
9288 {
9289 let mut sub_levels__ = None;
9290 let mut total_file_size__ = None;
9291 let mut uncompressed_file_size__ = None;
9292 while let Some(k) = map_.next_key()? {
9293 match k {
9294 GeneratedField::SubLevels => {
9295 if sub_levels__.is_some() {
9296 return Err(serde::de::Error::duplicate_field("subLevels"));
9297 }
9298 sub_levels__ = Some(map_.next_value()?);
9299 }
9300 GeneratedField::TotalFileSize => {
9301 if total_file_size__.is_some() {
9302 return Err(serde::de::Error::duplicate_field("totalFileSize"));
9303 }
9304 total_file_size__ =
9305 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9306 ;
9307 }
9308 GeneratedField::UncompressedFileSize => {
9309 if uncompressed_file_size__.is_some() {
9310 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
9311 }
9312 uncompressed_file_size__ =
9313 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9314 ;
9315 }
9316 }
9317 }
9318 Ok(OverlappingLevel {
9319 sub_levels: sub_levels__.unwrap_or_default(),
9320 total_file_size: total_file_size__.unwrap_or_default(),
9321 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
9322 })
9323 }
9324 }
9325 deserializer.deserialize_struct("hummock.OverlappingLevel", FIELDS, GeneratedVisitor)
9326 }
9327}
9328impl serde::Serialize for PinVersionRequest {
9329 #[allow(deprecated)]
9330 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9331 where
9332 S: serde::Serializer,
9333 {
9334 use serde::ser::SerializeStruct;
9335 let mut len = 0;
9336 if self.context_id != 0 {
9337 len += 1;
9338 }
9339 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionRequest", len)?;
9340 if self.context_id != 0 {
9341 struct_ser.serialize_field("contextId", &self.context_id)?;
9342 }
9343 struct_ser.end()
9344 }
9345}
9346impl<'de> serde::Deserialize<'de> for PinVersionRequest {
9347 #[allow(deprecated)]
9348 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9349 where
9350 D: serde::Deserializer<'de>,
9351 {
9352 const FIELDS: &[&str] = &[
9353 "context_id",
9354 "contextId",
9355 ];
9356
9357 #[allow(clippy::enum_variant_names)]
9358 enum GeneratedField {
9359 ContextId,
9360 }
9361 impl<'de> serde::Deserialize<'de> for GeneratedField {
9362 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9363 where
9364 D: serde::Deserializer<'de>,
9365 {
9366 struct GeneratedVisitor;
9367
9368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9369 type Value = GeneratedField;
9370
9371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9372 write!(formatter, "expected one of: {:?}", &FIELDS)
9373 }
9374
9375 #[allow(unused_variables)]
9376 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9377 where
9378 E: serde::de::Error,
9379 {
9380 match value {
9381 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
9382 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9383 }
9384 }
9385 }
9386 deserializer.deserialize_identifier(GeneratedVisitor)
9387 }
9388 }
9389 struct GeneratedVisitor;
9390 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9391 type Value = PinVersionRequest;
9392
9393 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9394 formatter.write_str("struct hummock.PinVersionRequest")
9395 }
9396
9397 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionRequest, V::Error>
9398 where
9399 V: serde::de::MapAccess<'de>,
9400 {
9401 let mut context_id__ = None;
9402 while let Some(k) = map_.next_key()? {
9403 match k {
9404 GeneratedField::ContextId => {
9405 if context_id__.is_some() {
9406 return Err(serde::de::Error::duplicate_field("contextId"));
9407 }
9408 context_id__ =
9409 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9410 ;
9411 }
9412 }
9413 }
9414 Ok(PinVersionRequest {
9415 context_id: context_id__.unwrap_or_default(),
9416 })
9417 }
9418 }
9419 deserializer.deserialize_struct("hummock.PinVersionRequest", FIELDS, GeneratedVisitor)
9420 }
9421}
9422impl serde::Serialize for PinVersionResponse {
9423 #[allow(deprecated)]
9424 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9425 where
9426 S: serde::Serializer,
9427 {
9428 use serde::ser::SerializeStruct;
9429 let mut len = 0;
9430 if self.pinned_version.is_some() {
9431 len += 1;
9432 }
9433 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionResponse", len)?;
9434 if let Some(v) = self.pinned_version.as_ref() {
9435 struct_ser.serialize_field("pinnedVersion", v)?;
9436 }
9437 struct_ser.end()
9438 }
9439}
9440impl<'de> serde::Deserialize<'de> for PinVersionResponse {
9441 #[allow(deprecated)]
9442 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9443 where
9444 D: serde::Deserializer<'de>,
9445 {
9446 const FIELDS: &[&str] = &[
9447 "pinned_version",
9448 "pinnedVersion",
9449 ];
9450
9451 #[allow(clippy::enum_variant_names)]
9452 enum GeneratedField {
9453 PinnedVersion,
9454 }
9455 impl<'de> serde::Deserialize<'de> for GeneratedField {
9456 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9457 where
9458 D: serde::Deserializer<'de>,
9459 {
9460 struct GeneratedVisitor;
9461
9462 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9463 type Value = GeneratedField;
9464
9465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9466 write!(formatter, "expected one of: {:?}", &FIELDS)
9467 }
9468
9469 #[allow(unused_variables)]
9470 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9471 where
9472 E: serde::de::Error,
9473 {
9474 match value {
9475 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
9476 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9477 }
9478 }
9479 }
9480 deserializer.deserialize_identifier(GeneratedVisitor)
9481 }
9482 }
9483 struct GeneratedVisitor;
9484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9485 type Value = PinVersionResponse;
9486
9487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9488 formatter.write_str("struct hummock.PinVersionResponse")
9489 }
9490
9491 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionResponse, V::Error>
9492 where
9493 V: serde::de::MapAccess<'de>,
9494 {
9495 let mut pinned_version__ = None;
9496 while let Some(k) = map_.next_key()? {
9497 match k {
9498 GeneratedField::PinnedVersion => {
9499 if pinned_version__.is_some() {
9500 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
9501 }
9502 pinned_version__ = map_.next_value()?;
9503 }
9504 }
9505 }
9506 Ok(PinVersionResponse {
9507 pinned_version: pinned_version__,
9508 })
9509 }
9510 }
9511 deserializer.deserialize_struct("hummock.PinVersionResponse", FIELDS, GeneratedVisitor)
9512 }
9513}
9514impl serde::Serialize for PinnedVersionsSummary {
9515 #[allow(deprecated)]
9516 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9517 where
9518 S: serde::Serializer,
9519 {
9520 use serde::ser::SerializeStruct;
9521 let mut len = 0;
9522 if !self.pinned_versions.is_empty() {
9523 len += 1;
9524 }
9525 if !self.workers.is_empty() {
9526 len += 1;
9527 }
9528 let mut struct_ser = serializer.serialize_struct("hummock.PinnedVersionsSummary", len)?;
9529 if !self.pinned_versions.is_empty() {
9530 struct_ser.serialize_field("pinnedVersions", &self.pinned_versions)?;
9531 }
9532 if !self.workers.is_empty() {
9533 struct_ser.serialize_field("workers", &self.workers)?;
9534 }
9535 struct_ser.end()
9536 }
9537}
9538impl<'de> serde::Deserialize<'de> for PinnedVersionsSummary {
9539 #[allow(deprecated)]
9540 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9541 where
9542 D: serde::Deserializer<'de>,
9543 {
9544 const FIELDS: &[&str] = &[
9545 "pinned_versions",
9546 "pinnedVersions",
9547 "workers",
9548 ];
9549
9550 #[allow(clippy::enum_variant_names)]
9551 enum GeneratedField {
9552 PinnedVersions,
9553 Workers,
9554 }
9555 impl<'de> serde::Deserialize<'de> for GeneratedField {
9556 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9557 where
9558 D: serde::Deserializer<'de>,
9559 {
9560 struct GeneratedVisitor;
9561
9562 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9563 type Value = GeneratedField;
9564
9565 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9566 write!(formatter, "expected one of: {:?}", &FIELDS)
9567 }
9568
9569 #[allow(unused_variables)]
9570 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9571 where
9572 E: serde::de::Error,
9573 {
9574 match value {
9575 "pinnedVersions" | "pinned_versions" => Ok(GeneratedField::PinnedVersions),
9576 "workers" => Ok(GeneratedField::Workers),
9577 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9578 }
9579 }
9580 }
9581 deserializer.deserialize_identifier(GeneratedVisitor)
9582 }
9583 }
9584 struct GeneratedVisitor;
9585 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9586 type Value = PinnedVersionsSummary;
9587
9588 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9589 formatter.write_str("struct hummock.PinnedVersionsSummary")
9590 }
9591
9592 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinnedVersionsSummary, V::Error>
9593 where
9594 V: serde::de::MapAccess<'de>,
9595 {
9596 let mut pinned_versions__ = None;
9597 let mut workers__ = None;
9598 while let Some(k) = map_.next_key()? {
9599 match k {
9600 GeneratedField::PinnedVersions => {
9601 if pinned_versions__.is_some() {
9602 return Err(serde::de::Error::duplicate_field("pinnedVersions"));
9603 }
9604 pinned_versions__ = Some(map_.next_value()?);
9605 }
9606 GeneratedField::Workers => {
9607 if workers__.is_some() {
9608 return Err(serde::de::Error::duplicate_field("workers"));
9609 }
9610 workers__ = Some(
9611 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9612 .into_iter().map(|(k,v)| (k.0, v)).collect()
9613 );
9614 }
9615 }
9616 }
9617 Ok(PinnedVersionsSummary {
9618 pinned_versions: pinned_versions__.unwrap_or_default(),
9619 workers: workers__.unwrap_or_default(),
9620 })
9621 }
9622 }
9623 deserializer.deserialize_struct("hummock.PinnedVersionsSummary", FIELDS, GeneratedVisitor)
9624 }
9625}
9626impl serde::Serialize for ReplayVersionDeltaRequest {
9627 #[allow(deprecated)]
9628 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9629 where
9630 S: serde::Serializer,
9631 {
9632 use serde::ser::SerializeStruct;
9633 let mut len = 0;
9634 if self.version_delta.is_some() {
9635 len += 1;
9636 }
9637 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaRequest", len)?;
9638 if let Some(v) = self.version_delta.as_ref() {
9639 struct_ser.serialize_field("versionDelta", v)?;
9640 }
9641 struct_ser.end()
9642 }
9643}
9644impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaRequest {
9645 #[allow(deprecated)]
9646 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9647 where
9648 D: serde::Deserializer<'de>,
9649 {
9650 const FIELDS: &[&str] = &[
9651 "version_delta",
9652 "versionDelta",
9653 ];
9654
9655 #[allow(clippy::enum_variant_names)]
9656 enum GeneratedField {
9657 VersionDelta,
9658 }
9659 impl<'de> serde::Deserialize<'de> for GeneratedField {
9660 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9661 where
9662 D: serde::Deserializer<'de>,
9663 {
9664 struct GeneratedVisitor;
9665
9666 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9667 type Value = GeneratedField;
9668
9669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9670 write!(formatter, "expected one of: {:?}", &FIELDS)
9671 }
9672
9673 #[allow(unused_variables)]
9674 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9675 where
9676 E: serde::de::Error,
9677 {
9678 match value {
9679 "versionDelta" | "version_delta" => Ok(GeneratedField::VersionDelta),
9680 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9681 }
9682 }
9683 }
9684 deserializer.deserialize_identifier(GeneratedVisitor)
9685 }
9686 }
9687 struct GeneratedVisitor;
9688 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9689 type Value = ReplayVersionDeltaRequest;
9690
9691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9692 formatter.write_str("struct hummock.ReplayVersionDeltaRequest")
9693 }
9694
9695 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaRequest, V::Error>
9696 where
9697 V: serde::de::MapAccess<'de>,
9698 {
9699 let mut version_delta__ = None;
9700 while let Some(k) = map_.next_key()? {
9701 match k {
9702 GeneratedField::VersionDelta => {
9703 if version_delta__.is_some() {
9704 return Err(serde::de::Error::duplicate_field("versionDelta"));
9705 }
9706 version_delta__ = map_.next_value()?;
9707 }
9708 }
9709 }
9710 Ok(ReplayVersionDeltaRequest {
9711 version_delta: version_delta__,
9712 })
9713 }
9714 }
9715 deserializer.deserialize_struct("hummock.ReplayVersionDeltaRequest", FIELDS, GeneratedVisitor)
9716 }
9717}
9718impl serde::Serialize for ReplayVersionDeltaResponse {
9719 #[allow(deprecated)]
9720 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9721 where
9722 S: serde::Serializer,
9723 {
9724 use serde::ser::SerializeStruct;
9725 let mut len = 0;
9726 if self.version.is_some() {
9727 len += 1;
9728 }
9729 if !self.modified_compaction_groups.is_empty() {
9730 len += 1;
9731 }
9732 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaResponse", len)?;
9733 if let Some(v) = self.version.as_ref() {
9734 struct_ser.serialize_field("version", v)?;
9735 }
9736 if !self.modified_compaction_groups.is_empty() {
9737 struct_ser.serialize_field("modifiedCompactionGroups", &self.modified_compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
9738 }
9739 struct_ser.end()
9740 }
9741}
9742impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaResponse {
9743 #[allow(deprecated)]
9744 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9745 where
9746 D: serde::Deserializer<'de>,
9747 {
9748 const FIELDS: &[&str] = &[
9749 "version",
9750 "modified_compaction_groups",
9751 "modifiedCompactionGroups",
9752 ];
9753
9754 #[allow(clippy::enum_variant_names)]
9755 enum GeneratedField {
9756 Version,
9757 ModifiedCompactionGroups,
9758 }
9759 impl<'de> serde::Deserialize<'de> for GeneratedField {
9760 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9761 where
9762 D: serde::Deserializer<'de>,
9763 {
9764 struct GeneratedVisitor;
9765
9766 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9767 type Value = GeneratedField;
9768
9769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9770 write!(formatter, "expected one of: {:?}", &FIELDS)
9771 }
9772
9773 #[allow(unused_variables)]
9774 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9775 where
9776 E: serde::de::Error,
9777 {
9778 match value {
9779 "version" => Ok(GeneratedField::Version),
9780 "modifiedCompactionGroups" | "modified_compaction_groups" => Ok(GeneratedField::ModifiedCompactionGroups),
9781 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9782 }
9783 }
9784 }
9785 deserializer.deserialize_identifier(GeneratedVisitor)
9786 }
9787 }
9788 struct GeneratedVisitor;
9789 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9790 type Value = ReplayVersionDeltaResponse;
9791
9792 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9793 formatter.write_str("struct hummock.ReplayVersionDeltaResponse")
9794 }
9795
9796 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaResponse, V::Error>
9797 where
9798 V: serde::de::MapAccess<'de>,
9799 {
9800 let mut version__ = None;
9801 let mut modified_compaction_groups__ = None;
9802 while let Some(k) = map_.next_key()? {
9803 match k {
9804 GeneratedField::Version => {
9805 if version__.is_some() {
9806 return Err(serde::de::Error::duplicate_field("version"));
9807 }
9808 version__ = map_.next_value()?;
9809 }
9810 GeneratedField::ModifiedCompactionGroups => {
9811 if modified_compaction_groups__.is_some() {
9812 return Err(serde::de::Error::duplicate_field("modifiedCompactionGroups"));
9813 }
9814 modified_compaction_groups__ =
9815 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9816 .into_iter().map(|x| x.0).collect())
9817 ;
9818 }
9819 }
9820 }
9821 Ok(ReplayVersionDeltaResponse {
9822 version: version__,
9823 modified_compaction_groups: modified_compaction_groups__.unwrap_or_default(),
9824 })
9825 }
9826 }
9827 deserializer.deserialize_struct("hummock.ReplayVersionDeltaResponse", FIELDS, GeneratedVisitor)
9828 }
9829}
9830impl serde::Serialize for ReportCompactionTaskRequest {
9831 #[allow(deprecated)]
9832 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9833 where
9834 S: serde::Serializer,
9835 {
9836 use serde::ser::SerializeStruct;
9837 let mut len = 0;
9838 if self.event.is_some() {
9839 len += 1;
9840 }
9841 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest", len)?;
9842 if let Some(v) = self.event.as_ref() {
9843 match v {
9844 report_compaction_task_request::Event::ReportTask(v) => {
9845 struct_ser.serialize_field("reportTask", v)?;
9846 }
9847 report_compaction_task_request::Event::HeartBeat(v) => {
9848 struct_ser.serialize_field("heartBeat", v)?;
9849 }
9850 }
9851 }
9852 struct_ser.end()
9853 }
9854}
9855impl<'de> serde::Deserialize<'de> for ReportCompactionTaskRequest {
9856 #[allow(deprecated)]
9857 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9858 where
9859 D: serde::Deserializer<'de>,
9860 {
9861 const FIELDS: &[&str] = &[
9862 "report_task",
9863 "reportTask",
9864 "heart_beat",
9865 "heartBeat",
9866 ];
9867
9868 #[allow(clippy::enum_variant_names)]
9869 enum GeneratedField {
9870 ReportTask,
9871 HeartBeat,
9872 }
9873 impl<'de> serde::Deserialize<'de> for GeneratedField {
9874 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9875 where
9876 D: serde::Deserializer<'de>,
9877 {
9878 struct GeneratedVisitor;
9879
9880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9881 type Value = GeneratedField;
9882
9883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9884 write!(formatter, "expected one of: {:?}", &FIELDS)
9885 }
9886
9887 #[allow(unused_variables)]
9888 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9889 where
9890 E: serde::de::Error,
9891 {
9892 match value {
9893 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
9894 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
9895 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9896 }
9897 }
9898 }
9899 deserializer.deserialize_identifier(GeneratedVisitor)
9900 }
9901 }
9902 struct GeneratedVisitor;
9903 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9904 type Value = ReportCompactionTaskRequest;
9905
9906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9907 formatter.write_str("struct hummock.ReportCompactionTaskRequest")
9908 }
9909
9910 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskRequest, V::Error>
9911 where
9912 V: serde::de::MapAccess<'de>,
9913 {
9914 let mut event__ = None;
9915 while let Some(k) = map_.next_key()? {
9916 match k {
9917 GeneratedField::ReportTask => {
9918 if event__.is_some() {
9919 return Err(serde::de::Error::duplicate_field("reportTask"));
9920 }
9921 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::ReportTask)
9922;
9923 }
9924 GeneratedField::HeartBeat => {
9925 if event__.is_some() {
9926 return Err(serde::de::Error::duplicate_field("heartBeat"));
9927 }
9928 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::HeartBeat)
9929;
9930 }
9931 }
9932 }
9933 Ok(ReportCompactionTaskRequest {
9934 event: event__,
9935 })
9936 }
9937 }
9938 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest", FIELDS, GeneratedVisitor)
9939 }
9940}
9941impl serde::Serialize for report_compaction_task_request::HeartBeat {
9942 #[allow(deprecated)]
9943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9944 where
9945 S: serde::Serializer,
9946 {
9947 use serde::ser::SerializeStruct;
9948 let mut len = 0;
9949 if !self.progress.is_empty() {
9950 len += 1;
9951 }
9952 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", len)?;
9953 if !self.progress.is_empty() {
9954 struct_ser.serialize_field("progress", &self.progress)?;
9955 }
9956 struct_ser.end()
9957 }
9958}
9959impl<'de> serde::Deserialize<'de> for report_compaction_task_request::HeartBeat {
9960 #[allow(deprecated)]
9961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9962 where
9963 D: serde::Deserializer<'de>,
9964 {
9965 const FIELDS: &[&str] = &[
9966 "progress",
9967 ];
9968
9969 #[allow(clippy::enum_variant_names)]
9970 enum GeneratedField {
9971 Progress,
9972 }
9973 impl<'de> serde::Deserialize<'de> for GeneratedField {
9974 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9975 where
9976 D: serde::Deserializer<'de>,
9977 {
9978 struct GeneratedVisitor;
9979
9980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9981 type Value = GeneratedField;
9982
9983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9984 write!(formatter, "expected one of: {:?}", &FIELDS)
9985 }
9986
9987 #[allow(unused_variables)]
9988 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9989 where
9990 E: serde::de::Error,
9991 {
9992 match value {
9993 "progress" => Ok(GeneratedField::Progress),
9994 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9995 }
9996 }
9997 }
9998 deserializer.deserialize_identifier(GeneratedVisitor)
9999 }
10000 }
10001 struct GeneratedVisitor;
10002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10003 type Value = report_compaction_task_request::HeartBeat;
10004
10005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10006 formatter.write_str("struct hummock.ReportCompactionTaskRequest.HeartBeat")
10007 }
10008
10009 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::HeartBeat, V::Error>
10010 where
10011 V: serde::de::MapAccess<'de>,
10012 {
10013 let mut progress__ = None;
10014 while let Some(k) = map_.next_key()? {
10015 match k {
10016 GeneratedField::Progress => {
10017 if progress__.is_some() {
10018 return Err(serde::de::Error::duplicate_field("progress"));
10019 }
10020 progress__ = Some(map_.next_value()?);
10021 }
10022 }
10023 }
10024 Ok(report_compaction_task_request::HeartBeat {
10025 progress: progress__.unwrap_or_default(),
10026 })
10027 }
10028 }
10029 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", FIELDS, GeneratedVisitor)
10030 }
10031}
10032impl serde::Serialize for report_compaction_task_request::ReportTask {
10033 #[allow(deprecated)]
10034 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10035 where
10036 S: serde::Serializer,
10037 {
10038 use serde::ser::SerializeStruct;
10039 let mut len = 0;
10040 if self.compact_task.is_some() {
10041 len += 1;
10042 }
10043 if !self.table_stats_change.is_empty() {
10044 len += 1;
10045 }
10046 if !self.object_timestamps.is_empty() {
10047 len += 1;
10048 }
10049 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", len)?;
10050 if let Some(v) = self.compact_task.as_ref() {
10051 struct_ser.serialize_field("compactTask", v)?;
10052 }
10053 if !self.table_stats_change.is_empty() {
10054 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
10055 }
10056 if !self.object_timestamps.is_empty() {
10057 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
10058 .map(|(k, v)| (k, v.to_string())).collect();
10059 struct_ser.serialize_field("objectTimestamps", &v)?;
10060 }
10061 struct_ser.end()
10062 }
10063}
10064impl<'de> serde::Deserialize<'de> for report_compaction_task_request::ReportTask {
10065 #[allow(deprecated)]
10066 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10067 where
10068 D: serde::Deserializer<'de>,
10069 {
10070 const FIELDS: &[&str] = &[
10071 "compact_task",
10072 "compactTask",
10073 "table_stats_change",
10074 "tableStatsChange",
10075 "object_timestamps",
10076 "objectTimestamps",
10077 ];
10078
10079 #[allow(clippy::enum_variant_names)]
10080 enum GeneratedField {
10081 CompactTask,
10082 TableStatsChange,
10083 ObjectTimestamps,
10084 }
10085 impl<'de> serde::Deserialize<'de> for GeneratedField {
10086 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10087 where
10088 D: serde::Deserializer<'de>,
10089 {
10090 struct GeneratedVisitor;
10091
10092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10093 type Value = GeneratedField;
10094
10095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10096 write!(formatter, "expected one of: {:?}", &FIELDS)
10097 }
10098
10099 #[allow(unused_variables)]
10100 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10101 where
10102 E: serde::de::Error,
10103 {
10104 match value {
10105 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
10106 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
10107 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
10108 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10109 }
10110 }
10111 }
10112 deserializer.deserialize_identifier(GeneratedVisitor)
10113 }
10114 }
10115 struct GeneratedVisitor;
10116 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10117 type Value = report_compaction_task_request::ReportTask;
10118
10119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10120 formatter.write_str("struct hummock.ReportCompactionTaskRequest.ReportTask")
10121 }
10122
10123 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::ReportTask, V::Error>
10124 where
10125 V: serde::de::MapAccess<'de>,
10126 {
10127 let mut compact_task__ = None;
10128 let mut table_stats_change__ = None;
10129 let mut object_timestamps__ = None;
10130 while let Some(k) = map_.next_key()? {
10131 match k {
10132 GeneratedField::CompactTask => {
10133 if compact_task__.is_some() {
10134 return Err(serde::de::Error::duplicate_field("compactTask"));
10135 }
10136 compact_task__ = map_.next_value()?;
10137 }
10138 GeneratedField::TableStatsChange => {
10139 if table_stats_change__.is_some() {
10140 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
10141 }
10142 table_stats_change__ = Some(
10143 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10144 .into_iter().map(|(k,v)| (k.0, v)).collect()
10145 );
10146 }
10147 GeneratedField::ObjectTimestamps => {
10148 if object_timestamps__.is_some() {
10149 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
10150 }
10151 object_timestamps__ = Some(
10152 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
10153 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
10154 );
10155 }
10156 }
10157 }
10158 Ok(report_compaction_task_request::ReportTask {
10159 compact_task: compact_task__,
10160 table_stats_change: table_stats_change__.unwrap_or_default(),
10161 object_timestamps: object_timestamps__.unwrap_or_default(),
10162 })
10163 }
10164 }
10165 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", FIELDS, GeneratedVisitor)
10166 }
10167}
10168impl serde::Serialize for ReportCompactionTaskResponse {
10169 #[allow(deprecated)]
10170 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10171 where
10172 S: serde::Serializer,
10173 {
10174 use serde::ser::SerializeStruct;
10175 let mut len = 0;
10176 if self.status.is_some() {
10177 len += 1;
10178 }
10179 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskResponse", len)?;
10180 if let Some(v) = self.status.as_ref() {
10181 struct_ser.serialize_field("status", v)?;
10182 }
10183 struct_ser.end()
10184 }
10185}
10186impl<'de> serde::Deserialize<'de> for ReportCompactionTaskResponse {
10187 #[allow(deprecated)]
10188 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10189 where
10190 D: serde::Deserializer<'de>,
10191 {
10192 const FIELDS: &[&str] = &[
10193 "status",
10194 ];
10195
10196 #[allow(clippy::enum_variant_names)]
10197 enum GeneratedField {
10198 Status,
10199 }
10200 impl<'de> serde::Deserialize<'de> for GeneratedField {
10201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10202 where
10203 D: serde::Deserializer<'de>,
10204 {
10205 struct GeneratedVisitor;
10206
10207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10208 type Value = GeneratedField;
10209
10210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10211 write!(formatter, "expected one of: {:?}", &FIELDS)
10212 }
10213
10214 #[allow(unused_variables)]
10215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10216 where
10217 E: serde::de::Error,
10218 {
10219 match value {
10220 "status" => Ok(GeneratedField::Status),
10221 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10222 }
10223 }
10224 }
10225 deserializer.deserialize_identifier(GeneratedVisitor)
10226 }
10227 }
10228 struct GeneratedVisitor;
10229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10230 type Value = ReportCompactionTaskResponse;
10231
10232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10233 formatter.write_str("struct hummock.ReportCompactionTaskResponse")
10234 }
10235
10236 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskResponse, V::Error>
10237 where
10238 V: serde::de::MapAccess<'de>,
10239 {
10240 let mut status__ = None;
10241 while let Some(k) = map_.next_key()? {
10242 match k {
10243 GeneratedField::Status => {
10244 if status__.is_some() {
10245 return Err(serde::de::Error::duplicate_field("status"));
10246 }
10247 status__ = map_.next_value()?;
10248 }
10249 }
10250 }
10251 Ok(ReportCompactionTaskResponse {
10252 status: status__,
10253 })
10254 }
10255 }
10256 deserializer.deserialize_struct("hummock.ReportCompactionTaskResponse", FIELDS, GeneratedVisitor)
10257 }
10258}
10259impl serde::Serialize for RiseCtlGetCheckpointVersionRequest {
10260 #[allow(deprecated)]
10261 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10262 where
10263 S: serde::Serializer,
10264 {
10265 use serde::ser::SerializeStruct;
10266 let len = 0;
10267 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", len)?;
10268 struct_ser.end()
10269 }
10270}
10271impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionRequest {
10272 #[allow(deprecated)]
10273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10274 where
10275 D: serde::Deserializer<'de>,
10276 {
10277 const FIELDS: &[&str] = &[
10278 ];
10279
10280 #[allow(clippy::enum_variant_names)]
10281 enum GeneratedField {
10282 }
10283 impl<'de> serde::Deserialize<'de> for GeneratedField {
10284 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10285 where
10286 D: serde::Deserializer<'de>,
10287 {
10288 struct GeneratedVisitor;
10289
10290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10291 type Value = GeneratedField;
10292
10293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10294 write!(formatter, "expected one of: {:?}", &FIELDS)
10295 }
10296
10297 #[allow(unused_variables)]
10298 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10299 where
10300 E: serde::de::Error,
10301 {
10302 Err(serde::de::Error::unknown_field(value, FIELDS))
10303 }
10304 }
10305 deserializer.deserialize_identifier(GeneratedVisitor)
10306 }
10307 }
10308 struct GeneratedVisitor;
10309 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10310 type Value = RiseCtlGetCheckpointVersionRequest;
10311
10312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10313 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionRequest")
10314 }
10315
10316 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionRequest, V::Error>
10317 where
10318 V: serde::de::MapAccess<'de>,
10319 {
10320 while map_.next_key::<GeneratedField>()?.is_some() {
10321 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10322 }
10323 Ok(RiseCtlGetCheckpointVersionRequest {
10324 })
10325 }
10326 }
10327 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", FIELDS, GeneratedVisitor)
10328 }
10329}
10330impl serde::Serialize for RiseCtlGetCheckpointVersionResponse {
10331 #[allow(deprecated)]
10332 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10333 where
10334 S: serde::Serializer,
10335 {
10336 use serde::ser::SerializeStruct;
10337 let mut len = 0;
10338 if self.checkpoint_version.is_some() {
10339 len += 1;
10340 }
10341 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", len)?;
10342 if let Some(v) = self.checkpoint_version.as_ref() {
10343 struct_ser.serialize_field("checkpointVersion", v)?;
10344 }
10345 struct_ser.end()
10346 }
10347}
10348impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionResponse {
10349 #[allow(deprecated)]
10350 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10351 where
10352 D: serde::Deserializer<'de>,
10353 {
10354 const FIELDS: &[&str] = &[
10355 "checkpoint_version",
10356 "checkpointVersion",
10357 ];
10358
10359 #[allow(clippy::enum_variant_names)]
10360 enum GeneratedField {
10361 CheckpointVersion,
10362 }
10363 impl<'de> serde::Deserialize<'de> for GeneratedField {
10364 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10365 where
10366 D: serde::Deserializer<'de>,
10367 {
10368 struct GeneratedVisitor;
10369
10370 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10371 type Value = GeneratedField;
10372
10373 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10374 write!(formatter, "expected one of: {:?}", &FIELDS)
10375 }
10376
10377 #[allow(unused_variables)]
10378 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10379 where
10380 E: serde::de::Error,
10381 {
10382 match value {
10383 "checkpointVersion" | "checkpoint_version" => Ok(GeneratedField::CheckpointVersion),
10384 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10385 }
10386 }
10387 }
10388 deserializer.deserialize_identifier(GeneratedVisitor)
10389 }
10390 }
10391 struct GeneratedVisitor;
10392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10393 type Value = RiseCtlGetCheckpointVersionResponse;
10394
10395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10396 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionResponse")
10397 }
10398
10399 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionResponse, V::Error>
10400 where
10401 V: serde::de::MapAccess<'de>,
10402 {
10403 let mut checkpoint_version__ = None;
10404 while let Some(k) = map_.next_key()? {
10405 match k {
10406 GeneratedField::CheckpointVersion => {
10407 if checkpoint_version__.is_some() {
10408 return Err(serde::de::Error::duplicate_field("checkpointVersion"));
10409 }
10410 checkpoint_version__ = map_.next_value()?;
10411 }
10412 }
10413 }
10414 Ok(RiseCtlGetCheckpointVersionResponse {
10415 checkpoint_version: checkpoint_version__,
10416 })
10417 }
10418 }
10419 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", FIELDS, GeneratedVisitor)
10420 }
10421}
10422impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryRequest {
10423 #[allow(deprecated)]
10424 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10425 where
10426 S: serde::Serializer,
10427 {
10428 use serde::ser::SerializeStruct;
10429 let len = 0;
10430 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", len)?;
10431 struct_ser.end()
10432 }
10433}
10434impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryRequest {
10435 #[allow(deprecated)]
10436 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10437 where
10438 D: serde::Deserializer<'de>,
10439 {
10440 const FIELDS: &[&str] = &[
10441 ];
10442
10443 #[allow(clippy::enum_variant_names)]
10444 enum GeneratedField {
10445 }
10446 impl<'de> serde::Deserialize<'de> for GeneratedField {
10447 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10448 where
10449 D: serde::Deserializer<'de>,
10450 {
10451 struct GeneratedVisitor;
10452
10453 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10454 type Value = GeneratedField;
10455
10456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10457 write!(formatter, "expected one of: {:?}", &FIELDS)
10458 }
10459
10460 #[allow(unused_variables)]
10461 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10462 where
10463 E: serde::de::Error,
10464 {
10465 Err(serde::de::Error::unknown_field(value, FIELDS))
10466 }
10467 }
10468 deserializer.deserialize_identifier(GeneratedVisitor)
10469 }
10470 }
10471 struct GeneratedVisitor;
10472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10473 type Value = RiseCtlGetPinnedVersionsSummaryRequest;
10474
10475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10476 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryRequest")
10477 }
10478
10479 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryRequest, V::Error>
10480 where
10481 V: serde::de::MapAccess<'de>,
10482 {
10483 while map_.next_key::<GeneratedField>()?.is_some() {
10484 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10485 }
10486 Ok(RiseCtlGetPinnedVersionsSummaryRequest {
10487 })
10488 }
10489 }
10490 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", FIELDS, GeneratedVisitor)
10491 }
10492}
10493impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryResponse {
10494 #[allow(deprecated)]
10495 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10496 where
10497 S: serde::Serializer,
10498 {
10499 use serde::ser::SerializeStruct;
10500 let mut len = 0;
10501 if self.summary.is_some() {
10502 len += 1;
10503 }
10504 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", len)?;
10505 if let Some(v) = self.summary.as_ref() {
10506 struct_ser.serialize_field("summary", v)?;
10507 }
10508 struct_ser.end()
10509 }
10510}
10511impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryResponse {
10512 #[allow(deprecated)]
10513 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10514 where
10515 D: serde::Deserializer<'de>,
10516 {
10517 const FIELDS: &[&str] = &[
10518 "summary",
10519 ];
10520
10521 #[allow(clippy::enum_variant_names)]
10522 enum GeneratedField {
10523 Summary,
10524 }
10525 impl<'de> serde::Deserialize<'de> for GeneratedField {
10526 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10527 where
10528 D: serde::Deserializer<'de>,
10529 {
10530 struct GeneratedVisitor;
10531
10532 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10533 type Value = GeneratedField;
10534
10535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10536 write!(formatter, "expected one of: {:?}", &FIELDS)
10537 }
10538
10539 #[allow(unused_variables)]
10540 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10541 where
10542 E: serde::de::Error,
10543 {
10544 match value {
10545 "summary" => Ok(GeneratedField::Summary),
10546 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10547 }
10548 }
10549 }
10550 deserializer.deserialize_identifier(GeneratedVisitor)
10551 }
10552 }
10553 struct GeneratedVisitor;
10554 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10555 type Value = RiseCtlGetPinnedVersionsSummaryResponse;
10556
10557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10558 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryResponse")
10559 }
10560
10561 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryResponse, V::Error>
10562 where
10563 V: serde::de::MapAccess<'de>,
10564 {
10565 let mut summary__ = None;
10566 while let Some(k) = map_.next_key()? {
10567 match k {
10568 GeneratedField::Summary => {
10569 if summary__.is_some() {
10570 return Err(serde::de::Error::duplicate_field("summary"));
10571 }
10572 summary__ = map_.next_value()?;
10573 }
10574 }
10575 }
10576 Ok(RiseCtlGetPinnedVersionsSummaryResponse {
10577 summary: summary__,
10578 })
10579 }
10580 }
10581 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", FIELDS, GeneratedVisitor)
10582 }
10583}
10584impl serde::Serialize for RiseCtlListCompactionGroupRequest {
10585 #[allow(deprecated)]
10586 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10587 where
10588 S: serde::Serializer,
10589 {
10590 use serde::ser::SerializeStruct;
10591 let len = 0;
10592 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupRequest", len)?;
10593 struct_ser.end()
10594 }
10595}
10596impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupRequest {
10597 #[allow(deprecated)]
10598 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10599 where
10600 D: serde::Deserializer<'de>,
10601 {
10602 const FIELDS: &[&str] = &[
10603 ];
10604
10605 #[allow(clippy::enum_variant_names)]
10606 enum GeneratedField {
10607 }
10608 impl<'de> serde::Deserialize<'de> for GeneratedField {
10609 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10610 where
10611 D: serde::Deserializer<'de>,
10612 {
10613 struct GeneratedVisitor;
10614
10615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10616 type Value = GeneratedField;
10617
10618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10619 write!(formatter, "expected one of: {:?}", &FIELDS)
10620 }
10621
10622 #[allow(unused_variables)]
10623 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10624 where
10625 E: serde::de::Error,
10626 {
10627 Err(serde::de::Error::unknown_field(value, FIELDS))
10628 }
10629 }
10630 deserializer.deserialize_identifier(GeneratedVisitor)
10631 }
10632 }
10633 struct GeneratedVisitor;
10634 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10635 type Value = RiseCtlListCompactionGroupRequest;
10636
10637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10638 formatter.write_str("struct hummock.RiseCtlListCompactionGroupRequest")
10639 }
10640
10641 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupRequest, V::Error>
10642 where
10643 V: serde::de::MapAccess<'de>,
10644 {
10645 while map_.next_key::<GeneratedField>()?.is_some() {
10646 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10647 }
10648 Ok(RiseCtlListCompactionGroupRequest {
10649 })
10650 }
10651 }
10652 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupRequest", FIELDS, GeneratedVisitor)
10653 }
10654}
10655impl serde::Serialize for RiseCtlListCompactionGroupResponse {
10656 #[allow(deprecated)]
10657 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10658 where
10659 S: serde::Serializer,
10660 {
10661 use serde::ser::SerializeStruct;
10662 let mut len = 0;
10663 if self.status.is_some() {
10664 len += 1;
10665 }
10666 if !self.compaction_groups.is_empty() {
10667 len += 1;
10668 }
10669 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupResponse", len)?;
10670 if let Some(v) = self.status.as_ref() {
10671 struct_ser.serialize_field("status", v)?;
10672 }
10673 if !self.compaction_groups.is_empty() {
10674 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
10675 }
10676 struct_ser.end()
10677 }
10678}
10679impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupResponse {
10680 #[allow(deprecated)]
10681 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10682 where
10683 D: serde::Deserializer<'de>,
10684 {
10685 const FIELDS: &[&str] = &[
10686 "status",
10687 "compaction_groups",
10688 "compactionGroups",
10689 ];
10690
10691 #[allow(clippy::enum_variant_names)]
10692 enum GeneratedField {
10693 Status,
10694 CompactionGroups,
10695 }
10696 impl<'de> serde::Deserialize<'de> for GeneratedField {
10697 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10698 where
10699 D: serde::Deserializer<'de>,
10700 {
10701 struct GeneratedVisitor;
10702
10703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10704 type Value = GeneratedField;
10705
10706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10707 write!(formatter, "expected one of: {:?}", &FIELDS)
10708 }
10709
10710 #[allow(unused_variables)]
10711 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10712 where
10713 E: serde::de::Error,
10714 {
10715 match value {
10716 "status" => Ok(GeneratedField::Status),
10717 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
10718 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10719 }
10720 }
10721 }
10722 deserializer.deserialize_identifier(GeneratedVisitor)
10723 }
10724 }
10725 struct GeneratedVisitor;
10726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10727 type Value = RiseCtlListCompactionGroupResponse;
10728
10729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10730 formatter.write_str("struct hummock.RiseCtlListCompactionGroupResponse")
10731 }
10732
10733 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupResponse, V::Error>
10734 where
10735 V: serde::de::MapAccess<'de>,
10736 {
10737 let mut status__ = None;
10738 let mut compaction_groups__ = None;
10739 while let Some(k) = map_.next_key()? {
10740 match k {
10741 GeneratedField::Status => {
10742 if status__.is_some() {
10743 return Err(serde::de::Error::duplicate_field("status"));
10744 }
10745 status__ = map_.next_value()?;
10746 }
10747 GeneratedField::CompactionGroups => {
10748 if compaction_groups__.is_some() {
10749 return Err(serde::de::Error::duplicate_field("compactionGroups"));
10750 }
10751 compaction_groups__ = Some(map_.next_value()?);
10752 }
10753 }
10754 }
10755 Ok(RiseCtlListCompactionGroupResponse {
10756 status: status__,
10757 compaction_groups: compaction_groups__.unwrap_or_default(),
10758 })
10759 }
10760 }
10761 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupResponse", FIELDS, GeneratedVisitor)
10762 }
10763}
10764impl serde::Serialize for RiseCtlListCompactionStatusRequest {
10765 #[allow(deprecated)]
10766 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10767 where
10768 S: serde::Serializer,
10769 {
10770 use serde::ser::SerializeStruct;
10771 let len = 0;
10772 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusRequest", len)?;
10773 struct_ser.end()
10774 }
10775}
10776impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusRequest {
10777 #[allow(deprecated)]
10778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10779 where
10780 D: serde::Deserializer<'de>,
10781 {
10782 const FIELDS: &[&str] = &[
10783 ];
10784
10785 #[allow(clippy::enum_variant_names)]
10786 enum GeneratedField {
10787 }
10788 impl<'de> serde::Deserialize<'de> for GeneratedField {
10789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10790 where
10791 D: serde::Deserializer<'de>,
10792 {
10793 struct GeneratedVisitor;
10794
10795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10796 type Value = GeneratedField;
10797
10798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10799 write!(formatter, "expected one of: {:?}", &FIELDS)
10800 }
10801
10802 #[allow(unused_variables)]
10803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10804 where
10805 E: serde::de::Error,
10806 {
10807 Err(serde::de::Error::unknown_field(value, FIELDS))
10808 }
10809 }
10810 deserializer.deserialize_identifier(GeneratedVisitor)
10811 }
10812 }
10813 struct GeneratedVisitor;
10814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10815 type Value = RiseCtlListCompactionStatusRequest;
10816
10817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10818 formatter.write_str("struct hummock.RiseCtlListCompactionStatusRequest")
10819 }
10820
10821 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusRequest, V::Error>
10822 where
10823 V: serde::de::MapAccess<'de>,
10824 {
10825 while map_.next_key::<GeneratedField>()?.is_some() {
10826 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10827 }
10828 Ok(RiseCtlListCompactionStatusRequest {
10829 })
10830 }
10831 }
10832 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusRequest", FIELDS, GeneratedVisitor)
10833 }
10834}
10835impl serde::Serialize for RiseCtlListCompactionStatusResponse {
10836 #[allow(deprecated)]
10837 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10838 where
10839 S: serde::Serializer,
10840 {
10841 use serde::ser::SerializeStruct;
10842 let mut len = 0;
10843 if !self.compaction_statuses.is_empty() {
10844 len += 1;
10845 }
10846 if !self.task_assignment.is_empty() {
10847 len += 1;
10848 }
10849 if !self.task_progress.is_empty() {
10850 len += 1;
10851 }
10852 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusResponse", len)?;
10853 if !self.compaction_statuses.is_empty() {
10854 struct_ser.serialize_field("compactionStatuses", &self.compaction_statuses)?;
10855 }
10856 if !self.task_assignment.is_empty() {
10857 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
10858 }
10859 if !self.task_progress.is_empty() {
10860 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
10861 }
10862 struct_ser.end()
10863 }
10864}
10865impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusResponse {
10866 #[allow(deprecated)]
10867 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10868 where
10869 D: serde::Deserializer<'de>,
10870 {
10871 const FIELDS: &[&str] = &[
10872 "compaction_statuses",
10873 "compactionStatuses",
10874 "task_assignment",
10875 "taskAssignment",
10876 "task_progress",
10877 "taskProgress",
10878 ];
10879
10880 #[allow(clippy::enum_variant_names)]
10881 enum GeneratedField {
10882 CompactionStatuses,
10883 TaskAssignment,
10884 TaskProgress,
10885 }
10886 impl<'de> serde::Deserialize<'de> for GeneratedField {
10887 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10888 where
10889 D: serde::Deserializer<'de>,
10890 {
10891 struct GeneratedVisitor;
10892
10893 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10894 type Value = GeneratedField;
10895
10896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10897 write!(formatter, "expected one of: {:?}", &FIELDS)
10898 }
10899
10900 #[allow(unused_variables)]
10901 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10902 where
10903 E: serde::de::Error,
10904 {
10905 match value {
10906 "compactionStatuses" | "compaction_statuses" => Ok(GeneratedField::CompactionStatuses),
10907 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
10908 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
10909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10910 }
10911 }
10912 }
10913 deserializer.deserialize_identifier(GeneratedVisitor)
10914 }
10915 }
10916 struct GeneratedVisitor;
10917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10918 type Value = RiseCtlListCompactionStatusResponse;
10919
10920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10921 formatter.write_str("struct hummock.RiseCtlListCompactionStatusResponse")
10922 }
10923
10924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusResponse, V::Error>
10925 where
10926 V: serde::de::MapAccess<'de>,
10927 {
10928 let mut compaction_statuses__ = None;
10929 let mut task_assignment__ = None;
10930 let mut task_progress__ = None;
10931 while let Some(k) = map_.next_key()? {
10932 match k {
10933 GeneratedField::CompactionStatuses => {
10934 if compaction_statuses__.is_some() {
10935 return Err(serde::de::Error::duplicate_field("compactionStatuses"));
10936 }
10937 compaction_statuses__ = Some(map_.next_value()?);
10938 }
10939 GeneratedField::TaskAssignment => {
10940 if task_assignment__.is_some() {
10941 return Err(serde::de::Error::duplicate_field("taskAssignment"));
10942 }
10943 task_assignment__ = Some(map_.next_value()?);
10944 }
10945 GeneratedField::TaskProgress => {
10946 if task_progress__.is_some() {
10947 return Err(serde::de::Error::duplicate_field("taskProgress"));
10948 }
10949 task_progress__ = Some(map_.next_value()?);
10950 }
10951 }
10952 }
10953 Ok(RiseCtlListCompactionStatusResponse {
10954 compaction_statuses: compaction_statuses__.unwrap_or_default(),
10955 task_assignment: task_assignment__.unwrap_or_default(),
10956 task_progress: task_progress__.unwrap_or_default(),
10957 })
10958 }
10959 }
10960 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusResponse", FIELDS, GeneratedVisitor)
10961 }
10962}
10963impl serde::Serialize for RiseCtlPauseVersionCheckpointRequest {
10964 #[allow(deprecated)]
10965 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10966 where
10967 S: serde::Serializer,
10968 {
10969 use serde::ser::SerializeStruct;
10970 let len = 0;
10971 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", len)?;
10972 struct_ser.end()
10973 }
10974}
10975impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointRequest {
10976 #[allow(deprecated)]
10977 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10978 where
10979 D: serde::Deserializer<'de>,
10980 {
10981 const FIELDS: &[&str] = &[
10982 ];
10983
10984 #[allow(clippy::enum_variant_names)]
10985 enum GeneratedField {
10986 }
10987 impl<'de> serde::Deserialize<'de> for GeneratedField {
10988 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10989 where
10990 D: serde::Deserializer<'de>,
10991 {
10992 struct GeneratedVisitor;
10993
10994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10995 type Value = GeneratedField;
10996
10997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10998 write!(formatter, "expected one of: {:?}", &FIELDS)
10999 }
11000
11001 #[allow(unused_variables)]
11002 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11003 where
11004 E: serde::de::Error,
11005 {
11006 Err(serde::de::Error::unknown_field(value, FIELDS))
11007 }
11008 }
11009 deserializer.deserialize_identifier(GeneratedVisitor)
11010 }
11011 }
11012 struct GeneratedVisitor;
11013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11014 type Value = RiseCtlPauseVersionCheckpointRequest;
11015
11016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11017 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointRequest")
11018 }
11019
11020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointRequest, V::Error>
11021 where
11022 V: serde::de::MapAccess<'de>,
11023 {
11024 while map_.next_key::<GeneratedField>()?.is_some() {
11025 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11026 }
11027 Ok(RiseCtlPauseVersionCheckpointRequest {
11028 })
11029 }
11030 }
11031 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", FIELDS, GeneratedVisitor)
11032 }
11033}
11034impl serde::Serialize for RiseCtlPauseVersionCheckpointResponse {
11035 #[allow(deprecated)]
11036 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11037 where
11038 S: serde::Serializer,
11039 {
11040 use serde::ser::SerializeStruct;
11041 let len = 0;
11042 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", len)?;
11043 struct_ser.end()
11044 }
11045}
11046impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointResponse {
11047 #[allow(deprecated)]
11048 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11049 where
11050 D: serde::Deserializer<'de>,
11051 {
11052 const FIELDS: &[&str] = &[
11053 ];
11054
11055 #[allow(clippy::enum_variant_names)]
11056 enum GeneratedField {
11057 }
11058 impl<'de> serde::Deserialize<'de> for GeneratedField {
11059 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11060 where
11061 D: serde::Deserializer<'de>,
11062 {
11063 struct GeneratedVisitor;
11064
11065 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11066 type Value = GeneratedField;
11067
11068 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11069 write!(formatter, "expected one of: {:?}", &FIELDS)
11070 }
11071
11072 #[allow(unused_variables)]
11073 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11074 where
11075 E: serde::de::Error,
11076 {
11077 Err(serde::de::Error::unknown_field(value, FIELDS))
11078 }
11079 }
11080 deserializer.deserialize_identifier(GeneratedVisitor)
11081 }
11082 }
11083 struct GeneratedVisitor;
11084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11085 type Value = RiseCtlPauseVersionCheckpointResponse;
11086
11087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11088 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointResponse")
11089 }
11090
11091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointResponse, V::Error>
11092 where
11093 V: serde::de::MapAccess<'de>,
11094 {
11095 while map_.next_key::<GeneratedField>()?.is_some() {
11096 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11097 }
11098 Ok(RiseCtlPauseVersionCheckpointResponse {
11099 })
11100 }
11101 }
11102 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", FIELDS, GeneratedVisitor)
11103 }
11104}
11105impl serde::Serialize for RiseCtlRebuildTableStatsRequest {
11106 #[allow(deprecated)]
11107 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11108 where
11109 S: serde::Serializer,
11110 {
11111 use serde::ser::SerializeStruct;
11112 let len = 0;
11113 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsRequest", len)?;
11114 struct_ser.end()
11115 }
11116}
11117impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsRequest {
11118 #[allow(deprecated)]
11119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11120 where
11121 D: serde::Deserializer<'de>,
11122 {
11123 const FIELDS: &[&str] = &[
11124 ];
11125
11126 #[allow(clippy::enum_variant_names)]
11127 enum GeneratedField {
11128 }
11129 impl<'de> serde::Deserialize<'de> for GeneratedField {
11130 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11131 where
11132 D: serde::Deserializer<'de>,
11133 {
11134 struct GeneratedVisitor;
11135
11136 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11137 type Value = GeneratedField;
11138
11139 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11140 write!(formatter, "expected one of: {:?}", &FIELDS)
11141 }
11142
11143 #[allow(unused_variables)]
11144 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11145 where
11146 E: serde::de::Error,
11147 {
11148 Err(serde::de::Error::unknown_field(value, FIELDS))
11149 }
11150 }
11151 deserializer.deserialize_identifier(GeneratedVisitor)
11152 }
11153 }
11154 struct GeneratedVisitor;
11155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11156 type Value = RiseCtlRebuildTableStatsRequest;
11157
11158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11159 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsRequest")
11160 }
11161
11162 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsRequest, V::Error>
11163 where
11164 V: serde::de::MapAccess<'de>,
11165 {
11166 while map_.next_key::<GeneratedField>()?.is_some() {
11167 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11168 }
11169 Ok(RiseCtlRebuildTableStatsRequest {
11170 })
11171 }
11172 }
11173 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsRequest", FIELDS, GeneratedVisitor)
11174 }
11175}
11176impl serde::Serialize for RiseCtlRebuildTableStatsResponse {
11177 #[allow(deprecated)]
11178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11179 where
11180 S: serde::Serializer,
11181 {
11182 use serde::ser::SerializeStruct;
11183 let len = 0;
11184 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsResponse", len)?;
11185 struct_ser.end()
11186 }
11187}
11188impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsResponse {
11189 #[allow(deprecated)]
11190 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11191 where
11192 D: serde::Deserializer<'de>,
11193 {
11194 const FIELDS: &[&str] = &[
11195 ];
11196
11197 #[allow(clippy::enum_variant_names)]
11198 enum GeneratedField {
11199 }
11200 impl<'de> serde::Deserialize<'de> for GeneratedField {
11201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11202 where
11203 D: serde::Deserializer<'de>,
11204 {
11205 struct GeneratedVisitor;
11206
11207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11208 type Value = GeneratedField;
11209
11210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11211 write!(formatter, "expected one of: {:?}", &FIELDS)
11212 }
11213
11214 #[allow(unused_variables)]
11215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11216 where
11217 E: serde::de::Error,
11218 {
11219 Err(serde::de::Error::unknown_field(value, FIELDS))
11220 }
11221 }
11222 deserializer.deserialize_identifier(GeneratedVisitor)
11223 }
11224 }
11225 struct GeneratedVisitor;
11226 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11227 type Value = RiseCtlRebuildTableStatsResponse;
11228
11229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11230 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsResponse")
11231 }
11232
11233 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsResponse, V::Error>
11234 where
11235 V: serde::de::MapAccess<'de>,
11236 {
11237 while map_.next_key::<GeneratedField>()?.is_some() {
11238 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11239 }
11240 Ok(RiseCtlRebuildTableStatsResponse {
11241 })
11242 }
11243 }
11244 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsResponse", FIELDS, GeneratedVisitor)
11245 }
11246}
11247impl serde::Serialize for RiseCtlResumeVersionCheckpointRequest {
11248 #[allow(deprecated)]
11249 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11250 where
11251 S: serde::Serializer,
11252 {
11253 use serde::ser::SerializeStruct;
11254 let len = 0;
11255 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", len)?;
11256 struct_ser.end()
11257 }
11258}
11259impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointRequest {
11260 #[allow(deprecated)]
11261 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11262 where
11263 D: serde::Deserializer<'de>,
11264 {
11265 const FIELDS: &[&str] = &[
11266 ];
11267
11268 #[allow(clippy::enum_variant_names)]
11269 enum GeneratedField {
11270 }
11271 impl<'de> serde::Deserialize<'de> for GeneratedField {
11272 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11273 where
11274 D: serde::Deserializer<'de>,
11275 {
11276 struct GeneratedVisitor;
11277
11278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11279 type Value = GeneratedField;
11280
11281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11282 write!(formatter, "expected one of: {:?}", &FIELDS)
11283 }
11284
11285 #[allow(unused_variables)]
11286 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11287 where
11288 E: serde::de::Error,
11289 {
11290 Err(serde::de::Error::unknown_field(value, FIELDS))
11291 }
11292 }
11293 deserializer.deserialize_identifier(GeneratedVisitor)
11294 }
11295 }
11296 struct GeneratedVisitor;
11297 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11298 type Value = RiseCtlResumeVersionCheckpointRequest;
11299
11300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11301 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointRequest")
11302 }
11303
11304 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointRequest, V::Error>
11305 where
11306 V: serde::de::MapAccess<'de>,
11307 {
11308 while map_.next_key::<GeneratedField>()?.is_some() {
11309 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11310 }
11311 Ok(RiseCtlResumeVersionCheckpointRequest {
11312 })
11313 }
11314 }
11315 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", FIELDS, GeneratedVisitor)
11316 }
11317}
11318impl serde::Serialize for RiseCtlResumeVersionCheckpointResponse {
11319 #[allow(deprecated)]
11320 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11321 where
11322 S: serde::Serializer,
11323 {
11324 use serde::ser::SerializeStruct;
11325 let len = 0;
11326 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", len)?;
11327 struct_ser.end()
11328 }
11329}
11330impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointResponse {
11331 #[allow(deprecated)]
11332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11333 where
11334 D: serde::Deserializer<'de>,
11335 {
11336 const FIELDS: &[&str] = &[
11337 ];
11338
11339 #[allow(clippy::enum_variant_names)]
11340 enum GeneratedField {
11341 }
11342 impl<'de> serde::Deserialize<'de> for GeneratedField {
11343 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11344 where
11345 D: serde::Deserializer<'de>,
11346 {
11347 struct GeneratedVisitor;
11348
11349 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11350 type Value = GeneratedField;
11351
11352 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11353 write!(formatter, "expected one of: {:?}", &FIELDS)
11354 }
11355
11356 #[allow(unused_variables)]
11357 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11358 where
11359 E: serde::de::Error,
11360 {
11361 Err(serde::de::Error::unknown_field(value, FIELDS))
11362 }
11363 }
11364 deserializer.deserialize_identifier(GeneratedVisitor)
11365 }
11366 }
11367 struct GeneratedVisitor;
11368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11369 type Value = RiseCtlResumeVersionCheckpointResponse;
11370
11371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11372 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointResponse")
11373 }
11374
11375 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointResponse, V::Error>
11376 where
11377 V: serde::de::MapAccess<'de>,
11378 {
11379 while map_.next_key::<GeneratedField>()?.is_some() {
11380 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11381 }
11382 Ok(RiseCtlResumeVersionCheckpointResponse {
11383 })
11384 }
11385 }
11386 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", FIELDS, GeneratedVisitor)
11387 }
11388}
11389impl serde::Serialize for RiseCtlUpdateCompactionConfigRequest {
11390 #[allow(deprecated)]
11391 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11392 where
11393 S: serde::Serializer,
11394 {
11395 use serde::ser::SerializeStruct;
11396 let mut len = 0;
11397 if !self.compaction_group_ids.is_empty() {
11398 len += 1;
11399 }
11400 if !self.configs.is_empty() {
11401 len += 1;
11402 }
11403 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", len)?;
11404 if !self.compaction_group_ids.is_empty() {
11405 struct_ser.serialize_field("compactionGroupIds", &self.compaction_group_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
11406 }
11407 if !self.configs.is_empty() {
11408 struct_ser.serialize_field("configs", &self.configs)?;
11409 }
11410 struct_ser.end()
11411 }
11412}
11413impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigRequest {
11414 #[allow(deprecated)]
11415 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11416 where
11417 D: serde::Deserializer<'de>,
11418 {
11419 const FIELDS: &[&str] = &[
11420 "compaction_group_ids",
11421 "compactionGroupIds",
11422 "configs",
11423 ];
11424
11425 #[allow(clippy::enum_variant_names)]
11426 enum GeneratedField {
11427 CompactionGroupIds,
11428 Configs,
11429 }
11430 impl<'de> serde::Deserialize<'de> for GeneratedField {
11431 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11432 where
11433 D: serde::Deserializer<'de>,
11434 {
11435 struct GeneratedVisitor;
11436
11437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11438 type Value = GeneratedField;
11439
11440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11441 write!(formatter, "expected one of: {:?}", &FIELDS)
11442 }
11443
11444 #[allow(unused_variables)]
11445 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11446 where
11447 E: serde::de::Error,
11448 {
11449 match value {
11450 "compactionGroupIds" | "compaction_group_ids" => Ok(GeneratedField::CompactionGroupIds),
11451 "configs" => Ok(GeneratedField::Configs),
11452 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11453 }
11454 }
11455 }
11456 deserializer.deserialize_identifier(GeneratedVisitor)
11457 }
11458 }
11459 struct GeneratedVisitor;
11460 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11461 type Value = RiseCtlUpdateCompactionConfigRequest;
11462
11463 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11464 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest")
11465 }
11466
11467 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigRequest, V::Error>
11468 where
11469 V: serde::de::MapAccess<'de>,
11470 {
11471 let mut compaction_group_ids__ = None;
11472 let mut configs__ = None;
11473 while let Some(k) = map_.next_key()? {
11474 match k {
11475 GeneratedField::CompactionGroupIds => {
11476 if compaction_group_ids__.is_some() {
11477 return Err(serde::de::Error::duplicate_field("compactionGroupIds"));
11478 }
11479 compaction_group_ids__ =
11480 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11481 .into_iter().map(|x| x.0).collect())
11482 ;
11483 }
11484 GeneratedField::Configs => {
11485 if configs__.is_some() {
11486 return Err(serde::de::Error::duplicate_field("configs"));
11487 }
11488 configs__ = Some(map_.next_value()?);
11489 }
11490 }
11491 }
11492 Ok(RiseCtlUpdateCompactionConfigRequest {
11493 compaction_group_ids: compaction_group_ids__.unwrap_or_default(),
11494 configs: configs__.unwrap_or_default(),
11495 })
11496 }
11497 }
11498 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", FIELDS, GeneratedVisitor)
11499 }
11500}
11501impl serde::Serialize for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
11502 #[allow(deprecated)]
11503 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11504 where
11505 S: serde::Serializer,
11506 {
11507 use serde::ser::SerializeStruct;
11508 let mut len = 0;
11509 if self.level != 0 {
11510 len += 1;
11511 }
11512 if !self.compression_algorithm.is_empty() {
11513 len += 1;
11514 }
11515 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", len)?;
11516 if self.level != 0 {
11517 struct_ser.serialize_field("level", &self.level)?;
11518 }
11519 if !self.compression_algorithm.is_empty() {
11520 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
11521 }
11522 struct_ser.end()
11523 }
11524}
11525impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
11526 #[allow(deprecated)]
11527 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11528 where
11529 D: serde::Deserializer<'de>,
11530 {
11531 const FIELDS: &[&str] = &[
11532 "level",
11533 "compression_algorithm",
11534 "compressionAlgorithm",
11535 ];
11536
11537 #[allow(clippy::enum_variant_names)]
11538 enum GeneratedField {
11539 Level,
11540 CompressionAlgorithm,
11541 }
11542 impl<'de> serde::Deserialize<'de> for GeneratedField {
11543 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11544 where
11545 D: serde::Deserializer<'de>,
11546 {
11547 struct GeneratedVisitor;
11548
11549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11550 type Value = GeneratedField;
11551
11552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11553 write!(formatter, "expected one of: {:?}", &FIELDS)
11554 }
11555
11556 #[allow(unused_variables)]
11557 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11558 where
11559 E: serde::de::Error,
11560 {
11561 match value {
11562 "level" => Ok(GeneratedField::Level),
11563 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
11564 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11565 }
11566 }
11567 }
11568 deserializer.deserialize_identifier(GeneratedVisitor)
11569 }
11570 }
11571 struct GeneratedVisitor;
11572 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11573 type Value = rise_ctl_update_compaction_config_request::CompressionAlgorithm;
11574
11575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11576 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm")
11577 }
11578
11579 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::CompressionAlgorithm, V::Error>
11580 where
11581 V: serde::de::MapAccess<'de>,
11582 {
11583 let mut level__ = None;
11584 let mut compression_algorithm__ = None;
11585 while let Some(k) = map_.next_key()? {
11586 match k {
11587 GeneratedField::Level => {
11588 if level__.is_some() {
11589 return Err(serde::de::Error::duplicate_field("level"));
11590 }
11591 level__ =
11592 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11593 ;
11594 }
11595 GeneratedField::CompressionAlgorithm => {
11596 if compression_algorithm__.is_some() {
11597 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
11598 }
11599 compression_algorithm__ = Some(map_.next_value()?);
11600 }
11601 }
11602 }
11603 Ok(rise_ctl_update_compaction_config_request::CompressionAlgorithm {
11604 level: level__.unwrap_or_default(),
11605 compression_algorithm: compression_algorithm__.unwrap_or_default(),
11606 })
11607 }
11608 }
11609 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", FIELDS, GeneratedVisitor)
11610 }
11611}
11612impl serde::Serialize for rise_ctl_update_compaction_config_request::MutableConfig {
11613 #[allow(deprecated)]
11614 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11615 where
11616 S: serde::Serializer,
11617 {
11618 use serde::ser::SerializeStruct;
11619 let mut len = 0;
11620 if self.mutable_config.is_some() {
11621 len += 1;
11622 }
11623 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", len)?;
11624 if let Some(v) = self.mutable_config.as_ref() {
11625 match v {
11626 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(v) => {
11627 #[allow(clippy::needless_borrow)]
11628 #[allow(clippy::needless_borrows_for_generic_args)]
11629 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&v).as_str())?;
11630 }
11631 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(v) => {
11632 #[allow(clippy::needless_borrow)]
11633 #[allow(clippy::needless_borrows_for_generic_args)]
11634 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&v).as_str())?;
11635 }
11636 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(v) => {
11637 #[allow(clippy::needless_borrow)]
11638 #[allow(clippy::needless_borrows_for_generic_args)]
11639 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&v).as_str())?;
11640 }
11641 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(v) => {
11642 #[allow(clippy::needless_borrow)]
11643 #[allow(clippy::needless_borrows_for_generic_args)]
11644 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&v).as_str())?;
11645 }
11646 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(v) => {
11647 #[allow(clippy::needless_borrow)]
11648 #[allow(clippy::needless_borrows_for_generic_args)]
11649 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&v).as_str())?;
11650 }
11651 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(v) => {
11652 #[allow(clippy::needless_borrow)]
11653 #[allow(clippy::needless_borrows_for_generic_args)]
11654 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&v).as_str())?;
11655 }
11656 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(v) => {
11657 struct_ser.serialize_field("compactionFilterMask", v)?;
11658 }
11659 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(v) => {
11660 struct_ser.serialize_field("maxSubCompaction", v)?;
11661 }
11662 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(v) => {
11663 #[allow(clippy::needless_borrow)]
11664 #[allow(clippy::needless_borrows_for_generic_args)]
11665 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&v).as_str())?;
11666 }
11667 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(v) => {
11668 struct_ser.serialize_field("level0SubLevelCompactLevelCount", v)?;
11669 }
11670 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(v) => {
11671 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", v)?;
11672 }
11673 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(v) => {
11674 #[allow(clippy::needless_borrow)]
11675 #[allow(clippy::needless_borrows_for_generic_args)]
11676 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&v).as_str())?;
11677 }
11678 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(v) => {
11679 #[allow(clippy::needless_borrow)]
11680 #[allow(clippy::needless_borrows_for_generic_args)]
11681 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&v).as_str())?;
11682 }
11683 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker(v) => {
11684 struct_ser.serialize_field("enableEmergencyPicker", v)?;
11685 }
11686 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(v) => {
11687 struct_ser.serialize_field("tombstoneReclaimRatio", v)?;
11688 }
11689 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm(v) => {
11690 struct_ser.serialize_field("compressionAlgorithm", v)?;
11691 }
11692 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(v) => {
11693 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
11694 }
11695 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(v) => {
11696 #[allow(clippy::needless_borrow)]
11697 #[allow(clippy::needless_borrows_for_generic_args)]
11698 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
11699 }
11700 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(v) => {
11701 struct_ser.serialize_field("splitWeightByVnode", v)?;
11702 }
11703 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling(v) => {
11704 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
11705 }
11706 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(v) => {
11707 #[allow(clippy::needless_borrow)]
11708 #[allow(clippy::needless_borrows_for_generic_args)]
11709 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
11710 }
11711 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(v) => {
11712 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
11713 }
11714 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(v) => {
11715 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
11716 }
11717 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(v) => {
11718 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
11719 }
11720 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(v) => {
11721 #[allow(clippy::needless_borrow)]
11722 #[allow(clippy::needless_borrows_for_generic_args)]
11723 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
11724 }
11725 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(v) => {
11726 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
11727 }
11728 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection(v) => {
11729 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
11730 }
11731 }
11732 }
11733 struct_ser.end()
11734 }
11735}
11736impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::MutableConfig {
11737 #[allow(deprecated)]
11738 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11739 where
11740 D: serde::Deserializer<'de>,
11741 {
11742 const FIELDS: &[&str] = &[
11743 "max_bytes_for_level_base",
11744 "maxBytesForLevelBase",
11745 "max_bytes_for_level_multiplier",
11746 "maxBytesForLevelMultiplier",
11747 "max_compaction_bytes",
11748 "maxCompactionBytes",
11749 "sub_level_max_compaction_bytes",
11750 "subLevelMaxCompactionBytes",
11751 "level0_tier_compact_file_number",
11752 "level0TierCompactFileNumber",
11753 "target_file_size_base",
11754 "targetFileSizeBase",
11755 "compaction_filter_mask",
11756 "compactionFilterMask",
11757 "max_sub_compaction",
11758 "maxSubCompaction",
11759 "level0_stop_write_threshold_sub_level_number",
11760 "level0StopWriteThresholdSubLevelNumber",
11761 "level0_sub_level_compact_level_count",
11762 "level0SubLevelCompactLevelCount",
11763 "level0_overlapping_sub_level_compact_level_count",
11764 "level0OverlappingSubLevelCompactLevelCount",
11765 "max_space_reclaim_bytes",
11766 "maxSpaceReclaimBytes",
11767 "level0_max_compact_file_number",
11768 "level0MaxCompactFileNumber",
11769 "enable_emergency_picker",
11770 "enableEmergencyPicker",
11771 "tombstone_reclaim_ratio",
11772 "tombstoneReclaimRatio",
11773 "compression_algorithm",
11774 "compressionAlgorithm",
11775 "max_l0_compact_level_count",
11776 "maxL0CompactLevelCount",
11777 "sst_allowed_trivial_move_min_size",
11778 "sstAllowedTrivialMoveMinSize",
11779 "split_weight_by_vnode",
11780 "splitWeightByVnode",
11781 "disable_auto_group_scheduling",
11782 "disableAutoGroupScheduling",
11783 "max_overlapping_level_size",
11784 "maxOverlappingLevelSize",
11785 "emergency_level0_sst_file_count",
11786 "emergencyLevel0SstFileCount",
11787 "emergency_level0_sub_level_partition",
11788 "emergencyLevel0SubLevelPartition",
11789 "level0_stop_write_threshold_max_sst_count",
11790 "level0StopWriteThresholdMaxSstCount",
11791 "level0_stop_write_threshold_max_size",
11792 "level0StopWriteThresholdMaxSize",
11793 "sst_allowed_trivial_move_max_count",
11794 "sstAllowedTrivialMoveMaxCount",
11795 "enable_optimize_l0_interval_selection",
11796 "enableOptimizeL0IntervalSelection",
11797 ];
11798
11799 #[allow(clippy::enum_variant_names)]
11800 enum GeneratedField {
11801 MaxBytesForLevelBase,
11802 MaxBytesForLevelMultiplier,
11803 MaxCompactionBytes,
11804 SubLevelMaxCompactionBytes,
11805 Level0TierCompactFileNumber,
11806 TargetFileSizeBase,
11807 CompactionFilterMask,
11808 MaxSubCompaction,
11809 Level0StopWriteThresholdSubLevelNumber,
11810 Level0SubLevelCompactLevelCount,
11811 Level0OverlappingSubLevelCompactLevelCount,
11812 MaxSpaceReclaimBytes,
11813 Level0MaxCompactFileNumber,
11814 EnableEmergencyPicker,
11815 TombstoneReclaimRatio,
11816 CompressionAlgorithm,
11817 MaxL0CompactLevelCount,
11818 SstAllowedTrivialMoveMinSize,
11819 SplitWeightByVnode,
11820 DisableAutoGroupScheduling,
11821 MaxOverlappingLevelSize,
11822 EmergencyLevel0SstFileCount,
11823 EmergencyLevel0SubLevelPartition,
11824 Level0StopWriteThresholdMaxSstCount,
11825 Level0StopWriteThresholdMaxSize,
11826 SstAllowedTrivialMoveMaxCount,
11827 EnableOptimizeL0IntervalSelection,
11828 }
11829 impl<'de> serde::Deserialize<'de> for GeneratedField {
11830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11831 where
11832 D: serde::Deserializer<'de>,
11833 {
11834 struct GeneratedVisitor;
11835
11836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11837 type Value = GeneratedField;
11838
11839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11840 write!(formatter, "expected one of: {:?}", &FIELDS)
11841 }
11842
11843 #[allow(unused_variables)]
11844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11845 where
11846 E: serde::de::Error,
11847 {
11848 match value {
11849 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
11850 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
11851 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
11852 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
11853 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
11854 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
11855 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
11856 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
11857 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
11858 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
11859 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
11860 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
11861 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
11862 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
11863 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
11864 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
11865 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
11866 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
11867 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
11868 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
11869 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
11870 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
11871 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
11872 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
11873 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
11874 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
11875 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
11876 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11877 }
11878 }
11879 }
11880 deserializer.deserialize_identifier(GeneratedVisitor)
11881 }
11882 }
11883 struct GeneratedVisitor;
11884 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11885 type Value = rise_ctl_update_compaction_config_request::MutableConfig;
11886
11887 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11888 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig")
11889 }
11890
11891 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::MutableConfig, V::Error>
11892 where
11893 V: serde::de::MapAccess<'de>,
11894 {
11895 let mut mutable_config__ = None;
11896 while let Some(k) = map_.next_key()? {
11897 match k {
11898 GeneratedField::MaxBytesForLevelBase => {
11899 if mutable_config__.is_some() {
11900 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
11901 }
11902 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(x.0));
11903 }
11904 GeneratedField::MaxBytesForLevelMultiplier => {
11905 if mutable_config__.is_some() {
11906 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
11907 }
11908 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(x.0));
11909 }
11910 GeneratedField::MaxCompactionBytes => {
11911 if mutable_config__.is_some() {
11912 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
11913 }
11914 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(x.0));
11915 }
11916 GeneratedField::SubLevelMaxCompactionBytes => {
11917 if mutable_config__.is_some() {
11918 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
11919 }
11920 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(x.0));
11921 }
11922 GeneratedField::Level0TierCompactFileNumber => {
11923 if mutable_config__.is_some() {
11924 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
11925 }
11926 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(x.0));
11927 }
11928 GeneratedField::TargetFileSizeBase => {
11929 if mutable_config__.is_some() {
11930 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
11931 }
11932 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(x.0));
11933 }
11934 GeneratedField::CompactionFilterMask => {
11935 if mutable_config__.is_some() {
11936 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
11937 }
11938 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(x.0));
11939 }
11940 GeneratedField::MaxSubCompaction => {
11941 if mutable_config__.is_some() {
11942 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
11943 }
11944 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(x.0));
11945 }
11946 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
11947 if mutable_config__.is_some() {
11948 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
11949 }
11950 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(x.0));
11951 }
11952 GeneratedField::Level0SubLevelCompactLevelCount => {
11953 if mutable_config__.is_some() {
11954 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
11955 }
11956 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(x.0));
11957 }
11958 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
11959 if mutable_config__.is_some() {
11960 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
11961 }
11962 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(x.0));
11963 }
11964 GeneratedField::MaxSpaceReclaimBytes => {
11965 if mutable_config__.is_some() {
11966 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
11967 }
11968 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(x.0));
11969 }
11970 GeneratedField::Level0MaxCompactFileNumber => {
11971 if mutable_config__.is_some() {
11972 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
11973 }
11974 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(x.0));
11975 }
11976 GeneratedField::EnableEmergencyPicker => {
11977 if mutable_config__.is_some() {
11978 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
11979 }
11980 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker);
11981 }
11982 GeneratedField::TombstoneReclaimRatio => {
11983 if mutable_config__.is_some() {
11984 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
11985 }
11986 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(x.0));
11987 }
11988 GeneratedField::CompressionAlgorithm => {
11989 if mutable_config__.is_some() {
11990 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
11991 }
11992 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm)
11993;
11994 }
11995 GeneratedField::MaxL0CompactLevelCount => {
11996 if mutable_config__.is_some() {
11997 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
11998 }
11999 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(x.0));
12000 }
12001 GeneratedField::SstAllowedTrivialMoveMinSize => {
12002 if mutable_config__.is_some() {
12003 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
12004 }
12005 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(x.0));
12006 }
12007 GeneratedField::SplitWeightByVnode => {
12008 if mutable_config__.is_some() {
12009 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
12010 }
12011 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(x.0));
12012 }
12013 GeneratedField::DisableAutoGroupScheduling => {
12014 if mutable_config__.is_some() {
12015 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
12016 }
12017 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling);
12018 }
12019 GeneratedField::MaxOverlappingLevelSize => {
12020 if mutable_config__.is_some() {
12021 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
12022 }
12023 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(x.0));
12024 }
12025 GeneratedField::EmergencyLevel0SstFileCount => {
12026 if mutable_config__.is_some() {
12027 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
12028 }
12029 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(x.0));
12030 }
12031 GeneratedField::EmergencyLevel0SubLevelPartition => {
12032 if mutable_config__.is_some() {
12033 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
12034 }
12035 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(x.0));
12036 }
12037 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
12038 if mutable_config__.is_some() {
12039 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
12040 }
12041 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(x.0));
12042 }
12043 GeneratedField::Level0StopWriteThresholdMaxSize => {
12044 if mutable_config__.is_some() {
12045 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
12046 }
12047 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(x.0));
12048 }
12049 GeneratedField::SstAllowedTrivialMoveMaxCount => {
12050 if mutable_config__.is_some() {
12051 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
12052 }
12053 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(x.0));
12054 }
12055 GeneratedField::EnableOptimizeL0IntervalSelection => {
12056 if mutable_config__.is_some() {
12057 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
12058 }
12059 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection);
12060 }
12061 }
12062 }
12063 Ok(rise_ctl_update_compaction_config_request::MutableConfig {
12064 mutable_config: mutable_config__,
12065 })
12066 }
12067 }
12068 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", FIELDS, GeneratedVisitor)
12069 }
12070}
12071impl serde::Serialize for RiseCtlUpdateCompactionConfigResponse {
12072 #[allow(deprecated)]
12073 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12074 where
12075 S: serde::Serializer,
12076 {
12077 use serde::ser::SerializeStruct;
12078 let mut len = 0;
12079 if self.status.is_some() {
12080 len += 1;
12081 }
12082 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", len)?;
12083 if let Some(v) = self.status.as_ref() {
12084 struct_ser.serialize_field("status", v)?;
12085 }
12086 struct_ser.end()
12087 }
12088}
12089impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigResponse {
12090 #[allow(deprecated)]
12091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12092 where
12093 D: serde::Deserializer<'de>,
12094 {
12095 const FIELDS: &[&str] = &[
12096 "status",
12097 ];
12098
12099 #[allow(clippy::enum_variant_names)]
12100 enum GeneratedField {
12101 Status,
12102 }
12103 impl<'de> serde::Deserialize<'de> for GeneratedField {
12104 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12105 where
12106 D: serde::Deserializer<'de>,
12107 {
12108 struct GeneratedVisitor;
12109
12110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12111 type Value = GeneratedField;
12112
12113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12114 write!(formatter, "expected one of: {:?}", &FIELDS)
12115 }
12116
12117 #[allow(unused_variables)]
12118 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12119 where
12120 E: serde::de::Error,
12121 {
12122 match value {
12123 "status" => Ok(GeneratedField::Status),
12124 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12125 }
12126 }
12127 }
12128 deserializer.deserialize_identifier(GeneratedVisitor)
12129 }
12130 }
12131 struct GeneratedVisitor;
12132 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12133 type Value = RiseCtlUpdateCompactionConfigResponse;
12134
12135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12136 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigResponse")
12137 }
12138
12139 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigResponse, V::Error>
12140 where
12141 V: serde::de::MapAccess<'de>,
12142 {
12143 let mut status__ = None;
12144 while let Some(k) = map_.next_key()? {
12145 match k {
12146 GeneratedField::Status => {
12147 if status__.is_some() {
12148 return Err(serde::de::Error::duplicate_field("status"));
12149 }
12150 status__ = map_.next_value()?;
12151 }
12152 }
12153 }
12154 Ok(RiseCtlUpdateCompactionConfigResponse {
12155 status: status__,
12156 })
12157 }
12158 }
12159 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", FIELDS, GeneratedVisitor)
12160 }
12161}
12162impl serde::Serialize for SplitCompactionGroupRequest {
12163 #[allow(deprecated)]
12164 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12165 where
12166 S: serde::Serializer,
12167 {
12168 use serde::ser::SerializeStruct;
12169 let mut len = 0;
12170 if self.group_id != 0 {
12171 len += 1;
12172 }
12173 if !self.table_ids.is_empty() {
12174 len += 1;
12175 }
12176 if self.partition_vnode_count != 0 {
12177 len += 1;
12178 }
12179 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupRequest", len)?;
12180 if self.group_id != 0 {
12181 #[allow(clippy::needless_borrow)]
12182 #[allow(clippy::needless_borrows_for_generic_args)]
12183 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
12184 }
12185 if !self.table_ids.is_empty() {
12186 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12187 }
12188 if self.partition_vnode_count != 0 {
12189 struct_ser.serialize_field("partitionVnodeCount", &self.partition_vnode_count)?;
12190 }
12191 struct_ser.end()
12192 }
12193}
12194impl<'de> serde::Deserialize<'de> for SplitCompactionGroupRequest {
12195 #[allow(deprecated)]
12196 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12197 where
12198 D: serde::Deserializer<'de>,
12199 {
12200 const FIELDS: &[&str] = &[
12201 "group_id",
12202 "groupId",
12203 "table_ids",
12204 "tableIds",
12205 "partition_vnode_count",
12206 "partitionVnodeCount",
12207 ];
12208
12209 #[allow(clippy::enum_variant_names)]
12210 enum GeneratedField {
12211 GroupId,
12212 TableIds,
12213 PartitionVnodeCount,
12214 }
12215 impl<'de> serde::Deserialize<'de> for GeneratedField {
12216 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12217 where
12218 D: serde::Deserializer<'de>,
12219 {
12220 struct GeneratedVisitor;
12221
12222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12223 type Value = GeneratedField;
12224
12225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12226 write!(formatter, "expected one of: {:?}", &FIELDS)
12227 }
12228
12229 #[allow(unused_variables)]
12230 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12231 where
12232 E: serde::de::Error,
12233 {
12234 match value {
12235 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
12236 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12237 "partitionVnodeCount" | "partition_vnode_count" => Ok(GeneratedField::PartitionVnodeCount),
12238 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12239 }
12240 }
12241 }
12242 deserializer.deserialize_identifier(GeneratedVisitor)
12243 }
12244 }
12245 struct GeneratedVisitor;
12246 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12247 type Value = SplitCompactionGroupRequest;
12248
12249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12250 formatter.write_str("struct hummock.SplitCompactionGroupRequest")
12251 }
12252
12253 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupRequest, V::Error>
12254 where
12255 V: serde::de::MapAccess<'de>,
12256 {
12257 let mut group_id__ = None;
12258 let mut table_ids__ = None;
12259 let mut partition_vnode_count__ = None;
12260 while let Some(k) = map_.next_key()? {
12261 match k {
12262 GeneratedField::GroupId => {
12263 if group_id__.is_some() {
12264 return Err(serde::de::Error::duplicate_field("groupId"));
12265 }
12266 group_id__ =
12267 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12268 ;
12269 }
12270 GeneratedField::TableIds => {
12271 if table_ids__.is_some() {
12272 return Err(serde::de::Error::duplicate_field("tableIds"));
12273 }
12274 table_ids__ =
12275 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12276 .into_iter().map(|x| x.0).collect())
12277 ;
12278 }
12279 GeneratedField::PartitionVnodeCount => {
12280 if partition_vnode_count__.is_some() {
12281 return Err(serde::de::Error::duplicate_field("partitionVnodeCount"));
12282 }
12283 partition_vnode_count__ =
12284 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12285 ;
12286 }
12287 }
12288 }
12289 Ok(SplitCompactionGroupRequest {
12290 group_id: group_id__.unwrap_or_default(),
12291 table_ids: table_ids__.unwrap_or_default(),
12292 partition_vnode_count: partition_vnode_count__.unwrap_or_default(),
12293 })
12294 }
12295 }
12296 deserializer.deserialize_struct("hummock.SplitCompactionGroupRequest", FIELDS, GeneratedVisitor)
12297 }
12298}
12299impl serde::Serialize for SplitCompactionGroupResponse {
12300 #[allow(deprecated)]
12301 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12302 where
12303 S: serde::Serializer,
12304 {
12305 use serde::ser::SerializeStruct;
12306 let mut len = 0;
12307 if self.new_group_id != 0 {
12308 len += 1;
12309 }
12310 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupResponse", len)?;
12311 if self.new_group_id != 0 {
12312 #[allow(clippy::needless_borrow)]
12313 #[allow(clippy::needless_borrows_for_generic_args)]
12314 struct_ser.serialize_field("newGroupId", ToString::to_string(&self.new_group_id).as_str())?;
12315 }
12316 struct_ser.end()
12317 }
12318}
12319impl<'de> serde::Deserialize<'de> for SplitCompactionGroupResponse {
12320 #[allow(deprecated)]
12321 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12322 where
12323 D: serde::Deserializer<'de>,
12324 {
12325 const FIELDS: &[&str] = &[
12326 "new_group_id",
12327 "newGroupId",
12328 ];
12329
12330 #[allow(clippy::enum_variant_names)]
12331 enum GeneratedField {
12332 NewGroupId,
12333 }
12334 impl<'de> serde::Deserialize<'de> for GeneratedField {
12335 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12336 where
12337 D: serde::Deserializer<'de>,
12338 {
12339 struct GeneratedVisitor;
12340
12341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12342 type Value = GeneratedField;
12343
12344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12345 write!(formatter, "expected one of: {:?}", &FIELDS)
12346 }
12347
12348 #[allow(unused_variables)]
12349 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12350 where
12351 E: serde::de::Error,
12352 {
12353 match value {
12354 "newGroupId" | "new_group_id" => Ok(GeneratedField::NewGroupId),
12355 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12356 }
12357 }
12358 }
12359 deserializer.deserialize_identifier(GeneratedVisitor)
12360 }
12361 }
12362 struct GeneratedVisitor;
12363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12364 type Value = SplitCompactionGroupResponse;
12365
12366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12367 formatter.write_str("struct hummock.SplitCompactionGroupResponse")
12368 }
12369
12370 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupResponse, V::Error>
12371 where
12372 V: serde::de::MapAccess<'de>,
12373 {
12374 let mut new_group_id__ = None;
12375 while let Some(k) = map_.next_key()? {
12376 match k {
12377 GeneratedField::NewGroupId => {
12378 if new_group_id__.is_some() {
12379 return Err(serde::de::Error::duplicate_field("newGroupId"));
12380 }
12381 new_group_id__ =
12382 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12383 ;
12384 }
12385 }
12386 }
12387 Ok(SplitCompactionGroupResponse {
12388 new_group_id: new_group_id__.unwrap_or_default(),
12389 })
12390 }
12391 }
12392 deserializer.deserialize_struct("hummock.SplitCompactionGroupResponse", FIELDS, GeneratedVisitor)
12393 }
12394}
12395impl serde::Serialize for SstableInfo {
12396 #[allow(deprecated)]
12397 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12398 where
12399 S: serde::Serializer,
12400 {
12401 use serde::ser::SerializeStruct;
12402 let mut len = 0;
12403 if self.object_id != 0 {
12404 len += 1;
12405 }
12406 if self.sst_id != 0 {
12407 len += 1;
12408 }
12409 if self.key_range.is_some() {
12410 len += 1;
12411 }
12412 if self.file_size != 0 {
12413 len += 1;
12414 }
12415 if !self.table_ids.is_empty() {
12416 len += 1;
12417 }
12418 if self.meta_offset != 0 {
12419 len += 1;
12420 }
12421 if self.stale_key_count != 0 {
12422 len += 1;
12423 }
12424 if self.total_key_count != 0 {
12425 len += 1;
12426 }
12427 if self.min_epoch != 0 {
12428 len += 1;
12429 }
12430 if self.max_epoch != 0 {
12431 len += 1;
12432 }
12433 if self.uncompressed_file_size != 0 {
12434 len += 1;
12435 }
12436 if self.range_tombstone_count != 0 {
12437 len += 1;
12438 }
12439 if self.bloom_filter_kind != 0 {
12440 len += 1;
12441 }
12442 if self.sst_size != 0 {
12443 len += 1;
12444 }
12445 let mut struct_ser = serializer.serialize_struct("hummock.SstableInfo", len)?;
12446 if self.object_id != 0 {
12447 #[allow(clippy::needless_borrow)]
12448 #[allow(clippy::needless_borrows_for_generic_args)]
12449 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
12450 }
12451 if self.sst_id != 0 {
12452 #[allow(clippy::needless_borrow)]
12453 #[allow(clippy::needless_borrows_for_generic_args)]
12454 struct_ser.serialize_field("sstId", ToString::to_string(&self.sst_id).as_str())?;
12455 }
12456 if let Some(v) = self.key_range.as_ref() {
12457 struct_ser.serialize_field("keyRange", v)?;
12458 }
12459 if self.file_size != 0 {
12460 #[allow(clippy::needless_borrow)]
12461 #[allow(clippy::needless_borrows_for_generic_args)]
12462 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
12463 }
12464 if !self.table_ids.is_empty() {
12465 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12466 }
12467 if self.meta_offset != 0 {
12468 #[allow(clippy::needless_borrow)]
12469 #[allow(clippy::needless_borrows_for_generic_args)]
12470 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
12471 }
12472 if self.stale_key_count != 0 {
12473 #[allow(clippy::needless_borrow)]
12474 #[allow(clippy::needless_borrows_for_generic_args)]
12475 struct_ser.serialize_field("staleKeyCount", ToString::to_string(&self.stale_key_count).as_str())?;
12476 }
12477 if self.total_key_count != 0 {
12478 #[allow(clippy::needless_borrow)]
12479 #[allow(clippy::needless_borrows_for_generic_args)]
12480 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
12481 }
12482 if self.min_epoch != 0 {
12483 #[allow(clippy::needless_borrow)]
12484 #[allow(clippy::needless_borrows_for_generic_args)]
12485 struct_ser.serialize_field("minEpoch", ToString::to_string(&self.min_epoch).as_str())?;
12486 }
12487 if self.max_epoch != 0 {
12488 #[allow(clippy::needless_borrow)]
12489 #[allow(clippy::needless_borrows_for_generic_args)]
12490 struct_ser.serialize_field("maxEpoch", ToString::to_string(&self.max_epoch).as_str())?;
12491 }
12492 if self.uncompressed_file_size != 0 {
12493 #[allow(clippy::needless_borrow)]
12494 #[allow(clippy::needless_borrows_for_generic_args)]
12495 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
12496 }
12497 if self.range_tombstone_count != 0 {
12498 #[allow(clippy::needless_borrow)]
12499 #[allow(clippy::needless_borrows_for_generic_args)]
12500 struct_ser.serialize_field("rangeTombstoneCount", ToString::to_string(&self.range_tombstone_count).as_str())?;
12501 }
12502 if self.bloom_filter_kind != 0 {
12503 let v = BloomFilterType::try_from(self.bloom_filter_kind)
12504 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.bloom_filter_kind)))?;
12505 struct_ser.serialize_field("bloomFilterKind", &v)?;
12506 }
12507 if self.sst_size != 0 {
12508 #[allow(clippy::needless_borrow)]
12509 #[allow(clippy::needless_borrows_for_generic_args)]
12510 struct_ser.serialize_field("sstSize", ToString::to_string(&self.sst_size).as_str())?;
12511 }
12512 struct_ser.end()
12513 }
12514}
12515impl<'de> serde::Deserialize<'de> for SstableInfo {
12516 #[allow(deprecated)]
12517 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12518 where
12519 D: serde::Deserializer<'de>,
12520 {
12521 const FIELDS: &[&str] = &[
12522 "object_id",
12523 "objectId",
12524 "sst_id",
12525 "sstId",
12526 "key_range",
12527 "keyRange",
12528 "file_size",
12529 "fileSize",
12530 "table_ids",
12531 "tableIds",
12532 "meta_offset",
12533 "metaOffset",
12534 "stale_key_count",
12535 "staleKeyCount",
12536 "total_key_count",
12537 "totalKeyCount",
12538 "min_epoch",
12539 "minEpoch",
12540 "max_epoch",
12541 "maxEpoch",
12542 "uncompressed_file_size",
12543 "uncompressedFileSize",
12544 "range_tombstone_count",
12545 "rangeTombstoneCount",
12546 "bloom_filter_kind",
12547 "bloomFilterKind",
12548 "sst_size",
12549 "sstSize",
12550 ];
12551
12552 #[allow(clippy::enum_variant_names)]
12553 enum GeneratedField {
12554 ObjectId,
12555 SstId,
12556 KeyRange,
12557 FileSize,
12558 TableIds,
12559 MetaOffset,
12560 StaleKeyCount,
12561 TotalKeyCount,
12562 MinEpoch,
12563 MaxEpoch,
12564 UncompressedFileSize,
12565 RangeTombstoneCount,
12566 BloomFilterKind,
12567 SstSize,
12568 }
12569 impl<'de> serde::Deserialize<'de> for GeneratedField {
12570 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12571 where
12572 D: serde::Deserializer<'de>,
12573 {
12574 struct GeneratedVisitor;
12575
12576 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12577 type Value = GeneratedField;
12578
12579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12580 write!(formatter, "expected one of: {:?}", &FIELDS)
12581 }
12582
12583 #[allow(unused_variables)]
12584 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12585 where
12586 E: serde::de::Error,
12587 {
12588 match value {
12589 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
12590 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
12591 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
12592 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
12593 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12594 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
12595 "staleKeyCount" | "stale_key_count" => Ok(GeneratedField::StaleKeyCount),
12596 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
12597 "minEpoch" | "min_epoch" => Ok(GeneratedField::MinEpoch),
12598 "maxEpoch" | "max_epoch" => Ok(GeneratedField::MaxEpoch),
12599 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
12600 "rangeTombstoneCount" | "range_tombstone_count" => Ok(GeneratedField::RangeTombstoneCount),
12601 "bloomFilterKind" | "bloom_filter_kind" => Ok(GeneratedField::BloomFilterKind),
12602 "sstSize" | "sst_size" => Ok(GeneratedField::SstSize),
12603 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12604 }
12605 }
12606 }
12607 deserializer.deserialize_identifier(GeneratedVisitor)
12608 }
12609 }
12610 struct GeneratedVisitor;
12611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12612 type Value = SstableInfo;
12613
12614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12615 formatter.write_str("struct hummock.SstableInfo")
12616 }
12617
12618 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SstableInfo, V::Error>
12619 where
12620 V: serde::de::MapAccess<'de>,
12621 {
12622 let mut object_id__ = None;
12623 let mut sst_id__ = None;
12624 let mut key_range__ = None;
12625 let mut file_size__ = None;
12626 let mut table_ids__ = None;
12627 let mut meta_offset__ = None;
12628 let mut stale_key_count__ = None;
12629 let mut total_key_count__ = None;
12630 let mut min_epoch__ = None;
12631 let mut max_epoch__ = None;
12632 let mut uncompressed_file_size__ = None;
12633 let mut range_tombstone_count__ = None;
12634 let mut bloom_filter_kind__ = None;
12635 let mut sst_size__ = None;
12636 while let Some(k) = map_.next_key()? {
12637 match k {
12638 GeneratedField::ObjectId => {
12639 if object_id__.is_some() {
12640 return Err(serde::de::Error::duplicate_field("objectId"));
12641 }
12642 object_id__ =
12643 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12644 ;
12645 }
12646 GeneratedField::SstId => {
12647 if sst_id__.is_some() {
12648 return Err(serde::de::Error::duplicate_field("sstId"));
12649 }
12650 sst_id__ =
12651 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12652 ;
12653 }
12654 GeneratedField::KeyRange => {
12655 if key_range__.is_some() {
12656 return Err(serde::de::Error::duplicate_field("keyRange"));
12657 }
12658 key_range__ = map_.next_value()?;
12659 }
12660 GeneratedField::FileSize => {
12661 if file_size__.is_some() {
12662 return Err(serde::de::Error::duplicate_field("fileSize"));
12663 }
12664 file_size__ =
12665 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12666 ;
12667 }
12668 GeneratedField::TableIds => {
12669 if table_ids__.is_some() {
12670 return Err(serde::de::Error::duplicate_field("tableIds"));
12671 }
12672 table_ids__ =
12673 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12674 .into_iter().map(|x| x.0).collect())
12675 ;
12676 }
12677 GeneratedField::MetaOffset => {
12678 if meta_offset__.is_some() {
12679 return Err(serde::de::Error::duplicate_field("metaOffset"));
12680 }
12681 meta_offset__ =
12682 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12683 ;
12684 }
12685 GeneratedField::StaleKeyCount => {
12686 if stale_key_count__.is_some() {
12687 return Err(serde::de::Error::duplicate_field("staleKeyCount"));
12688 }
12689 stale_key_count__ =
12690 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12691 ;
12692 }
12693 GeneratedField::TotalKeyCount => {
12694 if total_key_count__.is_some() {
12695 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
12696 }
12697 total_key_count__ =
12698 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12699 ;
12700 }
12701 GeneratedField::MinEpoch => {
12702 if min_epoch__.is_some() {
12703 return Err(serde::de::Error::duplicate_field("minEpoch"));
12704 }
12705 min_epoch__ =
12706 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12707 ;
12708 }
12709 GeneratedField::MaxEpoch => {
12710 if max_epoch__.is_some() {
12711 return Err(serde::de::Error::duplicate_field("maxEpoch"));
12712 }
12713 max_epoch__ =
12714 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12715 ;
12716 }
12717 GeneratedField::UncompressedFileSize => {
12718 if uncompressed_file_size__.is_some() {
12719 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
12720 }
12721 uncompressed_file_size__ =
12722 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12723 ;
12724 }
12725 GeneratedField::RangeTombstoneCount => {
12726 if range_tombstone_count__.is_some() {
12727 return Err(serde::de::Error::duplicate_field("rangeTombstoneCount"));
12728 }
12729 range_tombstone_count__ =
12730 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12731 ;
12732 }
12733 GeneratedField::BloomFilterKind => {
12734 if bloom_filter_kind__.is_some() {
12735 return Err(serde::de::Error::duplicate_field("bloomFilterKind"));
12736 }
12737 bloom_filter_kind__ = Some(map_.next_value::<BloomFilterType>()? as i32);
12738 }
12739 GeneratedField::SstSize => {
12740 if sst_size__.is_some() {
12741 return Err(serde::de::Error::duplicate_field("sstSize"));
12742 }
12743 sst_size__ =
12744 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12745 ;
12746 }
12747 }
12748 }
12749 Ok(SstableInfo {
12750 object_id: object_id__.unwrap_or_default(),
12751 sst_id: sst_id__.unwrap_or_default(),
12752 key_range: key_range__,
12753 file_size: file_size__.unwrap_or_default(),
12754 table_ids: table_ids__.unwrap_or_default(),
12755 meta_offset: meta_offset__.unwrap_or_default(),
12756 stale_key_count: stale_key_count__.unwrap_or_default(),
12757 total_key_count: total_key_count__.unwrap_or_default(),
12758 min_epoch: min_epoch__.unwrap_or_default(),
12759 max_epoch: max_epoch__.unwrap_or_default(),
12760 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
12761 range_tombstone_count: range_tombstone_count__.unwrap_or_default(),
12762 bloom_filter_kind: bloom_filter_kind__.unwrap_or_default(),
12763 sst_size: sst_size__.unwrap_or_default(),
12764 })
12765 }
12766 }
12767 deserializer.deserialize_struct("hummock.SstableInfo", FIELDS, GeneratedVisitor)
12768 }
12769}
12770impl serde::Serialize for StateTableInfo {
12771 #[allow(deprecated)]
12772 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12773 where
12774 S: serde::Serializer,
12775 {
12776 use serde::ser::SerializeStruct;
12777 let mut len = 0;
12778 if self.committed_epoch != 0 {
12779 len += 1;
12780 }
12781 if self.compaction_group_id != 0 {
12782 len += 1;
12783 }
12784 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfo", len)?;
12785 if self.committed_epoch != 0 {
12786 #[allow(clippy::needless_borrow)]
12787 #[allow(clippy::needless_borrows_for_generic_args)]
12788 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
12789 }
12790 if self.compaction_group_id != 0 {
12791 #[allow(clippy::needless_borrow)]
12792 #[allow(clippy::needless_borrows_for_generic_args)]
12793 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
12794 }
12795 struct_ser.end()
12796 }
12797}
12798impl<'de> serde::Deserialize<'de> for StateTableInfo {
12799 #[allow(deprecated)]
12800 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12801 where
12802 D: serde::Deserializer<'de>,
12803 {
12804 const FIELDS: &[&str] = &[
12805 "committed_epoch",
12806 "committedEpoch",
12807 "compaction_group_id",
12808 "compactionGroupId",
12809 ];
12810
12811 #[allow(clippy::enum_variant_names)]
12812 enum GeneratedField {
12813 CommittedEpoch,
12814 CompactionGroupId,
12815 }
12816 impl<'de> serde::Deserialize<'de> for GeneratedField {
12817 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12818 where
12819 D: serde::Deserializer<'de>,
12820 {
12821 struct GeneratedVisitor;
12822
12823 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12824 type Value = GeneratedField;
12825
12826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12827 write!(formatter, "expected one of: {:?}", &FIELDS)
12828 }
12829
12830 #[allow(unused_variables)]
12831 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12832 where
12833 E: serde::de::Error,
12834 {
12835 match value {
12836 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
12837 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
12838 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12839 }
12840 }
12841 }
12842 deserializer.deserialize_identifier(GeneratedVisitor)
12843 }
12844 }
12845 struct GeneratedVisitor;
12846 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12847 type Value = StateTableInfo;
12848
12849 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12850 formatter.write_str("struct hummock.StateTableInfo")
12851 }
12852
12853 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfo, V::Error>
12854 where
12855 V: serde::de::MapAccess<'de>,
12856 {
12857 let mut committed_epoch__ = None;
12858 let mut compaction_group_id__ = None;
12859 while let Some(k) = map_.next_key()? {
12860 match k {
12861 GeneratedField::CommittedEpoch => {
12862 if committed_epoch__.is_some() {
12863 return Err(serde::de::Error::duplicate_field("committedEpoch"));
12864 }
12865 committed_epoch__ =
12866 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12867 ;
12868 }
12869 GeneratedField::CompactionGroupId => {
12870 if compaction_group_id__.is_some() {
12871 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
12872 }
12873 compaction_group_id__ =
12874 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12875 ;
12876 }
12877 }
12878 }
12879 Ok(StateTableInfo {
12880 committed_epoch: committed_epoch__.unwrap_or_default(),
12881 compaction_group_id: compaction_group_id__.unwrap_or_default(),
12882 })
12883 }
12884 }
12885 deserializer.deserialize_struct("hummock.StateTableInfo", FIELDS, GeneratedVisitor)
12886 }
12887}
12888impl serde::Serialize for StateTableInfoDelta {
12889 #[allow(deprecated)]
12890 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12891 where
12892 S: serde::Serializer,
12893 {
12894 use serde::ser::SerializeStruct;
12895 let mut len = 0;
12896 if self.committed_epoch != 0 {
12897 len += 1;
12898 }
12899 if self.compaction_group_id != 0 {
12900 len += 1;
12901 }
12902 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfoDelta", len)?;
12903 if self.committed_epoch != 0 {
12904 #[allow(clippy::needless_borrow)]
12905 #[allow(clippy::needless_borrows_for_generic_args)]
12906 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
12907 }
12908 if self.compaction_group_id != 0 {
12909 #[allow(clippy::needless_borrow)]
12910 #[allow(clippy::needless_borrows_for_generic_args)]
12911 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
12912 }
12913 struct_ser.end()
12914 }
12915}
12916impl<'de> serde::Deserialize<'de> for StateTableInfoDelta {
12917 #[allow(deprecated)]
12918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12919 where
12920 D: serde::Deserializer<'de>,
12921 {
12922 const FIELDS: &[&str] = &[
12923 "committed_epoch",
12924 "committedEpoch",
12925 "compaction_group_id",
12926 "compactionGroupId",
12927 ];
12928
12929 #[allow(clippy::enum_variant_names)]
12930 enum GeneratedField {
12931 CommittedEpoch,
12932 CompactionGroupId,
12933 }
12934 impl<'de> serde::Deserialize<'de> for GeneratedField {
12935 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12936 where
12937 D: serde::Deserializer<'de>,
12938 {
12939 struct GeneratedVisitor;
12940
12941 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12942 type Value = GeneratedField;
12943
12944 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12945 write!(formatter, "expected one of: {:?}", &FIELDS)
12946 }
12947
12948 #[allow(unused_variables)]
12949 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12950 where
12951 E: serde::de::Error,
12952 {
12953 match value {
12954 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
12955 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
12956 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12957 }
12958 }
12959 }
12960 deserializer.deserialize_identifier(GeneratedVisitor)
12961 }
12962 }
12963 struct GeneratedVisitor;
12964 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12965 type Value = StateTableInfoDelta;
12966
12967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12968 formatter.write_str("struct hummock.StateTableInfoDelta")
12969 }
12970
12971 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfoDelta, V::Error>
12972 where
12973 V: serde::de::MapAccess<'de>,
12974 {
12975 let mut committed_epoch__ = None;
12976 let mut compaction_group_id__ = None;
12977 while let Some(k) = map_.next_key()? {
12978 match k {
12979 GeneratedField::CommittedEpoch => {
12980 if committed_epoch__.is_some() {
12981 return Err(serde::de::Error::duplicate_field("committedEpoch"));
12982 }
12983 committed_epoch__ =
12984 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12985 ;
12986 }
12987 GeneratedField::CompactionGroupId => {
12988 if compaction_group_id__.is_some() {
12989 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
12990 }
12991 compaction_group_id__ =
12992 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12993 ;
12994 }
12995 }
12996 }
12997 Ok(StateTableInfoDelta {
12998 committed_epoch: committed_epoch__.unwrap_or_default(),
12999 compaction_group_id: compaction_group_id__.unwrap_or_default(),
13000 })
13001 }
13002 }
13003 deserializer.deserialize_struct("hummock.StateTableInfoDelta", FIELDS, GeneratedVisitor)
13004 }
13005}
13006impl serde::Serialize for SubscribeCompactionEventRequest {
13007 #[allow(deprecated)]
13008 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13009 where
13010 S: serde::Serializer,
13011 {
13012 use serde::ser::SerializeStruct;
13013 let mut len = 0;
13014 if self.create_at != 0 {
13015 len += 1;
13016 }
13017 if self.event.is_some() {
13018 len += 1;
13019 }
13020 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest", len)?;
13021 if self.create_at != 0 {
13022 #[allow(clippy::needless_borrow)]
13023 #[allow(clippy::needless_borrows_for_generic_args)]
13024 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
13025 }
13026 if let Some(v) = self.event.as_ref() {
13027 match v {
13028 subscribe_compaction_event_request::Event::Register(v) => {
13029 struct_ser.serialize_field("register", v)?;
13030 }
13031 subscribe_compaction_event_request::Event::PullTask(v) => {
13032 struct_ser.serialize_field("pullTask", v)?;
13033 }
13034 subscribe_compaction_event_request::Event::ReportTask(v) => {
13035 struct_ser.serialize_field("reportTask", v)?;
13036 }
13037 subscribe_compaction_event_request::Event::HeartBeat(v) => {
13038 struct_ser.serialize_field("heartBeat", v)?;
13039 }
13040 }
13041 }
13042 struct_ser.end()
13043 }
13044}
13045impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventRequest {
13046 #[allow(deprecated)]
13047 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13048 where
13049 D: serde::Deserializer<'de>,
13050 {
13051 const FIELDS: &[&str] = &[
13052 "create_at",
13053 "createAt",
13054 "register",
13055 "pull_task",
13056 "pullTask",
13057 "report_task",
13058 "reportTask",
13059 "heart_beat",
13060 "heartBeat",
13061 ];
13062
13063 #[allow(clippy::enum_variant_names)]
13064 enum GeneratedField {
13065 CreateAt,
13066 Register,
13067 PullTask,
13068 ReportTask,
13069 HeartBeat,
13070 }
13071 impl<'de> serde::Deserialize<'de> for GeneratedField {
13072 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13073 where
13074 D: serde::Deserializer<'de>,
13075 {
13076 struct GeneratedVisitor;
13077
13078 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13079 type Value = GeneratedField;
13080
13081 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13082 write!(formatter, "expected one of: {:?}", &FIELDS)
13083 }
13084
13085 #[allow(unused_variables)]
13086 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13087 where
13088 E: serde::de::Error,
13089 {
13090 match value {
13091 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
13092 "register" => Ok(GeneratedField::Register),
13093 "pullTask" | "pull_task" => Ok(GeneratedField::PullTask),
13094 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
13095 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
13096 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13097 }
13098 }
13099 }
13100 deserializer.deserialize_identifier(GeneratedVisitor)
13101 }
13102 }
13103 struct GeneratedVisitor;
13104 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13105 type Value = SubscribeCompactionEventRequest;
13106
13107 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13108 formatter.write_str("struct hummock.SubscribeCompactionEventRequest")
13109 }
13110
13111 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventRequest, V::Error>
13112 where
13113 V: serde::de::MapAccess<'de>,
13114 {
13115 let mut create_at__ = None;
13116 let mut event__ = None;
13117 while let Some(k) = map_.next_key()? {
13118 match k {
13119 GeneratedField::CreateAt => {
13120 if create_at__.is_some() {
13121 return Err(serde::de::Error::duplicate_field("createAt"));
13122 }
13123 create_at__ =
13124 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13125 ;
13126 }
13127 GeneratedField::Register => {
13128 if event__.is_some() {
13129 return Err(serde::de::Error::duplicate_field("register"));
13130 }
13131 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::Register)
13132;
13133 }
13134 GeneratedField::PullTask => {
13135 if event__.is_some() {
13136 return Err(serde::de::Error::duplicate_field("pullTask"));
13137 }
13138 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::PullTask)
13139;
13140 }
13141 GeneratedField::ReportTask => {
13142 if event__.is_some() {
13143 return Err(serde::de::Error::duplicate_field("reportTask"));
13144 }
13145 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::ReportTask)
13146;
13147 }
13148 GeneratedField::HeartBeat => {
13149 if event__.is_some() {
13150 return Err(serde::de::Error::duplicate_field("heartBeat"));
13151 }
13152 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::HeartBeat)
13153;
13154 }
13155 }
13156 }
13157 Ok(SubscribeCompactionEventRequest {
13158 create_at: create_at__.unwrap_or_default(),
13159 event: event__,
13160 })
13161 }
13162 }
13163 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest", FIELDS, GeneratedVisitor)
13164 }
13165}
13166impl serde::Serialize for subscribe_compaction_event_request::HeartBeat {
13167 #[allow(deprecated)]
13168 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13169 where
13170 S: serde::Serializer,
13171 {
13172 use serde::ser::SerializeStruct;
13173 let mut len = 0;
13174 if !self.progress.is_empty() {
13175 len += 1;
13176 }
13177 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", len)?;
13178 if !self.progress.is_empty() {
13179 struct_ser.serialize_field("progress", &self.progress)?;
13180 }
13181 struct_ser.end()
13182 }
13183}
13184impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::HeartBeat {
13185 #[allow(deprecated)]
13186 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13187 where
13188 D: serde::Deserializer<'de>,
13189 {
13190 const FIELDS: &[&str] = &[
13191 "progress",
13192 ];
13193
13194 #[allow(clippy::enum_variant_names)]
13195 enum GeneratedField {
13196 Progress,
13197 }
13198 impl<'de> serde::Deserialize<'de> for GeneratedField {
13199 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13200 where
13201 D: serde::Deserializer<'de>,
13202 {
13203 struct GeneratedVisitor;
13204
13205 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13206 type Value = GeneratedField;
13207
13208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13209 write!(formatter, "expected one of: {:?}", &FIELDS)
13210 }
13211
13212 #[allow(unused_variables)]
13213 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13214 where
13215 E: serde::de::Error,
13216 {
13217 match value {
13218 "progress" => Ok(GeneratedField::Progress),
13219 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13220 }
13221 }
13222 }
13223 deserializer.deserialize_identifier(GeneratedVisitor)
13224 }
13225 }
13226 struct GeneratedVisitor;
13227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13228 type Value = subscribe_compaction_event_request::HeartBeat;
13229
13230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13231 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.HeartBeat")
13232 }
13233
13234 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::HeartBeat, V::Error>
13235 where
13236 V: serde::de::MapAccess<'de>,
13237 {
13238 let mut progress__ = None;
13239 while let Some(k) = map_.next_key()? {
13240 match k {
13241 GeneratedField::Progress => {
13242 if progress__.is_some() {
13243 return Err(serde::de::Error::duplicate_field("progress"));
13244 }
13245 progress__ = Some(map_.next_value()?);
13246 }
13247 }
13248 }
13249 Ok(subscribe_compaction_event_request::HeartBeat {
13250 progress: progress__.unwrap_or_default(),
13251 })
13252 }
13253 }
13254 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", FIELDS, GeneratedVisitor)
13255 }
13256}
13257impl serde::Serialize for subscribe_compaction_event_request::PullTask {
13258 #[allow(deprecated)]
13259 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13260 where
13261 S: serde::Serializer,
13262 {
13263 use serde::ser::SerializeStruct;
13264 let mut len = 0;
13265 if self.pull_task_count != 0 {
13266 len += 1;
13267 }
13268 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", len)?;
13269 if self.pull_task_count != 0 {
13270 struct_ser.serialize_field("pullTaskCount", &self.pull_task_count)?;
13271 }
13272 struct_ser.end()
13273 }
13274}
13275impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::PullTask {
13276 #[allow(deprecated)]
13277 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13278 where
13279 D: serde::Deserializer<'de>,
13280 {
13281 const FIELDS: &[&str] = &[
13282 "pull_task_count",
13283 "pullTaskCount",
13284 ];
13285
13286 #[allow(clippy::enum_variant_names)]
13287 enum GeneratedField {
13288 PullTaskCount,
13289 }
13290 impl<'de> serde::Deserialize<'de> for GeneratedField {
13291 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13292 where
13293 D: serde::Deserializer<'de>,
13294 {
13295 struct GeneratedVisitor;
13296
13297 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13298 type Value = GeneratedField;
13299
13300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13301 write!(formatter, "expected one of: {:?}", &FIELDS)
13302 }
13303
13304 #[allow(unused_variables)]
13305 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13306 where
13307 E: serde::de::Error,
13308 {
13309 match value {
13310 "pullTaskCount" | "pull_task_count" => Ok(GeneratedField::PullTaskCount),
13311 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13312 }
13313 }
13314 }
13315 deserializer.deserialize_identifier(GeneratedVisitor)
13316 }
13317 }
13318 struct GeneratedVisitor;
13319 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13320 type Value = subscribe_compaction_event_request::PullTask;
13321
13322 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13323 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.PullTask")
13324 }
13325
13326 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::PullTask, V::Error>
13327 where
13328 V: serde::de::MapAccess<'de>,
13329 {
13330 let mut pull_task_count__ = None;
13331 while let Some(k) = map_.next_key()? {
13332 match k {
13333 GeneratedField::PullTaskCount => {
13334 if pull_task_count__.is_some() {
13335 return Err(serde::de::Error::duplicate_field("pullTaskCount"));
13336 }
13337 pull_task_count__ =
13338 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13339 ;
13340 }
13341 }
13342 }
13343 Ok(subscribe_compaction_event_request::PullTask {
13344 pull_task_count: pull_task_count__.unwrap_or_default(),
13345 })
13346 }
13347 }
13348 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", FIELDS, GeneratedVisitor)
13349 }
13350}
13351impl serde::Serialize for subscribe_compaction_event_request::Register {
13352 #[allow(deprecated)]
13353 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13354 where
13355 S: serde::Serializer,
13356 {
13357 use serde::ser::SerializeStruct;
13358 let mut len = 0;
13359 if self.context_id != 0 {
13360 len += 1;
13361 }
13362 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.Register", len)?;
13363 if self.context_id != 0 {
13364 struct_ser.serialize_field("contextId", &self.context_id)?;
13365 }
13366 struct_ser.end()
13367 }
13368}
13369impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::Register {
13370 #[allow(deprecated)]
13371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13372 where
13373 D: serde::Deserializer<'de>,
13374 {
13375 const FIELDS: &[&str] = &[
13376 "context_id",
13377 "contextId",
13378 ];
13379
13380 #[allow(clippy::enum_variant_names)]
13381 enum GeneratedField {
13382 ContextId,
13383 }
13384 impl<'de> serde::Deserialize<'de> for GeneratedField {
13385 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13386 where
13387 D: serde::Deserializer<'de>,
13388 {
13389 struct GeneratedVisitor;
13390
13391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13392 type Value = GeneratedField;
13393
13394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13395 write!(formatter, "expected one of: {:?}", &FIELDS)
13396 }
13397
13398 #[allow(unused_variables)]
13399 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13400 where
13401 E: serde::de::Error,
13402 {
13403 match value {
13404 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
13405 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13406 }
13407 }
13408 }
13409 deserializer.deserialize_identifier(GeneratedVisitor)
13410 }
13411 }
13412 struct GeneratedVisitor;
13413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13414 type Value = subscribe_compaction_event_request::Register;
13415
13416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13417 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.Register")
13418 }
13419
13420 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::Register, V::Error>
13421 where
13422 V: serde::de::MapAccess<'de>,
13423 {
13424 let mut context_id__ = None;
13425 while let Some(k) = map_.next_key()? {
13426 match k {
13427 GeneratedField::ContextId => {
13428 if context_id__.is_some() {
13429 return Err(serde::de::Error::duplicate_field("contextId"));
13430 }
13431 context_id__ =
13432 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13433 ;
13434 }
13435 }
13436 }
13437 Ok(subscribe_compaction_event_request::Register {
13438 context_id: context_id__.unwrap_or_default(),
13439 })
13440 }
13441 }
13442 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.Register", FIELDS, GeneratedVisitor)
13443 }
13444}
13445impl serde::Serialize for subscribe_compaction_event_request::ReportTask {
13446 #[allow(deprecated)]
13447 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13448 where
13449 S: serde::Serializer,
13450 {
13451 use serde::ser::SerializeStruct;
13452 let mut len = 0;
13453 if !self.table_stats_change.is_empty() {
13454 len += 1;
13455 }
13456 if self.task_id != 0 {
13457 len += 1;
13458 }
13459 if self.task_status != 0 {
13460 len += 1;
13461 }
13462 if !self.sorted_output_ssts.is_empty() {
13463 len += 1;
13464 }
13465 if !self.object_timestamps.is_empty() {
13466 len += 1;
13467 }
13468 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", len)?;
13469 if !self.table_stats_change.is_empty() {
13470 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
13471 }
13472 if self.task_id != 0 {
13473 #[allow(clippy::needless_borrow)]
13474 #[allow(clippy::needless_borrows_for_generic_args)]
13475 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
13476 }
13477 if self.task_status != 0 {
13478 let v = compact_task::TaskStatus::try_from(self.task_status)
13479 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
13480 struct_ser.serialize_field("taskStatus", &v)?;
13481 }
13482 if !self.sorted_output_ssts.is_empty() {
13483 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
13484 }
13485 if !self.object_timestamps.is_empty() {
13486 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
13487 .map(|(k, v)| (k, v.to_string())).collect();
13488 struct_ser.serialize_field("objectTimestamps", &v)?;
13489 }
13490 struct_ser.end()
13491 }
13492}
13493impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::ReportTask {
13494 #[allow(deprecated)]
13495 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13496 where
13497 D: serde::Deserializer<'de>,
13498 {
13499 const FIELDS: &[&str] = &[
13500 "table_stats_change",
13501 "tableStatsChange",
13502 "task_id",
13503 "taskId",
13504 "task_status",
13505 "taskStatus",
13506 "sorted_output_ssts",
13507 "sortedOutputSsts",
13508 "object_timestamps",
13509 "objectTimestamps",
13510 ];
13511
13512 #[allow(clippy::enum_variant_names)]
13513 enum GeneratedField {
13514 TableStatsChange,
13515 TaskId,
13516 TaskStatus,
13517 SortedOutputSsts,
13518 ObjectTimestamps,
13519 }
13520 impl<'de> serde::Deserialize<'de> for GeneratedField {
13521 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13522 where
13523 D: serde::Deserializer<'de>,
13524 {
13525 struct GeneratedVisitor;
13526
13527 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13528 type Value = GeneratedField;
13529
13530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13531 write!(formatter, "expected one of: {:?}", &FIELDS)
13532 }
13533
13534 #[allow(unused_variables)]
13535 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13536 where
13537 E: serde::de::Error,
13538 {
13539 match value {
13540 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
13541 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
13542 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
13543 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
13544 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
13545 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13546 }
13547 }
13548 }
13549 deserializer.deserialize_identifier(GeneratedVisitor)
13550 }
13551 }
13552 struct GeneratedVisitor;
13553 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13554 type Value = subscribe_compaction_event_request::ReportTask;
13555
13556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13557 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.ReportTask")
13558 }
13559
13560 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::ReportTask, V::Error>
13561 where
13562 V: serde::de::MapAccess<'de>,
13563 {
13564 let mut table_stats_change__ = None;
13565 let mut task_id__ = None;
13566 let mut task_status__ = None;
13567 let mut sorted_output_ssts__ = None;
13568 let mut object_timestamps__ = None;
13569 while let Some(k) = map_.next_key()? {
13570 match k {
13571 GeneratedField::TableStatsChange => {
13572 if table_stats_change__.is_some() {
13573 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
13574 }
13575 table_stats_change__ = Some(
13576 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13577 .into_iter().map(|(k,v)| (k.0, v)).collect()
13578 );
13579 }
13580 GeneratedField::TaskId => {
13581 if task_id__.is_some() {
13582 return Err(serde::de::Error::duplicate_field("taskId"));
13583 }
13584 task_id__ =
13585 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13586 ;
13587 }
13588 GeneratedField::TaskStatus => {
13589 if task_status__.is_some() {
13590 return Err(serde::de::Error::duplicate_field("taskStatus"));
13591 }
13592 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
13593 }
13594 GeneratedField::SortedOutputSsts => {
13595 if sorted_output_ssts__.is_some() {
13596 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
13597 }
13598 sorted_output_ssts__ = Some(map_.next_value()?);
13599 }
13600 GeneratedField::ObjectTimestamps => {
13601 if object_timestamps__.is_some() {
13602 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
13603 }
13604 object_timestamps__ = Some(
13605 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
13606 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
13607 );
13608 }
13609 }
13610 }
13611 Ok(subscribe_compaction_event_request::ReportTask {
13612 table_stats_change: table_stats_change__.unwrap_or_default(),
13613 task_id: task_id__.unwrap_or_default(),
13614 task_status: task_status__.unwrap_or_default(),
13615 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
13616 object_timestamps: object_timestamps__.unwrap_or_default(),
13617 })
13618 }
13619 }
13620 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", FIELDS, GeneratedVisitor)
13621 }
13622}
13623impl serde::Serialize for SubscribeCompactionEventResponse {
13624 #[allow(deprecated)]
13625 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13626 where
13627 S: serde::Serializer,
13628 {
13629 use serde::ser::SerializeStruct;
13630 let mut len = 0;
13631 if self.create_at != 0 {
13632 len += 1;
13633 }
13634 if self.event.is_some() {
13635 len += 1;
13636 }
13637 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse", len)?;
13638 if self.create_at != 0 {
13639 #[allow(clippy::needless_borrow)]
13640 #[allow(clippy::needless_borrows_for_generic_args)]
13641 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
13642 }
13643 if let Some(v) = self.event.as_ref() {
13644 match v {
13645 subscribe_compaction_event_response::Event::CompactTask(v) => {
13646 struct_ser.serialize_field("compactTask", v)?;
13647 }
13648 subscribe_compaction_event_response::Event::VacuumTask(v) => {
13649 struct_ser.serialize_field("vacuumTask", v)?;
13650 }
13651 subscribe_compaction_event_response::Event::FullScanTask(v) => {
13652 struct_ser.serialize_field("fullScanTask", v)?;
13653 }
13654 subscribe_compaction_event_response::Event::ValidationTask(v) => {
13655 struct_ser.serialize_field("validationTask", v)?;
13656 }
13657 subscribe_compaction_event_response::Event::CancelCompactTask(v) => {
13658 struct_ser.serialize_field("cancelCompactTask", v)?;
13659 }
13660 subscribe_compaction_event_response::Event::PullTaskAck(v) => {
13661 struct_ser.serialize_field("pullTaskAck", v)?;
13662 }
13663 }
13664 }
13665 struct_ser.end()
13666 }
13667}
13668impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventResponse {
13669 #[allow(deprecated)]
13670 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13671 where
13672 D: serde::Deserializer<'de>,
13673 {
13674 const FIELDS: &[&str] = &[
13675 "create_at",
13676 "createAt",
13677 "compact_task",
13678 "compactTask",
13679 "vacuum_task",
13680 "vacuumTask",
13681 "full_scan_task",
13682 "fullScanTask",
13683 "validation_task",
13684 "validationTask",
13685 "cancel_compact_task",
13686 "cancelCompactTask",
13687 "pull_task_ack",
13688 "pullTaskAck",
13689 ];
13690
13691 #[allow(clippy::enum_variant_names)]
13692 enum GeneratedField {
13693 CreateAt,
13694 CompactTask,
13695 VacuumTask,
13696 FullScanTask,
13697 ValidationTask,
13698 CancelCompactTask,
13699 PullTaskAck,
13700 }
13701 impl<'de> serde::Deserialize<'de> for GeneratedField {
13702 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13703 where
13704 D: serde::Deserializer<'de>,
13705 {
13706 struct GeneratedVisitor;
13707
13708 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13709 type Value = GeneratedField;
13710
13711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13712 write!(formatter, "expected one of: {:?}", &FIELDS)
13713 }
13714
13715 #[allow(unused_variables)]
13716 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13717 where
13718 E: serde::de::Error,
13719 {
13720 match value {
13721 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
13722 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
13723 "vacuumTask" | "vacuum_task" => Ok(GeneratedField::VacuumTask),
13724 "fullScanTask" | "full_scan_task" => Ok(GeneratedField::FullScanTask),
13725 "validationTask" | "validation_task" => Ok(GeneratedField::ValidationTask),
13726 "cancelCompactTask" | "cancel_compact_task" => Ok(GeneratedField::CancelCompactTask),
13727 "pullTaskAck" | "pull_task_ack" => Ok(GeneratedField::PullTaskAck),
13728 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13729 }
13730 }
13731 }
13732 deserializer.deserialize_identifier(GeneratedVisitor)
13733 }
13734 }
13735 struct GeneratedVisitor;
13736 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13737 type Value = SubscribeCompactionEventResponse;
13738
13739 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13740 formatter.write_str("struct hummock.SubscribeCompactionEventResponse")
13741 }
13742
13743 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventResponse, V::Error>
13744 where
13745 V: serde::de::MapAccess<'de>,
13746 {
13747 let mut create_at__ = None;
13748 let mut event__ = None;
13749 while let Some(k) = map_.next_key()? {
13750 match k {
13751 GeneratedField::CreateAt => {
13752 if create_at__.is_some() {
13753 return Err(serde::de::Error::duplicate_field("createAt"));
13754 }
13755 create_at__ =
13756 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13757 ;
13758 }
13759 GeneratedField::CompactTask => {
13760 if event__.is_some() {
13761 return Err(serde::de::Error::duplicate_field("compactTask"));
13762 }
13763 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CompactTask)
13764;
13765 }
13766 GeneratedField::VacuumTask => {
13767 if event__.is_some() {
13768 return Err(serde::de::Error::duplicate_field("vacuumTask"));
13769 }
13770 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::VacuumTask)
13771;
13772 }
13773 GeneratedField::FullScanTask => {
13774 if event__.is_some() {
13775 return Err(serde::de::Error::duplicate_field("fullScanTask"));
13776 }
13777 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::FullScanTask)
13778;
13779 }
13780 GeneratedField::ValidationTask => {
13781 if event__.is_some() {
13782 return Err(serde::de::Error::duplicate_field("validationTask"));
13783 }
13784 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::ValidationTask)
13785;
13786 }
13787 GeneratedField::CancelCompactTask => {
13788 if event__.is_some() {
13789 return Err(serde::de::Error::duplicate_field("cancelCompactTask"));
13790 }
13791 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CancelCompactTask)
13792;
13793 }
13794 GeneratedField::PullTaskAck => {
13795 if event__.is_some() {
13796 return Err(serde::de::Error::duplicate_field("pullTaskAck"));
13797 }
13798 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::PullTaskAck)
13799;
13800 }
13801 }
13802 }
13803 Ok(SubscribeCompactionEventResponse {
13804 create_at: create_at__.unwrap_or_default(),
13805 event: event__,
13806 })
13807 }
13808 }
13809 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse", FIELDS, GeneratedVisitor)
13810 }
13811}
13812impl serde::Serialize for subscribe_compaction_event_response::PullTaskAck {
13813 #[allow(deprecated)]
13814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13815 where
13816 S: serde::Serializer,
13817 {
13818 use serde::ser::SerializeStruct;
13819 let len = 0;
13820 let struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", len)?;
13821 struct_ser.end()
13822 }
13823}
13824impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_response::PullTaskAck {
13825 #[allow(deprecated)]
13826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13827 where
13828 D: serde::Deserializer<'de>,
13829 {
13830 const FIELDS: &[&str] = &[
13831 ];
13832
13833 #[allow(clippy::enum_variant_names)]
13834 enum GeneratedField {
13835 }
13836 impl<'de> serde::Deserialize<'de> for GeneratedField {
13837 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13838 where
13839 D: serde::Deserializer<'de>,
13840 {
13841 struct GeneratedVisitor;
13842
13843 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13844 type Value = GeneratedField;
13845
13846 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13847 write!(formatter, "expected one of: {:?}", &FIELDS)
13848 }
13849
13850 #[allow(unused_variables)]
13851 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13852 where
13853 E: serde::de::Error,
13854 {
13855 Err(serde::de::Error::unknown_field(value, FIELDS))
13856 }
13857 }
13858 deserializer.deserialize_identifier(GeneratedVisitor)
13859 }
13860 }
13861 struct GeneratedVisitor;
13862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13863 type Value = subscribe_compaction_event_response::PullTaskAck;
13864
13865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13866 formatter.write_str("struct hummock.SubscribeCompactionEventResponse.PullTaskAck")
13867 }
13868
13869 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_response::PullTaskAck, V::Error>
13870 where
13871 V: serde::de::MapAccess<'de>,
13872 {
13873 while map_.next_key::<GeneratedField>()?.is_some() {
13874 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13875 }
13876 Ok(subscribe_compaction_event_response::PullTaskAck {
13877 })
13878 }
13879 }
13880 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", FIELDS, GeneratedVisitor)
13881 }
13882}
13883impl serde::Serialize for TableChangeLog {
13884 #[allow(deprecated)]
13885 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13886 where
13887 S: serde::Serializer,
13888 {
13889 use serde::ser::SerializeStruct;
13890 let mut len = 0;
13891 if !self.change_logs.is_empty() {
13892 len += 1;
13893 }
13894 let mut struct_ser = serializer.serialize_struct("hummock.TableChangeLog", len)?;
13895 if !self.change_logs.is_empty() {
13896 struct_ser.serialize_field("changeLogs", &self.change_logs)?;
13897 }
13898 struct_ser.end()
13899 }
13900}
13901impl<'de> serde::Deserialize<'de> for TableChangeLog {
13902 #[allow(deprecated)]
13903 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13904 where
13905 D: serde::Deserializer<'de>,
13906 {
13907 const FIELDS: &[&str] = &[
13908 "change_logs",
13909 "changeLogs",
13910 ];
13911
13912 #[allow(clippy::enum_variant_names)]
13913 enum GeneratedField {
13914 ChangeLogs,
13915 }
13916 impl<'de> serde::Deserialize<'de> for GeneratedField {
13917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13918 where
13919 D: serde::Deserializer<'de>,
13920 {
13921 struct GeneratedVisitor;
13922
13923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13924 type Value = GeneratedField;
13925
13926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13927 write!(formatter, "expected one of: {:?}", &FIELDS)
13928 }
13929
13930 #[allow(unused_variables)]
13931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13932 where
13933 E: serde::de::Error,
13934 {
13935 match value {
13936 "changeLogs" | "change_logs" => Ok(GeneratedField::ChangeLogs),
13937 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13938 }
13939 }
13940 }
13941 deserializer.deserialize_identifier(GeneratedVisitor)
13942 }
13943 }
13944 struct GeneratedVisitor;
13945 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13946 type Value = TableChangeLog;
13947
13948 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13949 formatter.write_str("struct hummock.TableChangeLog")
13950 }
13951
13952 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableChangeLog, V::Error>
13953 where
13954 V: serde::de::MapAccess<'de>,
13955 {
13956 let mut change_logs__ = None;
13957 while let Some(k) = map_.next_key()? {
13958 match k {
13959 GeneratedField::ChangeLogs => {
13960 if change_logs__.is_some() {
13961 return Err(serde::de::Error::duplicate_field("changeLogs"));
13962 }
13963 change_logs__ = Some(map_.next_value()?);
13964 }
13965 }
13966 }
13967 Ok(TableChangeLog {
13968 change_logs: change_logs__.unwrap_or_default(),
13969 })
13970 }
13971 }
13972 deserializer.deserialize_struct("hummock.TableChangeLog", FIELDS, GeneratedVisitor)
13973 }
13974}
13975impl serde::Serialize for TableOption {
13976 #[allow(deprecated)]
13977 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13978 where
13979 S: serde::Serializer,
13980 {
13981 use serde::ser::SerializeStruct;
13982 let mut len = 0;
13983 if self.retention_seconds.is_some() {
13984 len += 1;
13985 }
13986 let mut struct_ser = serializer.serialize_struct("hummock.TableOption", len)?;
13987 if let Some(v) = self.retention_seconds.as_ref() {
13988 struct_ser.serialize_field("retentionSeconds", v)?;
13989 }
13990 struct_ser.end()
13991 }
13992}
13993impl<'de> serde::Deserialize<'de> for TableOption {
13994 #[allow(deprecated)]
13995 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13996 where
13997 D: serde::Deserializer<'de>,
13998 {
13999 const FIELDS: &[&str] = &[
14000 "retention_seconds",
14001 "retentionSeconds",
14002 ];
14003
14004 #[allow(clippy::enum_variant_names)]
14005 enum GeneratedField {
14006 RetentionSeconds,
14007 }
14008 impl<'de> serde::Deserialize<'de> for GeneratedField {
14009 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14010 where
14011 D: serde::Deserializer<'de>,
14012 {
14013 struct GeneratedVisitor;
14014
14015 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14016 type Value = GeneratedField;
14017
14018 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14019 write!(formatter, "expected one of: {:?}", &FIELDS)
14020 }
14021
14022 #[allow(unused_variables)]
14023 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14024 where
14025 E: serde::de::Error,
14026 {
14027 match value {
14028 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
14029 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14030 }
14031 }
14032 }
14033 deserializer.deserialize_identifier(GeneratedVisitor)
14034 }
14035 }
14036 struct GeneratedVisitor;
14037 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14038 type Value = TableOption;
14039
14040 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14041 formatter.write_str("struct hummock.TableOption")
14042 }
14043
14044 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableOption, V::Error>
14045 where
14046 V: serde::de::MapAccess<'de>,
14047 {
14048 let mut retention_seconds__ = None;
14049 while let Some(k) = map_.next_key()? {
14050 match k {
14051 GeneratedField::RetentionSeconds => {
14052 if retention_seconds__.is_some() {
14053 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
14054 }
14055 retention_seconds__ =
14056 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14057 ;
14058 }
14059 }
14060 }
14061 Ok(TableOption {
14062 retention_seconds: retention_seconds__,
14063 })
14064 }
14065 }
14066 deserializer.deserialize_struct("hummock.TableOption", FIELDS, GeneratedVisitor)
14067 }
14068}
14069impl serde::Serialize for TableSchema {
14070 #[allow(deprecated)]
14071 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14072 where
14073 S: serde::Serializer,
14074 {
14075 use serde::ser::SerializeStruct;
14076 let mut len = 0;
14077 if !self.column_ids.is_empty() {
14078 len += 1;
14079 }
14080 let mut struct_ser = serializer.serialize_struct("hummock.TableSchema", len)?;
14081 if !self.column_ids.is_empty() {
14082 struct_ser.serialize_field("columnIds", &self.column_ids)?;
14083 }
14084 struct_ser.end()
14085 }
14086}
14087impl<'de> serde::Deserialize<'de> for TableSchema {
14088 #[allow(deprecated)]
14089 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14090 where
14091 D: serde::Deserializer<'de>,
14092 {
14093 const FIELDS: &[&str] = &[
14094 "column_ids",
14095 "columnIds",
14096 ];
14097
14098 #[allow(clippy::enum_variant_names)]
14099 enum GeneratedField {
14100 ColumnIds,
14101 }
14102 impl<'de> serde::Deserialize<'de> for GeneratedField {
14103 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14104 where
14105 D: serde::Deserializer<'de>,
14106 {
14107 struct GeneratedVisitor;
14108
14109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14110 type Value = GeneratedField;
14111
14112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14113 write!(formatter, "expected one of: {:?}", &FIELDS)
14114 }
14115
14116 #[allow(unused_variables)]
14117 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14118 where
14119 E: serde::de::Error,
14120 {
14121 match value {
14122 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
14123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14124 }
14125 }
14126 }
14127 deserializer.deserialize_identifier(GeneratedVisitor)
14128 }
14129 }
14130 struct GeneratedVisitor;
14131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14132 type Value = TableSchema;
14133
14134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14135 formatter.write_str("struct hummock.TableSchema")
14136 }
14137
14138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
14139 where
14140 V: serde::de::MapAccess<'de>,
14141 {
14142 let mut column_ids__ = None;
14143 while let Some(k) = map_.next_key()? {
14144 match k {
14145 GeneratedField::ColumnIds => {
14146 if column_ids__.is_some() {
14147 return Err(serde::de::Error::duplicate_field("columnIds"));
14148 }
14149 column_ids__ =
14150 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14151 .into_iter().map(|x| x.0).collect())
14152 ;
14153 }
14154 }
14155 }
14156 Ok(TableSchema {
14157 column_ids: column_ids__.unwrap_or_default(),
14158 })
14159 }
14160 }
14161 deserializer.deserialize_struct("hummock.TableSchema", FIELDS, GeneratedVisitor)
14162 }
14163}
14164impl serde::Serialize for TableStats {
14165 #[allow(deprecated)]
14166 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14167 where
14168 S: serde::Serializer,
14169 {
14170 use serde::ser::SerializeStruct;
14171 let mut len = 0;
14172 if self.total_key_size != 0 {
14173 len += 1;
14174 }
14175 if self.total_value_size != 0 {
14176 len += 1;
14177 }
14178 if self.total_key_count != 0 {
14179 len += 1;
14180 }
14181 if self.total_compressed_size != 0 {
14182 len += 1;
14183 }
14184 let mut struct_ser = serializer.serialize_struct("hummock.TableStats", len)?;
14185 if self.total_key_size != 0 {
14186 #[allow(clippy::needless_borrow)]
14187 #[allow(clippy::needless_borrows_for_generic_args)]
14188 struct_ser.serialize_field("totalKeySize", ToString::to_string(&self.total_key_size).as_str())?;
14189 }
14190 if self.total_value_size != 0 {
14191 #[allow(clippy::needless_borrow)]
14192 #[allow(clippy::needless_borrows_for_generic_args)]
14193 struct_ser.serialize_field("totalValueSize", ToString::to_string(&self.total_value_size).as_str())?;
14194 }
14195 if self.total_key_count != 0 {
14196 #[allow(clippy::needless_borrow)]
14197 #[allow(clippy::needless_borrows_for_generic_args)]
14198 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
14199 }
14200 if self.total_compressed_size != 0 {
14201 #[allow(clippy::needless_borrow)]
14202 #[allow(clippy::needless_borrows_for_generic_args)]
14203 struct_ser.serialize_field("totalCompressedSize", ToString::to_string(&self.total_compressed_size).as_str())?;
14204 }
14205 struct_ser.end()
14206 }
14207}
14208impl<'de> serde::Deserialize<'de> for TableStats {
14209 #[allow(deprecated)]
14210 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14211 where
14212 D: serde::Deserializer<'de>,
14213 {
14214 const FIELDS: &[&str] = &[
14215 "total_key_size",
14216 "totalKeySize",
14217 "total_value_size",
14218 "totalValueSize",
14219 "total_key_count",
14220 "totalKeyCount",
14221 "total_compressed_size",
14222 "totalCompressedSize",
14223 ];
14224
14225 #[allow(clippy::enum_variant_names)]
14226 enum GeneratedField {
14227 TotalKeySize,
14228 TotalValueSize,
14229 TotalKeyCount,
14230 TotalCompressedSize,
14231 }
14232 impl<'de> serde::Deserialize<'de> for GeneratedField {
14233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14234 where
14235 D: serde::Deserializer<'de>,
14236 {
14237 struct GeneratedVisitor;
14238
14239 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14240 type Value = GeneratedField;
14241
14242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14243 write!(formatter, "expected one of: {:?}", &FIELDS)
14244 }
14245
14246 #[allow(unused_variables)]
14247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14248 where
14249 E: serde::de::Error,
14250 {
14251 match value {
14252 "totalKeySize" | "total_key_size" => Ok(GeneratedField::TotalKeySize),
14253 "totalValueSize" | "total_value_size" => Ok(GeneratedField::TotalValueSize),
14254 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
14255 "totalCompressedSize" | "total_compressed_size" => Ok(GeneratedField::TotalCompressedSize),
14256 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14257 }
14258 }
14259 }
14260 deserializer.deserialize_identifier(GeneratedVisitor)
14261 }
14262 }
14263 struct GeneratedVisitor;
14264 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14265 type Value = TableStats;
14266
14267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14268 formatter.write_str("struct hummock.TableStats")
14269 }
14270
14271 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableStats, V::Error>
14272 where
14273 V: serde::de::MapAccess<'de>,
14274 {
14275 let mut total_key_size__ = None;
14276 let mut total_value_size__ = None;
14277 let mut total_key_count__ = None;
14278 let mut total_compressed_size__ = None;
14279 while let Some(k) = map_.next_key()? {
14280 match k {
14281 GeneratedField::TotalKeySize => {
14282 if total_key_size__.is_some() {
14283 return Err(serde::de::Error::duplicate_field("totalKeySize"));
14284 }
14285 total_key_size__ =
14286 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14287 ;
14288 }
14289 GeneratedField::TotalValueSize => {
14290 if total_value_size__.is_some() {
14291 return Err(serde::de::Error::duplicate_field("totalValueSize"));
14292 }
14293 total_value_size__ =
14294 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14295 ;
14296 }
14297 GeneratedField::TotalKeyCount => {
14298 if total_key_count__.is_some() {
14299 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
14300 }
14301 total_key_count__ =
14302 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14303 ;
14304 }
14305 GeneratedField::TotalCompressedSize => {
14306 if total_compressed_size__.is_some() {
14307 return Err(serde::de::Error::duplicate_field("totalCompressedSize"));
14308 }
14309 total_compressed_size__ =
14310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14311 ;
14312 }
14313 }
14314 }
14315 Ok(TableStats {
14316 total_key_size: total_key_size__.unwrap_or_default(),
14317 total_value_size: total_value_size__.unwrap_or_default(),
14318 total_key_count: total_key_count__.unwrap_or_default(),
14319 total_compressed_size: total_compressed_size__.unwrap_or_default(),
14320 })
14321 }
14322 }
14323 deserializer.deserialize_struct("hummock.TableStats", FIELDS, GeneratedVisitor)
14324 }
14325}
14326impl serde::Serialize for TableWatermarks {
14327 #[allow(deprecated)]
14328 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14329 where
14330 S: serde::Serializer,
14331 {
14332 use serde::ser::SerializeStruct;
14333 let mut len = 0;
14334 if !self.epoch_watermarks.is_empty() {
14335 len += 1;
14336 }
14337 if self.is_ascending {
14338 len += 1;
14339 }
14340 if self.is_non_pk_prefix {
14341 len += 1;
14342 }
14343 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks", len)?;
14344 if !self.epoch_watermarks.is_empty() {
14345 struct_ser.serialize_field("epochWatermarks", &self.epoch_watermarks)?;
14346 }
14347 if self.is_ascending {
14348 struct_ser.serialize_field("isAscending", &self.is_ascending)?;
14349 }
14350 if self.is_non_pk_prefix {
14351 struct_ser.serialize_field("isNonPkPrefix", &self.is_non_pk_prefix)?;
14352 }
14353 struct_ser.end()
14354 }
14355}
14356impl<'de> serde::Deserialize<'de> for TableWatermarks {
14357 #[allow(deprecated)]
14358 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14359 where
14360 D: serde::Deserializer<'de>,
14361 {
14362 const FIELDS: &[&str] = &[
14363 "epoch_watermarks",
14364 "epochWatermarks",
14365 "is_ascending",
14366 "isAscending",
14367 "is_non_pk_prefix",
14368 "isNonPkPrefix",
14369 ];
14370
14371 #[allow(clippy::enum_variant_names)]
14372 enum GeneratedField {
14373 EpochWatermarks,
14374 IsAscending,
14375 IsNonPkPrefix,
14376 }
14377 impl<'de> serde::Deserialize<'de> for GeneratedField {
14378 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14379 where
14380 D: serde::Deserializer<'de>,
14381 {
14382 struct GeneratedVisitor;
14383
14384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14385 type Value = GeneratedField;
14386
14387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14388 write!(formatter, "expected one of: {:?}", &FIELDS)
14389 }
14390
14391 #[allow(unused_variables)]
14392 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14393 where
14394 E: serde::de::Error,
14395 {
14396 match value {
14397 "epochWatermarks" | "epoch_watermarks" => Ok(GeneratedField::EpochWatermarks),
14398 "isAscending" | "is_ascending" => Ok(GeneratedField::IsAscending),
14399 "isNonPkPrefix" | "is_non_pk_prefix" => Ok(GeneratedField::IsNonPkPrefix),
14400 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14401 }
14402 }
14403 }
14404 deserializer.deserialize_identifier(GeneratedVisitor)
14405 }
14406 }
14407 struct GeneratedVisitor;
14408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14409 type Value = TableWatermarks;
14410
14411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14412 formatter.write_str("struct hummock.TableWatermarks")
14413 }
14414
14415 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableWatermarks, V::Error>
14416 where
14417 V: serde::de::MapAccess<'de>,
14418 {
14419 let mut epoch_watermarks__ = None;
14420 let mut is_ascending__ = None;
14421 let mut is_non_pk_prefix__ = None;
14422 while let Some(k) = map_.next_key()? {
14423 match k {
14424 GeneratedField::EpochWatermarks => {
14425 if epoch_watermarks__.is_some() {
14426 return Err(serde::de::Error::duplicate_field("epochWatermarks"));
14427 }
14428 epoch_watermarks__ = Some(map_.next_value()?);
14429 }
14430 GeneratedField::IsAscending => {
14431 if is_ascending__.is_some() {
14432 return Err(serde::de::Error::duplicate_field("isAscending"));
14433 }
14434 is_ascending__ = Some(map_.next_value()?);
14435 }
14436 GeneratedField::IsNonPkPrefix => {
14437 if is_non_pk_prefix__.is_some() {
14438 return Err(serde::de::Error::duplicate_field("isNonPkPrefix"));
14439 }
14440 is_non_pk_prefix__ = Some(map_.next_value()?);
14441 }
14442 }
14443 }
14444 Ok(TableWatermarks {
14445 epoch_watermarks: epoch_watermarks__.unwrap_or_default(),
14446 is_ascending: is_ascending__.unwrap_or_default(),
14447 is_non_pk_prefix: is_non_pk_prefix__.unwrap_or_default(),
14448 })
14449 }
14450 }
14451 deserializer.deserialize_struct("hummock.TableWatermarks", FIELDS, GeneratedVisitor)
14452 }
14453}
14454impl serde::Serialize for table_watermarks::EpochNewWatermarks {
14455 #[allow(deprecated)]
14456 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14457 where
14458 S: serde::Serializer,
14459 {
14460 use serde::ser::SerializeStruct;
14461 let mut len = 0;
14462 if !self.watermarks.is_empty() {
14463 len += 1;
14464 }
14465 if self.epoch != 0 {
14466 len += 1;
14467 }
14468 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks.EpochNewWatermarks", len)?;
14469 if !self.watermarks.is_empty() {
14470 struct_ser.serialize_field("watermarks", &self.watermarks)?;
14471 }
14472 if self.epoch != 0 {
14473 #[allow(clippy::needless_borrow)]
14474 #[allow(clippy::needless_borrows_for_generic_args)]
14475 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
14476 }
14477 struct_ser.end()
14478 }
14479}
14480impl<'de> serde::Deserialize<'de> for table_watermarks::EpochNewWatermarks {
14481 #[allow(deprecated)]
14482 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14483 where
14484 D: serde::Deserializer<'de>,
14485 {
14486 const FIELDS: &[&str] = &[
14487 "watermarks",
14488 "epoch",
14489 ];
14490
14491 #[allow(clippy::enum_variant_names)]
14492 enum GeneratedField {
14493 Watermarks,
14494 Epoch,
14495 }
14496 impl<'de> serde::Deserialize<'de> for GeneratedField {
14497 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14498 where
14499 D: serde::Deserializer<'de>,
14500 {
14501 struct GeneratedVisitor;
14502
14503 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14504 type Value = GeneratedField;
14505
14506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14507 write!(formatter, "expected one of: {:?}", &FIELDS)
14508 }
14509
14510 #[allow(unused_variables)]
14511 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14512 where
14513 E: serde::de::Error,
14514 {
14515 match value {
14516 "watermarks" => Ok(GeneratedField::Watermarks),
14517 "epoch" => Ok(GeneratedField::Epoch),
14518 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14519 }
14520 }
14521 }
14522 deserializer.deserialize_identifier(GeneratedVisitor)
14523 }
14524 }
14525 struct GeneratedVisitor;
14526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14527 type Value = table_watermarks::EpochNewWatermarks;
14528
14529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14530 formatter.write_str("struct hummock.TableWatermarks.EpochNewWatermarks")
14531 }
14532
14533 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_watermarks::EpochNewWatermarks, V::Error>
14534 where
14535 V: serde::de::MapAccess<'de>,
14536 {
14537 let mut watermarks__ = None;
14538 let mut epoch__ = None;
14539 while let Some(k) = map_.next_key()? {
14540 match k {
14541 GeneratedField::Watermarks => {
14542 if watermarks__.is_some() {
14543 return Err(serde::de::Error::duplicate_field("watermarks"));
14544 }
14545 watermarks__ = Some(map_.next_value()?);
14546 }
14547 GeneratedField::Epoch => {
14548 if epoch__.is_some() {
14549 return Err(serde::de::Error::duplicate_field("epoch"));
14550 }
14551 epoch__ =
14552 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14553 ;
14554 }
14555 }
14556 }
14557 Ok(table_watermarks::EpochNewWatermarks {
14558 watermarks: watermarks__.unwrap_or_default(),
14559 epoch: epoch__.unwrap_or_default(),
14560 })
14561 }
14562 }
14563 deserializer.deserialize_struct("hummock.TableWatermarks.EpochNewWatermarks", FIELDS, GeneratedVisitor)
14564 }
14565}
14566impl serde::Serialize for TriggerCompactionDeterministicRequest {
14567 #[allow(deprecated)]
14568 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14569 where
14570 S: serde::Serializer,
14571 {
14572 use serde::ser::SerializeStruct;
14573 let mut len = 0;
14574 if self.version_id != 0 {
14575 len += 1;
14576 }
14577 if !self.compaction_groups.is_empty() {
14578 len += 1;
14579 }
14580 let mut struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicRequest", len)?;
14581 if self.version_id != 0 {
14582 #[allow(clippy::needless_borrow)]
14583 #[allow(clippy::needless_borrows_for_generic_args)]
14584 struct_ser.serialize_field("versionId", ToString::to_string(&self.version_id).as_str())?;
14585 }
14586 if !self.compaction_groups.is_empty() {
14587 struct_ser.serialize_field("compactionGroups", &self.compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
14588 }
14589 struct_ser.end()
14590 }
14591}
14592impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicRequest {
14593 #[allow(deprecated)]
14594 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14595 where
14596 D: serde::Deserializer<'de>,
14597 {
14598 const FIELDS: &[&str] = &[
14599 "version_id",
14600 "versionId",
14601 "compaction_groups",
14602 "compactionGroups",
14603 ];
14604
14605 #[allow(clippy::enum_variant_names)]
14606 enum GeneratedField {
14607 VersionId,
14608 CompactionGroups,
14609 }
14610 impl<'de> serde::Deserialize<'de> for GeneratedField {
14611 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14612 where
14613 D: serde::Deserializer<'de>,
14614 {
14615 struct GeneratedVisitor;
14616
14617 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14618 type Value = GeneratedField;
14619
14620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14621 write!(formatter, "expected one of: {:?}", &FIELDS)
14622 }
14623
14624 #[allow(unused_variables)]
14625 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14626 where
14627 E: serde::de::Error,
14628 {
14629 match value {
14630 "versionId" | "version_id" => Ok(GeneratedField::VersionId),
14631 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
14632 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14633 }
14634 }
14635 }
14636 deserializer.deserialize_identifier(GeneratedVisitor)
14637 }
14638 }
14639 struct GeneratedVisitor;
14640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14641 type Value = TriggerCompactionDeterministicRequest;
14642
14643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14644 formatter.write_str("struct hummock.TriggerCompactionDeterministicRequest")
14645 }
14646
14647 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicRequest, V::Error>
14648 where
14649 V: serde::de::MapAccess<'de>,
14650 {
14651 let mut version_id__ = None;
14652 let mut compaction_groups__ = None;
14653 while let Some(k) = map_.next_key()? {
14654 match k {
14655 GeneratedField::VersionId => {
14656 if version_id__.is_some() {
14657 return Err(serde::de::Error::duplicate_field("versionId"));
14658 }
14659 version_id__ =
14660 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14661 ;
14662 }
14663 GeneratedField::CompactionGroups => {
14664 if compaction_groups__.is_some() {
14665 return Err(serde::de::Error::duplicate_field("compactionGroups"));
14666 }
14667 compaction_groups__ =
14668 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14669 .into_iter().map(|x| x.0).collect())
14670 ;
14671 }
14672 }
14673 }
14674 Ok(TriggerCompactionDeterministicRequest {
14675 version_id: version_id__.unwrap_or_default(),
14676 compaction_groups: compaction_groups__.unwrap_or_default(),
14677 })
14678 }
14679 }
14680 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicRequest", FIELDS, GeneratedVisitor)
14681 }
14682}
14683impl serde::Serialize for TriggerCompactionDeterministicResponse {
14684 #[allow(deprecated)]
14685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14686 where
14687 S: serde::Serializer,
14688 {
14689 use serde::ser::SerializeStruct;
14690 let len = 0;
14691 let struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicResponse", len)?;
14692 struct_ser.end()
14693 }
14694}
14695impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicResponse {
14696 #[allow(deprecated)]
14697 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14698 where
14699 D: serde::Deserializer<'de>,
14700 {
14701 const FIELDS: &[&str] = &[
14702 ];
14703
14704 #[allow(clippy::enum_variant_names)]
14705 enum GeneratedField {
14706 }
14707 impl<'de> serde::Deserialize<'de> for GeneratedField {
14708 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14709 where
14710 D: serde::Deserializer<'de>,
14711 {
14712 struct GeneratedVisitor;
14713
14714 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14715 type Value = GeneratedField;
14716
14717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14718 write!(formatter, "expected one of: {:?}", &FIELDS)
14719 }
14720
14721 #[allow(unused_variables)]
14722 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14723 where
14724 E: serde::de::Error,
14725 {
14726 Err(serde::de::Error::unknown_field(value, FIELDS))
14727 }
14728 }
14729 deserializer.deserialize_identifier(GeneratedVisitor)
14730 }
14731 }
14732 struct GeneratedVisitor;
14733 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14734 type Value = TriggerCompactionDeterministicResponse;
14735
14736 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14737 formatter.write_str("struct hummock.TriggerCompactionDeterministicResponse")
14738 }
14739
14740 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicResponse, V::Error>
14741 where
14742 V: serde::de::MapAccess<'de>,
14743 {
14744 while map_.next_key::<GeneratedField>()?.is_some() {
14745 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14746 }
14747 Ok(TriggerCompactionDeterministicResponse {
14748 })
14749 }
14750 }
14751 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicResponse", FIELDS, GeneratedVisitor)
14752 }
14753}
14754impl serde::Serialize for TriggerFullGcRequest {
14755 #[allow(deprecated)]
14756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14757 where
14758 S: serde::Serializer,
14759 {
14760 use serde::ser::SerializeStruct;
14761 let mut len = 0;
14762 if self.sst_retention_time_sec != 0 {
14763 len += 1;
14764 }
14765 if self.prefix.is_some() {
14766 len += 1;
14767 }
14768 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCRequest", len)?;
14769 if self.sst_retention_time_sec != 0 {
14770 #[allow(clippy::needless_borrow)]
14771 #[allow(clippy::needless_borrows_for_generic_args)]
14772 struct_ser.serialize_field("sstRetentionTimeSec", ToString::to_string(&self.sst_retention_time_sec).as_str())?;
14773 }
14774 if let Some(v) = self.prefix.as_ref() {
14775 struct_ser.serialize_field("prefix", v)?;
14776 }
14777 struct_ser.end()
14778 }
14779}
14780impl<'de> serde::Deserialize<'de> for TriggerFullGcRequest {
14781 #[allow(deprecated)]
14782 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14783 where
14784 D: serde::Deserializer<'de>,
14785 {
14786 const FIELDS: &[&str] = &[
14787 "sst_retention_time_sec",
14788 "sstRetentionTimeSec",
14789 "prefix",
14790 ];
14791
14792 #[allow(clippy::enum_variant_names)]
14793 enum GeneratedField {
14794 SstRetentionTimeSec,
14795 Prefix,
14796 }
14797 impl<'de> serde::Deserialize<'de> for GeneratedField {
14798 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14799 where
14800 D: serde::Deserializer<'de>,
14801 {
14802 struct GeneratedVisitor;
14803
14804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14805 type Value = GeneratedField;
14806
14807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14808 write!(formatter, "expected one of: {:?}", &FIELDS)
14809 }
14810
14811 #[allow(unused_variables)]
14812 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14813 where
14814 E: serde::de::Error,
14815 {
14816 match value {
14817 "sstRetentionTimeSec" | "sst_retention_time_sec" => Ok(GeneratedField::SstRetentionTimeSec),
14818 "prefix" => Ok(GeneratedField::Prefix),
14819 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14820 }
14821 }
14822 }
14823 deserializer.deserialize_identifier(GeneratedVisitor)
14824 }
14825 }
14826 struct GeneratedVisitor;
14827 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14828 type Value = TriggerFullGcRequest;
14829
14830 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14831 formatter.write_str("struct hummock.TriggerFullGCRequest")
14832 }
14833
14834 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcRequest, V::Error>
14835 where
14836 V: serde::de::MapAccess<'de>,
14837 {
14838 let mut sst_retention_time_sec__ = None;
14839 let mut prefix__ = None;
14840 while let Some(k) = map_.next_key()? {
14841 match k {
14842 GeneratedField::SstRetentionTimeSec => {
14843 if sst_retention_time_sec__.is_some() {
14844 return Err(serde::de::Error::duplicate_field("sstRetentionTimeSec"));
14845 }
14846 sst_retention_time_sec__ =
14847 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14848 ;
14849 }
14850 GeneratedField::Prefix => {
14851 if prefix__.is_some() {
14852 return Err(serde::de::Error::duplicate_field("prefix"));
14853 }
14854 prefix__ = map_.next_value()?;
14855 }
14856 }
14857 }
14858 Ok(TriggerFullGcRequest {
14859 sst_retention_time_sec: sst_retention_time_sec__.unwrap_or_default(),
14860 prefix: prefix__,
14861 })
14862 }
14863 }
14864 deserializer.deserialize_struct("hummock.TriggerFullGCRequest", FIELDS, GeneratedVisitor)
14865 }
14866}
14867impl serde::Serialize for TriggerFullGcResponse {
14868 #[allow(deprecated)]
14869 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14870 where
14871 S: serde::Serializer,
14872 {
14873 use serde::ser::SerializeStruct;
14874 let mut len = 0;
14875 if self.status.is_some() {
14876 len += 1;
14877 }
14878 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCResponse", len)?;
14879 if let Some(v) = self.status.as_ref() {
14880 struct_ser.serialize_field("status", v)?;
14881 }
14882 struct_ser.end()
14883 }
14884}
14885impl<'de> serde::Deserialize<'de> for TriggerFullGcResponse {
14886 #[allow(deprecated)]
14887 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14888 where
14889 D: serde::Deserializer<'de>,
14890 {
14891 const FIELDS: &[&str] = &[
14892 "status",
14893 ];
14894
14895 #[allow(clippy::enum_variant_names)]
14896 enum GeneratedField {
14897 Status,
14898 }
14899 impl<'de> serde::Deserialize<'de> for GeneratedField {
14900 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14901 where
14902 D: serde::Deserializer<'de>,
14903 {
14904 struct GeneratedVisitor;
14905
14906 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14907 type Value = GeneratedField;
14908
14909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14910 write!(formatter, "expected one of: {:?}", &FIELDS)
14911 }
14912
14913 #[allow(unused_variables)]
14914 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14915 where
14916 E: serde::de::Error,
14917 {
14918 match value {
14919 "status" => Ok(GeneratedField::Status),
14920 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14921 }
14922 }
14923 }
14924 deserializer.deserialize_identifier(GeneratedVisitor)
14925 }
14926 }
14927 struct GeneratedVisitor;
14928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14929 type Value = TriggerFullGcResponse;
14930
14931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14932 formatter.write_str("struct hummock.TriggerFullGCResponse")
14933 }
14934
14935 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcResponse, V::Error>
14936 where
14937 V: serde::de::MapAccess<'de>,
14938 {
14939 let mut status__ = None;
14940 while let Some(k) = map_.next_key()? {
14941 match k {
14942 GeneratedField::Status => {
14943 if status__.is_some() {
14944 return Err(serde::de::Error::duplicate_field("status"));
14945 }
14946 status__ = map_.next_value()?;
14947 }
14948 }
14949 }
14950 Ok(TriggerFullGcResponse {
14951 status: status__,
14952 })
14953 }
14954 }
14955 deserializer.deserialize_struct("hummock.TriggerFullGCResponse", FIELDS, GeneratedVisitor)
14956 }
14957}
14958impl serde::Serialize for TriggerManualCompactionRequest {
14959 #[allow(deprecated)]
14960 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14961 where
14962 S: serde::Serializer,
14963 {
14964 use serde::ser::SerializeStruct;
14965 let mut len = 0;
14966 if self.compaction_group_id != 0 {
14967 len += 1;
14968 }
14969 if self.key_range.is_some() {
14970 len += 1;
14971 }
14972 if self.table_id != 0 {
14973 len += 1;
14974 }
14975 if self.level != 0 {
14976 len += 1;
14977 }
14978 if !self.sst_ids.is_empty() {
14979 len += 1;
14980 }
14981 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionRequest", len)?;
14982 if self.compaction_group_id != 0 {
14983 #[allow(clippy::needless_borrow)]
14984 #[allow(clippy::needless_borrows_for_generic_args)]
14985 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
14986 }
14987 if let Some(v) = self.key_range.as_ref() {
14988 struct_ser.serialize_field("keyRange", v)?;
14989 }
14990 if self.table_id != 0 {
14991 struct_ser.serialize_field("tableId", &self.table_id)?;
14992 }
14993 if self.level != 0 {
14994 struct_ser.serialize_field("level", &self.level)?;
14995 }
14996 if !self.sst_ids.is_empty() {
14997 struct_ser.serialize_field("sstIds", &self.sst_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
14998 }
14999 struct_ser.end()
15000 }
15001}
15002impl<'de> serde::Deserialize<'de> for TriggerManualCompactionRequest {
15003 #[allow(deprecated)]
15004 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15005 where
15006 D: serde::Deserializer<'de>,
15007 {
15008 const FIELDS: &[&str] = &[
15009 "compaction_group_id",
15010 "compactionGroupId",
15011 "key_range",
15012 "keyRange",
15013 "table_id",
15014 "tableId",
15015 "level",
15016 "sst_ids",
15017 "sstIds",
15018 ];
15019
15020 #[allow(clippy::enum_variant_names)]
15021 enum GeneratedField {
15022 CompactionGroupId,
15023 KeyRange,
15024 TableId,
15025 Level,
15026 SstIds,
15027 }
15028 impl<'de> serde::Deserialize<'de> for GeneratedField {
15029 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15030 where
15031 D: serde::Deserializer<'de>,
15032 {
15033 struct GeneratedVisitor;
15034
15035 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15036 type Value = GeneratedField;
15037
15038 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15039 write!(formatter, "expected one of: {:?}", &FIELDS)
15040 }
15041
15042 #[allow(unused_variables)]
15043 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15044 where
15045 E: serde::de::Error,
15046 {
15047 match value {
15048 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
15049 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
15050 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15051 "level" => Ok(GeneratedField::Level),
15052 "sstIds" | "sst_ids" => Ok(GeneratedField::SstIds),
15053 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15054 }
15055 }
15056 }
15057 deserializer.deserialize_identifier(GeneratedVisitor)
15058 }
15059 }
15060 struct GeneratedVisitor;
15061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15062 type Value = TriggerManualCompactionRequest;
15063
15064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15065 formatter.write_str("struct hummock.TriggerManualCompactionRequest")
15066 }
15067
15068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionRequest, V::Error>
15069 where
15070 V: serde::de::MapAccess<'de>,
15071 {
15072 let mut compaction_group_id__ = None;
15073 let mut key_range__ = None;
15074 let mut table_id__ = None;
15075 let mut level__ = None;
15076 let mut sst_ids__ = None;
15077 while let Some(k) = map_.next_key()? {
15078 match k {
15079 GeneratedField::CompactionGroupId => {
15080 if compaction_group_id__.is_some() {
15081 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
15082 }
15083 compaction_group_id__ =
15084 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15085 ;
15086 }
15087 GeneratedField::KeyRange => {
15088 if key_range__.is_some() {
15089 return Err(serde::de::Error::duplicate_field("keyRange"));
15090 }
15091 key_range__ = map_.next_value()?;
15092 }
15093 GeneratedField::TableId => {
15094 if table_id__.is_some() {
15095 return Err(serde::de::Error::duplicate_field("tableId"));
15096 }
15097 table_id__ =
15098 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15099 ;
15100 }
15101 GeneratedField::Level => {
15102 if level__.is_some() {
15103 return Err(serde::de::Error::duplicate_field("level"));
15104 }
15105 level__ =
15106 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15107 ;
15108 }
15109 GeneratedField::SstIds => {
15110 if sst_ids__.is_some() {
15111 return Err(serde::de::Error::duplicate_field("sstIds"));
15112 }
15113 sst_ids__ =
15114 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15115 .into_iter().map(|x| x.0).collect())
15116 ;
15117 }
15118 }
15119 }
15120 Ok(TriggerManualCompactionRequest {
15121 compaction_group_id: compaction_group_id__.unwrap_or_default(),
15122 key_range: key_range__,
15123 table_id: table_id__.unwrap_or_default(),
15124 level: level__.unwrap_or_default(),
15125 sst_ids: sst_ids__.unwrap_or_default(),
15126 })
15127 }
15128 }
15129 deserializer.deserialize_struct("hummock.TriggerManualCompactionRequest", FIELDS, GeneratedVisitor)
15130 }
15131}
15132impl serde::Serialize for TriggerManualCompactionResponse {
15133 #[allow(deprecated)]
15134 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15135 where
15136 S: serde::Serializer,
15137 {
15138 use serde::ser::SerializeStruct;
15139 let mut len = 0;
15140 if self.status.is_some() {
15141 len += 1;
15142 }
15143 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionResponse", len)?;
15144 if let Some(v) = self.status.as_ref() {
15145 struct_ser.serialize_field("status", v)?;
15146 }
15147 struct_ser.end()
15148 }
15149}
15150impl<'de> serde::Deserialize<'de> for TriggerManualCompactionResponse {
15151 #[allow(deprecated)]
15152 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15153 where
15154 D: serde::Deserializer<'de>,
15155 {
15156 const FIELDS: &[&str] = &[
15157 "status",
15158 ];
15159
15160 #[allow(clippy::enum_variant_names)]
15161 enum GeneratedField {
15162 Status,
15163 }
15164 impl<'de> serde::Deserialize<'de> for GeneratedField {
15165 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15166 where
15167 D: serde::Deserializer<'de>,
15168 {
15169 struct GeneratedVisitor;
15170
15171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15172 type Value = GeneratedField;
15173
15174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15175 write!(formatter, "expected one of: {:?}", &FIELDS)
15176 }
15177
15178 #[allow(unused_variables)]
15179 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15180 where
15181 E: serde::de::Error,
15182 {
15183 match value {
15184 "status" => Ok(GeneratedField::Status),
15185 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15186 }
15187 }
15188 }
15189 deserializer.deserialize_identifier(GeneratedVisitor)
15190 }
15191 }
15192 struct GeneratedVisitor;
15193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15194 type Value = TriggerManualCompactionResponse;
15195
15196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15197 formatter.write_str("struct hummock.TriggerManualCompactionResponse")
15198 }
15199
15200 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionResponse, V::Error>
15201 where
15202 V: serde::de::MapAccess<'de>,
15203 {
15204 let mut status__ = None;
15205 while let Some(k) = map_.next_key()? {
15206 match k {
15207 GeneratedField::Status => {
15208 if status__.is_some() {
15209 return Err(serde::de::Error::duplicate_field("status"));
15210 }
15211 status__ = map_.next_value()?;
15212 }
15213 }
15214 }
15215 Ok(TriggerManualCompactionResponse {
15216 status: status__,
15217 })
15218 }
15219 }
15220 deserializer.deserialize_struct("hummock.TriggerManualCompactionResponse", FIELDS, GeneratedVisitor)
15221 }
15222}
15223impl serde::Serialize for UncommittedEpoch {
15224 #[allow(deprecated)]
15225 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15226 where
15227 S: serde::Serializer,
15228 {
15229 use serde::ser::SerializeStruct;
15230 let mut len = 0;
15231 if self.epoch != 0 {
15232 len += 1;
15233 }
15234 if !self.tables.is_empty() {
15235 len += 1;
15236 }
15237 let mut struct_ser = serializer.serialize_struct("hummock.UncommittedEpoch", len)?;
15238 if self.epoch != 0 {
15239 #[allow(clippy::needless_borrow)]
15240 #[allow(clippy::needless_borrows_for_generic_args)]
15241 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
15242 }
15243 if !self.tables.is_empty() {
15244 struct_ser.serialize_field("tables", &self.tables)?;
15245 }
15246 struct_ser.end()
15247 }
15248}
15249impl<'de> serde::Deserialize<'de> for UncommittedEpoch {
15250 #[allow(deprecated)]
15251 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15252 where
15253 D: serde::Deserializer<'de>,
15254 {
15255 const FIELDS: &[&str] = &[
15256 "epoch",
15257 "tables",
15258 ];
15259
15260 #[allow(clippy::enum_variant_names)]
15261 enum GeneratedField {
15262 Epoch,
15263 Tables,
15264 }
15265 impl<'de> serde::Deserialize<'de> for GeneratedField {
15266 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15267 where
15268 D: serde::Deserializer<'de>,
15269 {
15270 struct GeneratedVisitor;
15271
15272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15273 type Value = GeneratedField;
15274
15275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15276 write!(formatter, "expected one of: {:?}", &FIELDS)
15277 }
15278
15279 #[allow(unused_variables)]
15280 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15281 where
15282 E: serde::de::Error,
15283 {
15284 match value {
15285 "epoch" => Ok(GeneratedField::Epoch),
15286 "tables" => Ok(GeneratedField::Tables),
15287 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15288 }
15289 }
15290 }
15291 deserializer.deserialize_identifier(GeneratedVisitor)
15292 }
15293 }
15294 struct GeneratedVisitor;
15295 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15296 type Value = UncommittedEpoch;
15297
15298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15299 formatter.write_str("struct hummock.UncommittedEpoch")
15300 }
15301
15302 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UncommittedEpoch, V::Error>
15303 where
15304 V: serde::de::MapAccess<'de>,
15305 {
15306 let mut epoch__ = None;
15307 let mut tables__ = None;
15308 while let Some(k) = map_.next_key()? {
15309 match k {
15310 GeneratedField::Epoch => {
15311 if epoch__.is_some() {
15312 return Err(serde::de::Error::duplicate_field("epoch"));
15313 }
15314 epoch__ =
15315 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15316 ;
15317 }
15318 GeneratedField::Tables => {
15319 if tables__.is_some() {
15320 return Err(serde::de::Error::duplicate_field("tables"));
15321 }
15322 tables__ = Some(map_.next_value()?);
15323 }
15324 }
15325 }
15326 Ok(UncommittedEpoch {
15327 epoch: epoch__.unwrap_or_default(),
15328 tables: tables__.unwrap_or_default(),
15329 })
15330 }
15331 }
15332 deserializer.deserialize_struct("hummock.UncommittedEpoch", FIELDS, GeneratedVisitor)
15333 }
15334}
15335impl serde::Serialize for UnpinVersionBeforeRequest {
15336 #[allow(deprecated)]
15337 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15338 where
15339 S: serde::Serializer,
15340 {
15341 use serde::ser::SerializeStruct;
15342 let mut len = 0;
15343 if self.context_id != 0 {
15344 len += 1;
15345 }
15346 if self.unpin_version_before != 0 {
15347 len += 1;
15348 }
15349 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeRequest", len)?;
15350 if self.context_id != 0 {
15351 struct_ser.serialize_field("contextId", &self.context_id)?;
15352 }
15353 if self.unpin_version_before != 0 {
15354 #[allow(clippy::needless_borrow)]
15355 #[allow(clippy::needless_borrows_for_generic_args)]
15356 struct_ser.serialize_field("unpinVersionBefore", ToString::to_string(&self.unpin_version_before).as_str())?;
15357 }
15358 struct_ser.end()
15359 }
15360}
15361impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeRequest {
15362 #[allow(deprecated)]
15363 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15364 where
15365 D: serde::Deserializer<'de>,
15366 {
15367 const FIELDS: &[&str] = &[
15368 "context_id",
15369 "contextId",
15370 "unpin_version_before",
15371 "unpinVersionBefore",
15372 ];
15373
15374 #[allow(clippy::enum_variant_names)]
15375 enum GeneratedField {
15376 ContextId,
15377 UnpinVersionBefore,
15378 }
15379 impl<'de> serde::Deserialize<'de> for GeneratedField {
15380 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15381 where
15382 D: serde::Deserializer<'de>,
15383 {
15384 struct GeneratedVisitor;
15385
15386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15387 type Value = GeneratedField;
15388
15389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15390 write!(formatter, "expected one of: {:?}", &FIELDS)
15391 }
15392
15393 #[allow(unused_variables)]
15394 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15395 where
15396 E: serde::de::Error,
15397 {
15398 match value {
15399 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15400 "unpinVersionBefore" | "unpin_version_before" => Ok(GeneratedField::UnpinVersionBefore),
15401 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15402 }
15403 }
15404 }
15405 deserializer.deserialize_identifier(GeneratedVisitor)
15406 }
15407 }
15408 struct GeneratedVisitor;
15409 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15410 type Value = UnpinVersionBeforeRequest;
15411
15412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15413 formatter.write_str("struct hummock.UnpinVersionBeforeRequest")
15414 }
15415
15416 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeRequest, V::Error>
15417 where
15418 V: serde::de::MapAccess<'de>,
15419 {
15420 let mut context_id__ = None;
15421 let mut unpin_version_before__ = None;
15422 while let Some(k) = map_.next_key()? {
15423 match k {
15424 GeneratedField::ContextId => {
15425 if context_id__.is_some() {
15426 return Err(serde::de::Error::duplicate_field("contextId"));
15427 }
15428 context_id__ =
15429 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15430 ;
15431 }
15432 GeneratedField::UnpinVersionBefore => {
15433 if unpin_version_before__.is_some() {
15434 return Err(serde::de::Error::duplicate_field("unpinVersionBefore"));
15435 }
15436 unpin_version_before__ =
15437 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15438 ;
15439 }
15440 }
15441 }
15442 Ok(UnpinVersionBeforeRequest {
15443 context_id: context_id__.unwrap_or_default(),
15444 unpin_version_before: unpin_version_before__.unwrap_or_default(),
15445 })
15446 }
15447 }
15448 deserializer.deserialize_struct("hummock.UnpinVersionBeforeRequest", FIELDS, GeneratedVisitor)
15449 }
15450}
15451impl serde::Serialize for UnpinVersionBeforeResponse {
15452 #[allow(deprecated)]
15453 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15454 where
15455 S: serde::Serializer,
15456 {
15457 use serde::ser::SerializeStruct;
15458 let mut len = 0;
15459 if self.status.is_some() {
15460 len += 1;
15461 }
15462 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeResponse", len)?;
15463 if let Some(v) = self.status.as_ref() {
15464 struct_ser.serialize_field("status", v)?;
15465 }
15466 struct_ser.end()
15467 }
15468}
15469impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeResponse {
15470 #[allow(deprecated)]
15471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15472 where
15473 D: serde::Deserializer<'de>,
15474 {
15475 const FIELDS: &[&str] = &[
15476 "status",
15477 ];
15478
15479 #[allow(clippy::enum_variant_names)]
15480 enum GeneratedField {
15481 Status,
15482 }
15483 impl<'de> serde::Deserialize<'de> for GeneratedField {
15484 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15485 where
15486 D: serde::Deserializer<'de>,
15487 {
15488 struct GeneratedVisitor;
15489
15490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15491 type Value = GeneratedField;
15492
15493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15494 write!(formatter, "expected one of: {:?}", &FIELDS)
15495 }
15496
15497 #[allow(unused_variables)]
15498 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15499 where
15500 E: serde::de::Error,
15501 {
15502 match value {
15503 "status" => Ok(GeneratedField::Status),
15504 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15505 }
15506 }
15507 }
15508 deserializer.deserialize_identifier(GeneratedVisitor)
15509 }
15510 }
15511 struct GeneratedVisitor;
15512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15513 type Value = UnpinVersionBeforeResponse;
15514
15515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15516 formatter.write_str("struct hummock.UnpinVersionBeforeResponse")
15517 }
15518
15519 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeResponse, V::Error>
15520 where
15521 V: serde::de::MapAccess<'de>,
15522 {
15523 let mut status__ = None;
15524 while let Some(k) = map_.next_key()? {
15525 match k {
15526 GeneratedField::Status => {
15527 if status__.is_some() {
15528 return Err(serde::de::Error::duplicate_field("status"));
15529 }
15530 status__ = map_.next_value()?;
15531 }
15532 }
15533 }
15534 Ok(UnpinVersionBeforeResponse {
15535 status: status__,
15536 })
15537 }
15538 }
15539 deserializer.deserialize_struct("hummock.UnpinVersionBeforeResponse", FIELDS, GeneratedVisitor)
15540 }
15541}
15542impl serde::Serialize for UnpinVersionRequest {
15543 #[allow(deprecated)]
15544 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15545 where
15546 S: serde::Serializer,
15547 {
15548 use serde::ser::SerializeStruct;
15549 let mut len = 0;
15550 if self.context_id != 0 {
15551 len += 1;
15552 }
15553 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionRequest", len)?;
15554 if self.context_id != 0 {
15555 struct_ser.serialize_field("contextId", &self.context_id)?;
15556 }
15557 struct_ser.end()
15558 }
15559}
15560impl<'de> serde::Deserialize<'de> for UnpinVersionRequest {
15561 #[allow(deprecated)]
15562 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15563 where
15564 D: serde::Deserializer<'de>,
15565 {
15566 const FIELDS: &[&str] = &[
15567 "context_id",
15568 "contextId",
15569 ];
15570
15571 #[allow(clippy::enum_variant_names)]
15572 enum GeneratedField {
15573 ContextId,
15574 }
15575 impl<'de> serde::Deserialize<'de> for GeneratedField {
15576 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15577 where
15578 D: serde::Deserializer<'de>,
15579 {
15580 struct GeneratedVisitor;
15581
15582 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15583 type Value = GeneratedField;
15584
15585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15586 write!(formatter, "expected one of: {:?}", &FIELDS)
15587 }
15588
15589 #[allow(unused_variables)]
15590 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15591 where
15592 E: serde::de::Error,
15593 {
15594 match value {
15595 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15596 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15597 }
15598 }
15599 }
15600 deserializer.deserialize_identifier(GeneratedVisitor)
15601 }
15602 }
15603 struct GeneratedVisitor;
15604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15605 type Value = UnpinVersionRequest;
15606
15607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15608 formatter.write_str("struct hummock.UnpinVersionRequest")
15609 }
15610
15611 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionRequest, V::Error>
15612 where
15613 V: serde::de::MapAccess<'de>,
15614 {
15615 let mut context_id__ = None;
15616 while let Some(k) = map_.next_key()? {
15617 match k {
15618 GeneratedField::ContextId => {
15619 if context_id__.is_some() {
15620 return Err(serde::de::Error::duplicate_field("contextId"));
15621 }
15622 context_id__ =
15623 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15624 ;
15625 }
15626 }
15627 }
15628 Ok(UnpinVersionRequest {
15629 context_id: context_id__.unwrap_or_default(),
15630 })
15631 }
15632 }
15633 deserializer.deserialize_struct("hummock.UnpinVersionRequest", FIELDS, GeneratedVisitor)
15634 }
15635}
15636impl serde::Serialize for UnpinVersionResponse {
15637 #[allow(deprecated)]
15638 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15639 where
15640 S: serde::Serializer,
15641 {
15642 use serde::ser::SerializeStruct;
15643 let mut len = 0;
15644 if self.status.is_some() {
15645 len += 1;
15646 }
15647 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionResponse", len)?;
15648 if let Some(v) = self.status.as_ref() {
15649 struct_ser.serialize_field("status", v)?;
15650 }
15651 struct_ser.end()
15652 }
15653}
15654impl<'de> serde::Deserialize<'de> for UnpinVersionResponse {
15655 #[allow(deprecated)]
15656 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15657 where
15658 D: serde::Deserializer<'de>,
15659 {
15660 const FIELDS: &[&str] = &[
15661 "status",
15662 ];
15663
15664 #[allow(clippy::enum_variant_names)]
15665 enum GeneratedField {
15666 Status,
15667 }
15668 impl<'de> serde::Deserialize<'de> for GeneratedField {
15669 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15670 where
15671 D: serde::Deserializer<'de>,
15672 {
15673 struct GeneratedVisitor;
15674
15675 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15676 type Value = GeneratedField;
15677
15678 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15679 write!(formatter, "expected one of: {:?}", &FIELDS)
15680 }
15681
15682 #[allow(unused_variables)]
15683 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15684 where
15685 E: serde::de::Error,
15686 {
15687 match value {
15688 "status" => Ok(GeneratedField::Status),
15689 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15690 }
15691 }
15692 }
15693 deserializer.deserialize_identifier(GeneratedVisitor)
15694 }
15695 }
15696 struct GeneratedVisitor;
15697 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15698 type Value = UnpinVersionResponse;
15699
15700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15701 formatter.write_str("struct hummock.UnpinVersionResponse")
15702 }
15703
15704 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionResponse, V::Error>
15705 where
15706 V: serde::de::MapAccess<'de>,
15707 {
15708 let mut status__ = None;
15709 while let Some(k) = map_.next_key()? {
15710 match k {
15711 GeneratedField::Status => {
15712 if status__.is_some() {
15713 return Err(serde::de::Error::duplicate_field("status"));
15714 }
15715 status__ = map_.next_value()?;
15716 }
15717 }
15718 }
15719 Ok(UnpinVersionResponse {
15720 status: status__,
15721 })
15722 }
15723 }
15724 deserializer.deserialize_struct("hummock.UnpinVersionResponse", FIELDS, GeneratedVisitor)
15725 }
15726}
15727impl serde::Serialize for VacuumTask {
15728 #[allow(deprecated)]
15729 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15730 where
15731 S: serde::Serializer,
15732 {
15733 use serde::ser::SerializeStruct;
15734 let mut len = 0;
15735 if !self.sstable_object_ids.is_empty() {
15736 len += 1;
15737 }
15738 let mut struct_ser = serializer.serialize_struct("hummock.VacuumTask", len)?;
15739 if !self.sstable_object_ids.is_empty() {
15740 struct_ser.serialize_field("sstableObjectIds", &self.sstable_object_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
15741 }
15742 struct_ser.end()
15743 }
15744}
15745impl<'de> serde::Deserialize<'de> for VacuumTask {
15746 #[allow(deprecated)]
15747 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15748 where
15749 D: serde::Deserializer<'de>,
15750 {
15751 const FIELDS: &[&str] = &[
15752 "sstable_object_ids",
15753 "sstableObjectIds",
15754 ];
15755
15756 #[allow(clippy::enum_variant_names)]
15757 enum GeneratedField {
15758 SstableObjectIds,
15759 }
15760 impl<'de> serde::Deserialize<'de> for GeneratedField {
15761 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15762 where
15763 D: serde::Deserializer<'de>,
15764 {
15765 struct GeneratedVisitor;
15766
15767 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15768 type Value = GeneratedField;
15769
15770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15771 write!(formatter, "expected one of: {:?}", &FIELDS)
15772 }
15773
15774 #[allow(unused_variables)]
15775 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15776 where
15777 E: serde::de::Error,
15778 {
15779 match value {
15780 "sstableObjectIds" | "sstable_object_ids" => Ok(GeneratedField::SstableObjectIds),
15781 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15782 }
15783 }
15784 }
15785 deserializer.deserialize_identifier(GeneratedVisitor)
15786 }
15787 }
15788 struct GeneratedVisitor;
15789 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15790 type Value = VacuumTask;
15791
15792 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15793 formatter.write_str("struct hummock.VacuumTask")
15794 }
15795
15796 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VacuumTask, V::Error>
15797 where
15798 V: serde::de::MapAccess<'de>,
15799 {
15800 let mut sstable_object_ids__ = None;
15801 while let Some(k) = map_.next_key()? {
15802 match k {
15803 GeneratedField::SstableObjectIds => {
15804 if sstable_object_ids__.is_some() {
15805 return Err(serde::de::Error::duplicate_field("sstableObjectIds"));
15806 }
15807 sstable_object_ids__ =
15808 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15809 .into_iter().map(|x| x.0).collect())
15810 ;
15811 }
15812 }
15813 }
15814 Ok(VacuumTask {
15815 sstable_object_ids: sstable_object_ids__.unwrap_or_default(),
15816 })
15817 }
15818 }
15819 deserializer.deserialize_struct("hummock.VacuumTask", FIELDS, GeneratedVisitor)
15820 }
15821}
15822impl serde::Serialize for ValidationTask {
15823 #[allow(deprecated)]
15824 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15825 where
15826 S: serde::Serializer,
15827 {
15828 use serde::ser::SerializeStruct;
15829 let mut len = 0;
15830 if !self.sst_infos.is_empty() {
15831 len += 1;
15832 }
15833 if !self.sst_id_to_worker_id.is_empty() {
15834 len += 1;
15835 }
15836 let mut struct_ser = serializer.serialize_struct("hummock.ValidationTask", len)?;
15837 if !self.sst_infos.is_empty() {
15838 struct_ser.serialize_field("sstInfos", &self.sst_infos)?;
15839 }
15840 if !self.sst_id_to_worker_id.is_empty() {
15841 struct_ser.serialize_field("sstIdToWorkerId", &self.sst_id_to_worker_id)?;
15842 }
15843 struct_ser.end()
15844 }
15845}
15846impl<'de> serde::Deserialize<'de> for ValidationTask {
15847 #[allow(deprecated)]
15848 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15849 where
15850 D: serde::Deserializer<'de>,
15851 {
15852 const FIELDS: &[&str] = &[
15853 "sst_infos",
15854 "sstInfos",
15855 "sst_id_to_worker_id",
15856 "sstIdToWorkerId",
15857 ];
15858
15859 #[allow(clippy::enum_variant_names)]
15860 enum GeneratedField {
15861 SstInfos,
15862 SstIdToWorkerId,
15863 }
15864 impl<'de> serde::Deserialize<'de> for GeneratedField {
15865 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15866 where
15867 D: serde::Deserializer<'de>,
15868 {
15869 struct GeneratedVisitor;
15870
15871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15872 type Value = GeneratedField;
15873
15874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15875 write!(formatter, "expected one of: {:?}", &FIELDS)
15876 }
15877
15878 #[allow(unused_variables)]
15879 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15880 where
15881 E: serde::de::Error,
15882 {
15883 match value {
15884 "sstInfos" | "sst_infos" => Ok(GeneratedField::SstInfos),
15885 "sstIdToWorkerId" | "sst_id_to_worker_id" => Ok(GeneratedField::SstIdToWorkerId),
15886 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15887 }
15888 }
15889 }
15890 deserializer.deserialize_identifier(GeneratedVisitor)
15891 }
15892 }
15893 struct GeneratedVisitor;
15894 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15895 type Value = ValidationTask;
15896
15897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15898 formatter.write_str("struct hummock.ValidationTask")
15899 }
15900
15901 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationTask, V::Error>
15902 where
15903 V: serde::de::MapAccess<'de>,
15904 {
15905 let mut sst_infos__ = None;
15906 let mut sst_id_to_worker_id__ = None;
15907 while let Some(k) = map_.next_key()? {
15908 match k {
15909 GeneratedField::SstInfos => {
15910 if sst_infos__.is_some() {
15911 return Err(serde::de::Error::duplicate_field("sstInfos"));
15912 }
15913 sst_infos__ = Some(map_.next_value()?);
15914 }
15915 GeneratedField::SstIdToWorkerId => {
15916 if sst_id_to_worker_id__.is_some() {
15917 return Err(serde::de::Error::duplicate_field("sstIdToWorkerId"));
15918 }
15919 sst_id_to_worker_id__ = Some(
15920 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u32>>>()?
15921 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
15922 );
15923 }
15924 }
15925 }
15926 Ok(ValidationTask {
15927 sst_infos: sst_infos__.unwrap_or_default(),
15928 sst_id_to_worker_id: sst_id_to_worker_id__.unwrap_or_default(),
15929 })
15930 }
15931 }
15932 deserializer.deserialize_struct("hummock.ValidationTask", FIELDS, GeneratedVisitor)
15933 }
15934}
15935impl serde::Serialize for VersionUpdatePayload {
15936 #[allow(deprecated)]
15937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15938 where
15939 S: serde::Serializer,
15940 {
15941 use serde::ser::SerializeStruct;
15942 let mut len = 0;
15943 if self.payload.is_some() {
15944 len += 1;
15945 }
15946 let mut struct_ser = serializer.serialize_struct("hummock.VersionUpdatePayload", len)?;
15947 if let Some(v) = self.payload.as_ref() {
15948 match v {
15949 version_update_payload::Payload::VersionDeltas(v) => {
15950 struct_ser.serialize_field("versionDeltas", v)?;
15951 }
15952 version_update_payload::Payload::PinnedVersion(v) => {
15953 struct_ser.serialize_field("pinnedVersion", v)?;
15954 }
15955 }
15956 }
15957 struct_ser.end()
15958 }
15959}
15960impl<'de> serde::Deserialize<'de> for VersionUpdatePayload {
15961 #[allow(deprecated)]
15962 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15963 where
15964 D: serde::Deserializer<'de>,
15965 {
15966 const FIELDS: &[&str] = &[
15967 "version_deltas",
15968 "versionDeltas",
15969 "pinned_version",
15970 "pinnedVersion",
15971 ];
15972
15973 #[allow(clippy::enum_variant_names)]
15974 enum GeneratedField {
15975 VersionDeltas,
15976 PinnedVersion,
15977 }
15978 impl<'de> serde::Deserialize<'de> for GeneratedField {
15979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15980 where
15981 D: serde::Deserializer<'de>,
15982 {
15983 struct GeneratedVisitor;
15984
15985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15986 type Value = GeneratedField;
15987
15988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15989 write!(formatter, "expected one of: {:?}", &FIELDS)
15990 }
15991
15992 #[allow(unused_variables)]
15993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15994 where
15995 E: serde::de::Error,
15996 {
15997 match value {
15998 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
15999 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
16000 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16001 }
16002 }
16003 }
16004 deserializer.deserialize_identifier(GeneratedVisitor)
16005 }
16006 }
16007 struct GeneratedVisitor;
16008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16009 type Value = VersionUpdatePayload;
16010
16011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16012 formatter.write_str("struct hummock.VersionUpdatePayload")
16013 }
16014
16015 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VersionUpdatePayload, V::Error>
16016 where
16017 V: serde::de::MapAccess<'de>,
16018 {
16019 let mut payload__ = None;
16020 while let Some(k) = map_.next_key()? {
16021 match k {
16022 GeneratedField::VersionDeltas => {
16023 if payload__.is_some() {
16024 return Err(serde::de::Error::duplicate_field("versionDeltas"));
16025 }
16026 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::VersionDeltas)
16027;
16028 }
16029 GeneratedField::PinnedVersion => {
16030 if payload__.is_some() {
16031 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
16032 }
16033 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::PinnedVersion)
16034;
16035 }
16036 }
16037 }
16038 Ok(VersionUpdatePayload {
16039 payload: payload__,
16040 })
16041 }
16042 }
16043 deserializer.deserialize_struct("hummock.VersionUpdatePayload", FIELDS, GeneratedVisitor)
16044 }
16045}
16046impl serde::Serialize for VnodeWatermark {
16047 #[allow(deprecated)]
16048 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16049 where
16050 S: serde::Serializer,
16051 {
16052 use serde::ser::SerializeStruct;
16053 let mut len = 0;
16054 if !self.watermark.is_empty() {
16055 len += 1;
16056 }
16057 if self.vnode_bitmap.is_some() {
16058 len += 1;
16059 }
16060 let mut struct_ser = serializer.serialize_struct("hummock.VnodeWatermark", len)?;
16061 if !self.watermark.is_empty() {
16062 #[allow(clippy::needless_borrow)]
16063 #[allow(clippy::needless_borrows_for_generic_args)]
16064 struct_ser.serialize_field("watermark", pbjson::private::base64::encode(&self.watermark).as_str())?;
16065 }
16066 if let Some(v) = self.vnode_bitmap.as_ref() {
16067 struct_ser.serialize_field("vnodeBitmap", v)?;
16068 }
16069 struct_ser.end()
16070 }
16071}
16072impl<'de> serde::Deserialize<'de> for VnodeWatermark {
16073 #[allow(deprecated)]
16074 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16075 where
16076 D: serde::Deserializer<'de>,
16077 {
16078 const FIELDS: &[&str] = &[
16079 "watermark",
16080 "vnode_bitmap",
16081 "vnodeBitmap",
16082 ];
16083
16084 #[allow(clippy::enum_variant_names)]
16085 enum GeneratedField {
16086 Watermark,
16087 VnodeBitmap,
16088 }
16089 impl<'de> serde::Deserialize<'de> for GeneratedField {
16090 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16091 where
16092 D: serde::Deserializer<'de>,
16093 {
16094 struct GeneratedVisitor;
16095
16096 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16097 type Value = GeneratedField;
16098
16099 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16100 write!(formatter, "expected one of: {:?}", &FIELDS)
16101 }
16102
16103 #[allow(unused_variables)]
16104 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16105 where
16106 E: serde::de::Error,
16107 {
16108 match value {
16109 "watermark" => Ok(GeneratedField::Watermark),
16110 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
16111 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16112 }
16113 }
16114 }
16115 deserializer.deserialize_identifier(GeneratedVisitor)
16116 }
16117 }
16118 struct GeneratedVisitor;
16119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16120 type Value = VnodeWatermark;
16121
16122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16123 formatter.write_str("struct hummock.VnodeWatermark")
16124 }
16125
16126 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeWatermark, V::Error>
16127 where
16128 V: serde::de::MapAccess<'de>,
16129 {
16130 let mut watermark__ = None;
16131 let mut vnode_bitmap__ = None;
16132 while let Some(k) = map_.next_key()? {
16133 match k {
16134 GeneratedField::Watermark => {
16135 if watermark__.is_some() {
16136 return Err(serde::de::Error::duplicate_field("watermark"));
16137 }
16138 watermark__ =
16139 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
16140 ;
16141 }
16142 GeneratedField::VnodeBitmap => {
16143 if vnode_bitmap__.is_some() {
16144 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
16145 }
16146 vnode_bitmap__ = map_.next_value()?;
16147 }
16148 }
16149 }
16150 Ok(VnodeWatermark {
16151 watermark: watermark__.unwrap_or_default(),
16152 vnode_bitmap: vnode_bitmap__,
16153 })
16154 }
16155 }
16156 deserializer.deserialize_struct("hummock.VnodeWatermark", FIELDS, GeneratedVisitor)
16157 }
16158}
16159impl serde::Serialize for WriteLimits {
16160 #[allow(deprecated)]
16161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16162 where
16163 S: serde::Serializer,
16164 {
16165 use serde::ser::SerializeStruct;
16166 let mut len = 0;
16167 if !self.write_limits.is_empty() {
16168 len += 1;
16169 }
16170 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits", len)?;
16171 if !self.write_limits.is_empty() {
16172 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
16173 }
16174 struct_ser.end()
16175 }
16176}
16177impl<'de> serde::Deserialize<'de> for WriteLimits {
16178 #[allow(deprecated)]
16179 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16180 where
16181 D: serde::Deserializer<'de>,
16182 {
16183 const FIELDS: &[&str] = &[
16184 "write_limits",
16185 "writeLimits",
16186 ];
16187
16188 #[allow(clippy::enum_variant_names)]
16189 enum GeneratedField {
16190 WriteLimits,
16191 }
16192 impl<'de> serde::Deserialize<'de> for GeneratedField {
16193 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16194 where
16195 D: serde::Deserializer<'de>,
16196 {
16197 struct GeneratedVisitor;
16198
16199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16200 type Value = GeneratedField;
16201
16202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16203 write!(formatter, "expected one of: {:?}", &FIELDS)
16204 }
16205
16206 #[allow(unused_variables)]
16207 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16208 where
16209 E: serde::de::Error,
16210 {
16211 match value {
16212 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
16213 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16214 }
16215 }
16216 }
16217 deserializer.deserialize_identifier(GeneratedVisitor)
16218 }
16219 }
16220 struct GeneratedVisitor;
16221 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16222 type Value = WriteLimits;
16223
16224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16225 formatter.write_str("struct hummock.WriteLimits")
16226 }
16227
16228 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WriteLimits, V::Error>
16229 where
16230 V: serde::de::MapAccess<'de>,
16231 {
16232 let mut write_limits__ = None;
16233 while let Some(k) = map_.next_key()? {
16234 match k {
16235 GeneratedField::WriteLimits => {
16236 if write_limits__.is_some() {
16237 return Err(serde::de::Error::duplicate_field("writeLimits"));
16238 }
16239 write_limits__ = Some(
16240 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
16241 .into_iter().map(|(k,v)| (k.0, v)).collect()
16242 );
16243 }
16244 }
16245 }
16246 Ok(WriteLimits {
16247 write_limits: write_limits__.unwrap_or_default(),
16248 })
16249 }
16250 }
16251 deserializer.deserialize_struct("hummock.WriteLimits", FIELDS, GeneratedVisitor)
16252 }
16253}
16254impl serde::Serialize for write_limits::WriteLimit {
16255 #[allow(deprecated)]
16256 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16257 where
16258 S: serde::Serializer,
16259 {
16260 use serde::ser::SerializeStruct;
16261 let mut len = 0;
16262 if !self.table_ids.is_empty() {
16263 len += 1;
16264 }
16265 if !self.reason.is_empty() {
16266 len += 1;
16267 }
16268 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits.WriteLimit", len)?;
16269 if !self.table_ids.is_empty() {
16270 struct_ser.serialize_field("tableIds", &self.table_ids)?;
16271 }
16272 if !self.reason.is_empty() {
16273 struct_ser.serialize_field("reason", &self.reason)?;
16274 }
16275 struct_ser.end()
16276 }
16277}
16278impl<'de> serde::Deserialize<'de> for write_limits::WriteLimit {
16279 #[allow(deprecated)]
16280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16281 where
16282 D: serde::Deserializer<'de>,
16283 {
16284 const FIELDS: &[&str] = &[
16285 "table_ids",
16286 "tableIds",
16287 "reason",
16288 ];
16289
16290 #[allow(clippy::enum_variant_names)]
16291 enum GeneratedField {
16292 TableIds,
16293 Reason,
16294 }
16295 impl<'de> serde::Deserialize<'de> for GeneratedField {
16296 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16297 where
16298 D: serde::Deserializer<'de>,
16299 {
16300 struct GeneratedVisitor;
16301
16302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16303 type Value = GeneratedField;
16304
16305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16306 write!(formatter, "expected one of: {:?}", &FIELDS)
16307 }
16308
16309 #[allow(unused_variables)]
16310 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16311 where
16312 E: serde::de::Error,
16313 {
16314 match value {
16315 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
16316 "reason" => Ok(GeneratedField::Reason),
16317 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16318 }
16319 }
16320 }
16321 deserializer.deserialize_identifier(GeneratedVisitor)
16322 }
16323 }
16324 struct GeneratedVisitor;
16325 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16326 type Value = write_limits::WriteLimit;
16327
16328 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16329 formatter.write_str("struct hummock.WriteLimits.WriteLimit")
16330 }
16331
16332 fn visit_map<V>(self, mut map_: V) -> std::result::Result<write_limits::WriteLimit, V::Error>
16333 where
16334 V: serde::de::MapAccess<'de>,
16335 {
16336 let mut table_ids__ = None;
16337 let mut reason__ = None;
16338 while let Some(k) = map_.next_key()? {
16339 match k {
16340 GeneratedField::TableIds => {
16341 if table_ids__.is_some() {
16342 return Err(serde::de::Error::duplicate_field("tableIds"));
16343 }
16344 table_ids__ =
16345 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16346 .into_iter().map(|x| x.0).collect())
16347 ;
16348 }
16349 GeneratedField::Reason => {
16350 if reason__.is_some() {
16351 return Err(serde::de::Error::duplicate_field("reason"));
16352 }
16353 reason__ = Some(map_.next_value()?);
16354 }
16355 }
16356 }
16357 Ok(write_limits::WriteLimit {
16358 table_ids: table_ids__.unwrap_or_default(),
16359 reason: reason__.unwrap_or_default(),
16360 })
16361 }
16362 }
16363 deserializer.deserialize_struct("hummock.WriteLimits.WriteLimit", FIELDS, GeneratedVisitor)
16364 }
16365}