1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::hummock::*;
4impl serde::Serialize for BloomFilterType {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 let variant = match self {
11 Self::BloomFilterUnspecified => "BLOOM_FILTER_UNSPECIFIED",
12 Self::Sstable => "SSTABLE",
13 Self::Blocked => "BLOCKED",
14 };
15 serializer.serialize_str(variant)
16 }
17}
18impl<'de> serde::Deserialize<'de> for BloomFilterType {
19 #[allow(deprecated)]
20 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
21 where
22 D: serde::Deserializer<'de>,
23 {
24 const FIELDS: &[&str] = &[
25 "BLOOM_FILTER_UNSPECIFIED",
26 "SSTABLE",
27 "BLOCKED",
28 ];
29
30 struct GeneratedVisitor;
31
32 impl serde::de::Visitor<'_> for GeneratedVisitor {
33 type Value = BloomFilterType;
34
35 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
36 write!(formatter, "expected one of: {:?}", &FIELDS)
37 }
38
39 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
40 where
41 E: serde::de::Error,
42 {
43 i32::try_from(v)
44 .ok()
45 .and_then(|x| x.try_into().ok())
46 .ok_or_else(|| {
47 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
48 })
49 }
50
51 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
52 where
53 E: serde::de::Error,
54 {
55 i32::try_from(v)
56 .ok()
57 .and_then(|x| x.try_into().ok())
58 .ok_or_else(|| {
59 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
60 })
61 }
62
63 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
64 where
65 E: serde::de::Error,
66 {
67 match value {
68 "BLOOM_FILTER_UNSPECIFIED" => Ok(BloomFilterType::BloomFilterUnspecified),
69 "SSTABLE" => Ok(BloomFilterType::Sstable),
70 "BLOCKED" => Ok(BloomFilterType::Blocked),
71 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
72 }
73 }
74 }
75 deserializer.deserialize_any(GeneratedVisitor)
76 }
77}
78impl serde::Serialize for BranchedObject {
79 #[allow(deprecated)]
80 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
81 where
82 S: serde::Serializer,
83 {
84 use serde::ser::SerializeStruct;
85 let mut len = 0;
86 if self.object_id != 0 {
87 len += 1;
88 }
89 if !self.sst_id.is_empty() {
90 len += 1;
91 }
92 if self.compaction_group_id != 0 {
93 len += 1;
94 }
95 let mut struct_ser = serializer.serialize_struct("hummock.BranchedObject", len)?;
96 if self.object_id != 0 {
97 #[allow(clippy::needless_borrow)]
98 #[allow(clippy::needless_borrows_for_generic_args)]
99 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
100 }
101 if !self.sst_id.is_empty() {
102 struct_ser.serialize_field("sstId", &self.sst_id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
103 }
104 if self.compaction_group_id != 0 {
105 #[allow(clippy::needless_borrow)]
106 #[allow(clippy::needless_borrows_for_generic_args)]
107 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
108 }
109 struct_ser.end()
110 }
111}
112impl<'de> serde::Deserialize<'de> for BranchedObject {
113 #[allow(deprecated)]
114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
115 where
116 D: serde::Deserializer<'de>,
117 {
118 const FIELDS: &[&str] = &[
119 "object_id",
120 "objectId",
121 "sst_id",
122 "sstId",
123 "compaction_group_id",
124 "compactionGroupId",
125 ];
126
127 #[allow(clippy::enum_variant_names)]
128 enum GeneratedField {
129 ObjectId,
130 SstId,
131 CompactionGroupId,
132 }
133 impl<'de> serde::Deserialize<'de> for GeneratedField {
134 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
135 where
136 D: serde::Deserializer<'de>,
137 {
138 struct GeneratedVisitor;
139
140 impl serde::de::Visitor<'_> for GeneratedVisitor {
141 type Value = GeneratedField;
142
143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
144 write!(formatter, "expected one of: {:?}", &FIELDS)
145 }
146
147 #[allow(unused_variables)]
148 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
149 where
150 E: serde::de::Error,
151 {
152 match value {
153 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
154 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
155 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
156 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
157 }
158 }
159 }
160 deserializer.deserialize_identifier(GeneratedVisitor)
161 }
162 }
163 struct GeneratedVisitor;
164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
165 type Value = BranchedObject;
166
167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
168 formatter.write_str("struct hummock.BranchedObject")
169 }
170
171 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BranchedObject, V::Error>
172 where
173 V: serde::de::MapAccess<'de>,
174 {
175 let mut object_id__ = None;
176 let mut sst_id__ = None;
177 let mut compaction_group_id__ = None;
178 while let Some(k) = map_.next_key()? {
179 match k {
180 GeneratedField::ObjectId => {
181 if object_id__.is_some() {
182 return Err(serde::de::Error::duplicate_field("objectId"));
183 }
184 object_id__ =
185 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
186 ;
187 }
188 GeneratedField::SstId => {
189 if sst_id__.is_some() {
190 return Err(serde::de::Error::duplicate_field("sstId"));
191 }
192 sst_id__ =
193 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
194 .into_iter().map(|x| x.0).collect())
195 ;
196 }
197 GeneratedField::CompactionGroupId => {
198 if compaction_group_id__.is_some() {
199 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
200 }
201 compaction_group_id__ =
202 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
203 ;
204 }
205 }
206 }
207 Ok(BranchedObject {
208 object_id: object_id__.unwrap_or_default(),
209 sst_id: sst_id__.unwrap_or_default(),
210 compaction_group_id: compaction_group_id__.unwrap_or_default(),
211 })
212 }
213 }
214 deserializer.deserialize_struct("hummock.BranchedObject", FIELDS, GeneratedVisitor)
215 }
216}
217impl serde::Serialize for CancelCompactTask {
218 #[allow(deprecated)]
219 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
220 where
221 S: serde::Serializer,
222 {
223 use serde::ser::SerializeStruct;
224 let mut len = 0;
225 if self.context_id != 0 {
226 len += 1;
227 }
228 if self.task_id != 0 {
229 len += 1;
230 }
231 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTask", len)?;
232 if self.context_id != 0 {
233 struct_ser.serialize_field("contextId", &self.context_id)?;
234 }
235 if self.task_id != 0 {
236 #[allow(clippy::needless_borrow)]
237 #[allow(clippy::needless_borrows_for_generic_args)]
238 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
239 }
240 struct_ser.end()
241 }
242}
243impl<'de> serde::Deserialize<'de> for CancelCompactTask {
244 #[allow(deprecated)]
245 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
246 where
247 D: serde::Deserializer<'de>,
248 {
249 const FIELDS: &[&str] = &[
250 "context_id",
251 "contextId",
252 "task_id",
253 "taskId",
254 ];
255
256 #[allow(clippy::enum_variant_names)]
257 enum GeneratedField {
258 ContextId,
259 TaskId,
260 }
261 impl<'de> serde::Deserialize<'de> for GeneratedField {
262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
263 where
264 D: serde::Deserializer<'de>,
265 {
266 struct GeneratedVisitor;
267
268 impl serde::de::Visitor<'_> for GeneratedVisitor {
269 type Value = GeneratedField;
270
271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
272 write!(formatter, "expected one of: {:?}", &FIELDS)
273 }
274
275 #[allow(unused_variables)]
276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
277 where
278 E: serde::de::Error,
279 {
280 match value {
281 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
282 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
284 }
285 }
286 }
287 deserializer.deserialize_identifier(GeneratedVisitor)
288 }
289 }
290 struct GeneratedVisitor;
291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
292 type Value = CancelCompactTask;
293
294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
295 formatter.write_str("struct hummock.CancelCompactTask")
296 }
297
298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTask, V::Error>
299 where
300 V: serde::de::MapAccess<'de>,
301 {
302 let mut context_id__ = None;
303 let mut task_id__ = None;
304 while let Some(k) = map_.next_key()? {
305 match k {
306 GeneratedField::ContextId => {
307 if context_id__.is_some() {
308 return Err(serde::de::Error::duplicate_field("contextId"));
309 }
310 context_id__ =
311 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
312 ;
313 }
314 GeneratedField::TaskId => {
315 if task_id__.is_some() {
316 return Err(serde::de::Error::duplicate_field("taskId"));
317 }
318 task_id__ =
319 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
320 ;
321 }
322 }
323 }
324 Ok(CancelCompactTask {
325 context_id: context_id__.unwrap_or_default(),
326 task_id: task_id__.unwrap_or_default(),
327 })
328 }
329 }
330 deserializer.deserialize_struct("hummock.CancelCompactTask", FIELDS, GeneratedVisitor)
331 }
332}
333impl serde::Serialize for CancelCompactTaskRequest {
334 #[allow(deprecated)]
335 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
336 where
337 S: serde::Serializer,
338 {
339 use serde::ser::SerializeStruct;
340 let mut len = 0;
341 if self.task_id != 0 {
342 len += 1;
343 }
344 if self.task_status != 0 {
345 len += 1;
346 }
347 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskRequest", len)?;
348 if self.task_id != 0 {
349 #[allow(clippy::needless_borrow)]
350 #[allow(clippy::needless_borrows_for_generic_args)]
351 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
352 }
353 if self.task_status != 0 {
354 let v = compact_task::TaskStatus::try_from(self.task_status)
355 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
356 struct_ser.serialize_field("taskStatus", &v)?;
357 }
358 struct_ser.end()
359 }
360}
361impl<'de> serde::Deserialize<'de> for CancelCompactTaskRequest {
362 #[allow(deprecated)]
363 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
364 where
365 D: serde::Deserializer<'de>,
366 {
367 const FIELDS: &[&str] = &[
368 "task_id",
369 "taskId",
370 "task_status",
371 "taskStatus",
372 ];
373
374 #[allow(clippy::enum_variant_names)]
375 enum GeneratedField {
376 TaskId,
377 TaskStatus,
378 }
379 impl<'de> serde::Deserialize<'de> for GeneratedField {
380 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
381 where
382 D: serde::Deserializer<'de>,
383 {
384 struct GeneratedVisitor;
385
386 impl serde::de::Visitor<'_> for GeneratedVisitor {
387 type Value = GeneratedField;
388
389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
390 write!(formatter, "expected one of: {:?}", &FIELDS)
391 }
392
393 #[allow(unused_variables)]
394 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
395 where
396 E: serde::de::Error,
397 {
398 match value {
399 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
400 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
401 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
402 }
403 }
404 }
405 deserializer.deserialize_identifier(GeneratedVisitor)
406 }
407 }
408 struct GeneratedVisitor;
409 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
410 type Value = CancelCompactTaskRequest;
411
412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
413 formatter.write_str("struct hummock.CancelCompactTaskRequest")
414 }
415
416 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskRequest, V::Error>
417 where
418 V: serde::de::MapAccess<'de>,
419 {
420 let mut task_id__ = None;
421 let mut task_status__ = None;
422 while let Some(k) = map_.next_key()? {
423 match k {
424 GeneratedField::TaskId => {
425 if task_id__.is_some() {
426 return Err(serde::de::Error::duplicate_field("taskId"));
427 }
428 task_id__ =
429 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
430 ;
431 }
432 GeneratedField::TaskStatus => {
433 if task_status__.is_some() {
434 return Err(serde::de::Error::duplicate_field("taskStatus"));
435 }
436 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
437 }
438 }
439 }
440 Ok(CancelCompactTaskRequest {
441 task_id: task_id__.unwrap_or_default(),
442 task_status: task_status__.unwrap_or_default(),
443 })
444 }
445 }
446 deserializer.deserialize_struct("hummock.CancelCompactTaskRequest", FIELDS, GeneratedVisitor)
447 }
448}
449impl serde::Serialize for CancelCompactTaskResponse {
450 #[allow(deprecated)]
451 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
452 where
453 S: serde::Serializer,
454 {
455 use serde::ser::SerializeStruct;
456 let mut len = 0;
457 if self.ret {
458 len += 1;
459 }
460 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskResponse", len)?;
461 if self.ret {
462 struct_ser.serialize_field("ret", &self.ret)?;
463 }
464 struct_ser.end()
465 }
466}
467impl<'de> serde::Deserialize<'de> for CancelCompactTaskResponse {
468 #[allow(deprecated)]
469 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
470 where
471 D: serde::Deserializer<'de>,
472 {
473 const FIELDS: &[&str] = &[
474 "ret",
475 ];
476
477 #[allow(clippy::enum_variant_names)]
478 enum GeneratedField {
479 Ret,
480 }
481 impl<'de> serde::Deserialize<'de> for GeneratedField {
482 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
483 where
484 D: serde::Deserializer<'de>,
485 {
486 struct GeneratedVisitor;
487
488 impl serde::de::Visitor<'_> for GeneratedVisitor {
489 type Value = GeneratedField;
490
491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
492 write!(formatter, "expected one of: {:?}", &FIELDS)
493 }
494
495 #[allow(unused_variables)]
496 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
497 where
498 E: serde::de::Error,
499 {
500 match value {
501 "ret" => Ok(GeneratedField::Ret),
502 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
503 }
504 }
505 }
506 deserializer.deserialize_identifier(GeneratedVisitor)
507 }
508 }
509 struct GeneratedVisitor;
510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
511 type Value = CancelCompactTaskResponse;
512
513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
514 formatter.write_str("struct hummock.CancelCompactTaskResponse")
515 }
516
517 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskResponse, V::Error>
518 where
519 V: serde::de::MapAccess<'de>,
520 {
521 let mut ret__ = None;
522 while let Some(k) = map_.next_key()? {
523 match k {
524 GeneratedField::Ret => {
525 if ret__.is_some() {
526 return Err(serde::de::Error::duplicate_field("ret"));
527 }
528 ret__ = Some(map_.next_value()?);
529 }
530 }
531 }
532 Ok(CancelCompactTaskResponse {
533 ret: ret__.unwrap_or_default(),
534 })
535 }
536 }
537 deserializer.deserialize_struct("hummock.CancelCompactTaskResponse", FIELDS, GeneratedVisitor)
538 }
539}
540impl serde::Serialize for CheckpointCompressionAlgorithm {
541 #[allow(deprecated)]
542 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
543 where
544 S: serde::Serializer,
545 {
546 let variant = match self {
547 Self::CheckpointCompressionUnspecified => "CHECKPOINT_COMPRESSION_UNSPECIFIED",
548 Self::CheckpointCompressionZstd => "CHECKPOINT_COMPRESSION_ZSTD",
549 Self::CheckpointCompressionLz4 => "CHECKPOINT_COMPRESSION_LZ4",
550 };
551 serializer.serialize_str(variant)
552 }
553}
554impl<'de> serde::Deserialize<'de> for CheckpointCompressionAlgorithm {
555 #[allow(deprecated)]
556 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
557 where
558 D: serde::Deserializer<'de>,
559 {
560 const FIELDS: &[&str] = &[
561 "CHECKPOINT_COMPRESSION_UNSPECIFIED",
562 "CHECKPOINT_COMPRESSION_ZSTD",
563 "CHECKPOINT_COMPRESSION_LZ4",
564 ];
565
566 struct GeneratedVisitor;
567
568 impl serde::de::Visitor<'_> for GeneratedVisitor {
569 type Value = CheckpointCompressionAlgorithm;
570
571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
572 write!(formatter, "expected one of: {:?}", &FIELDS)
573 }
574
575 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
576 where
577 E: serde::de::Error,
578 {
579 i32::try_from(v)
580 .ok()
581 .and_then(|x| x.try_into().ok())
582 .ok_or_else(|| {
583 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
584 })
585 }
586
587 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
588 where
589 E: serde::de::Error,
590 {
591 i32::try_from(v)
592 .ok()
593 .and_then(|x| x.try_into().ok())
594 .ok_or_else(|| {
595 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
596 })
597 }
598
599 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
600 where
601 E: serde::de::Error,
602 {
603 match value {
604 "CHECKPOINT_COMPRESSION_UNSPECIFIED" => Ok(CheckpointCompressionAlgorithm::CheckpointCompressionUnspecified),
605 "CHECKPOINT_COMPRESSION_ZSTD" => Ok(CheckpointCompressionAlgorithm::CheckpointCompressionZstd),
606 "CHECKPOINT_COMPRESSION_LZ4" => Ok(CheckpointCompressionAlgorithm::CheckpointCompressionLz4),
607 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
608 }
609 }
610 }
611 deserializer.deserialize_any(GeneratedVisitor)
612 }
613}
614impl serde::Serialize for CompactStatus {
615 #[allow(deprecated)]
616 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
617 where
618 S: serde::Serializer,
619 {
620 use serde::ser::SerializeStruct;
621 let mut len = 0;
622 if self.compaction_group_id != 0 {
623 len += 1;
624 }
625 if !self.level_handlers.is_empty() {
626 len += 1;
627 }
628 let mut struct_ser = serializer.serialize_struct("hummock.CompactStatus", len)?;
629 if self.compaction_group_id != 0 {
630 #[allow(clippy::needless_borrow)]
631 #[allow(clippy::needless_borrows_for_generic_args)]
632 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
633 }
634 if !self.level_handlers.is_empty() {
635 struct_ser.serialize_field("levelHandlers", &self.level_handlers)?;
636 }
637 struct_ser.end()
638 }
639}
640impl<'de> serde::Deserialize<'de> for CompactStatus {
641 #[allow(deprecated)]
642 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
643 where
644 D: serde::Deserializer<'de>,
645 {
646 const FIELDS: &[&str] = &[
647 "compaction_group_id",
648 "compactionGroupId",
649 "level_handlers",
650 "levelHandlers",
651 ];
652
653 #[allow(clippy::enum_variant_names)]
654 enum GeneratedField {
655 CompactionGroupId,
656 LevelHandlers,
657 }
658 impl<'de> serde::Deserialize<'de> for GeneratedField {
659 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
660 where
661 D: serde::Deserializer<'de>,
662 {
663 struct GeneratedVisitor;
664
665 impl serde::de::Visitor<'_> for GeneratedVisitor {
666 type Value = GeneratedField;
667
668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
669 write!(formatter, "expected one of: {:?}", &FIELDS)
670 }
671
672 #[allow(unused_variables)]
673 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
674 where
675 E: serde::de::Error,
676 {
677 match value {
678 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
679 "levelHandlers" | "level_handlers" => Ok(GeneratedField::LevelHandlers),
680 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
681 }
682 }
683 }
684 deserializer.deserialize_identifier(GeneratedVisitor)
685 }
686 }
687 struct GeneratedVisitor;
688 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
689 type Value = CompactStatus;
690
691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
692 formatter.write_str("struct hummock.CompactStatus")
693 }
694
695 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactStatus, V::Error>
696 where
697 V: serde::de::MapAccess<'de>,
698 {
699 let mut compaction_group_id__ = None;
700 let mut level_handlers__ = None;
701 while let Some(k) = map_.next_key()? {
702 match k {
703 GeneratedField::CompactionGroupId => {
704 if compaction_group_id__.is_some() {
705 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
706 }
707 compaction_group_id__ =
708 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
709 ;
710 }
711 GeneratedField::LevelHandlers => {
712 if level_handlers__.is_some() {
713 return Err(serde::de::Error::duplicate_field("levelHandlers"));
714 }
715 level_handlers__ = Some(map_.next_value()?);
716 }
717 }
718 }
719 Ok(CompactStatus {
720 compaction_group_id: compaction_group_id__.unwrap_or_default(),
721 level_handlers: level_handlers__.unwrap_or_default(),
722 })
723 }
724 }
725 deserializer.deserialize_struct("hummock.CompactStatus", FIELDS, GeneratedVisitor)
726 }
727}
728impl serde::Serialize for CompactTask {
729 #[allow(deprecated)]
730 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
731 where
732 S: serde::Serializer,
733 {
734 use serde::ser::SerializeStruct;
735 let mut len = 0;
736 if !self.input_ssts.is_empty() {
737 len += 1;
738 }
739 if !self.splits.is_empty() {
740 len += 1;
741 }
742 if !self.sorted_output_ssts.is_empty() {
743 len += 1;
744 }
745 if self.task_id != 0 {
746 len += 1;
747 }
748 if self.target_level != 0 {
749 len += 1;
750 }
751 if self.gc_delete_keys {
752 len += 1;
753 }
754 if self.base_level != 0 {
755 len += 1;
756 }
757 if self.task_status != 0 {
758 len += 1;
759 }
760 if self.compaction_group_id != 0 {
761 len += 1;
762 }
763 if !self.existing_table_ids.is_empty() {
764 len += 1;
765 }
766 if self.compression_algorithm != 0 {
767 len += 1;
768 }
769 if self.target_file_size != 0 {
770 len += 1;
771 }
772 if self.compaction_filter_mask != 0 {
773 len += 1;
774 }
775 if !self.table_options.is_empty() {
776 len += 1;
777 }
778 if self.current_epoch_time != 0 {
779 len += 1;
780 }
781 if self.target_sub_level_id != 0 {
782 len += 1;
783 }
784 if self.task_type != 0 {
785 len += 1;
786 }
787 if self.split_by_state_table {
788 len += 1;
789 }
790 if self.split_weight_by_vnode != 0 {
791 len += 1;
792 }
793 if !self.table_vnode_partition.is_empty() {
794 len += 1;
795 }
796 if !self.table_watermarks.is_empty() {
797 len += 1;
798 }
799 if !self.table_schemas.is_empty() {
800 len += 1;
801 }
802 if self.max_sub_compaction != 0 {
803 len += 1;
804 }
805 if self.compaction_group_version_id != 0 {
806 len += 1;
807 }
808 if self.max_kv_count_for_xor16.is_some() {
809 len += 1;
810 }
811 if self.max_vnode_key_range_bytes.is_some() {
812 len += 1;
813 }
814 if self.sstable_filter_type != 0 {
815 len += 1;
816 }
817 if self.sstable_filter_layout != 0 {
818 len += 1;
819 }
820 let mut struct_ser = serializer.serialize_struct("hummock.CompactTask", len)?;
821 if !self.input_ssts.is_empty() {
822 struct_ser.serialize_field("inputSsts", &self.input_ssts)?;
823 }
824 if !self.splits.is_empty() {
825 struct_ser.serialize_field("splits", &self.splits)?;
826 }
827 if !self.sorted_output_ssts.is_empty() {
828 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
829 }
830 if self.task_id != 0 {
831 #[allow(clippy::needless_borrow)]
832 #[allow(clippy::needless_borrows_for_generic_args)]
833 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
834 }
835 if self.target_level != 0 {
836 struct_ser.serialize_field("targetLevel", &self.target_level)?;
837 }
838 if self.gc_delete_keys {
839 struct_ser.serialize_field("gcDeleteKeys", &self.gc_delete_keys)?;
840 }
841 if self.base_level != 0 {
842 struct_ser.serialize_field("baseLevel", &self.base_level)?;
843 }
844 if self.task_status != 0 {
845 let v = compact_task::TaskStatus::try_from(self.task_status)
846 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
847 struct_ser.serialize_field("taskStatus", &v)?;
848 }
849 if self.compaction_group_id != 0 {
850 #[allow(clippy::needless_borrow)]
851 #[allow(clippy::needless_borrows_for_generic_args)]
852 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
853 }
854 if !self.existing_table_ids.is_empty() {
855 struct_ser.serialize_field("existingTableIds", &self.existing_table_ids)?;
856 }
857 if self.compression_algorithm != 0 {
858 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
859 }
860 if self.target_file_size != 0 {
861 #[allow(clippy::needless_borrow)]
862 #[allow(clippy::needless_borrows_for_generic_args)]
863 struct_ser.serialize_field("targetFileSize", ToString::to_string(&self.target_file_size).as_str())?;
864 }
865 if self.compaction_filter_mask != 0 {
866 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
867 }
868 if !self.table_options.is_empty() {
869 struct_ser.serialize_field("tableOptions", &self.table_options)?;
870 }
871 if self.current_epoch_time != 0 {
872 #[allow(clippy::needless_borrow)]
873 #[allow(clippy::needless_borrows_for_generic_args)]
874 struct_ser.serialize_field("currentEpochTime", ToString::to_string(&self.current_epoch_time).as_str())?;
875 }
876 if self.target_sub_level_id != 0 {
877 #[allow(clippy::needless_borrow)]
878 #[allow(clippy::needless_borrows_for_generic_args)]
879 struct_ser.serialize_field("targetSubLevelId", ToString::to_string(&self.target_sub_level_id).as_str())?;
880 }
881 if self.task_type != 0 {
882 let v = compact_task::TaskType::try_from(self.task_type)
883 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_type)))?;
884 struct_ser.serialize_field("taskType", &v)?;
885 }
886 if self.split_by_state_table {
887 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
888 }
889 if self.split_weight_by_vnode != 0 {
890 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
891 }
892 if !self.table_vnode_partition.is_empty() {
893 struct_ser.serialize_field("tableVnodePartition", &self.table_vnode_partition)?;
894 }
895 if !self.table_watermarks.is_empty() {
896 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
897 }
898 if !self.table_schemas.is_empty() {
899 struct_ser.serialize_field("tableSchemas", &self.table_schemas)?;
900 }
901 if self.max_sub_compaction != 0 {
902 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
903 }
904 if self.compaction_group_version_id != 0 {
905 #[allow(clippy::needless_borrow)]
906 #[allow(clippy::needless_borrows_for_generic_args)]
907 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
908 }
909 if let Some(v) = self.max_kv_count_for_xor16.as_ref() {
910 #[allow(clippy::needless_borrow)]
911 #[allow(clippy::needless_borrows_for_generic_args)]
912 struct_ser.serialize_field("maxKvCountForXor16", ToString::to_string(&v).as_str())?;
913 }
914 if let Some(v) = self.max_vnode_key_range_bytes.as_ref() {
915 #[allow(clippy::needless_borrow)]
916 #[allow(clippy::needless_borrows_for_generic_args)]
917 struct_ser.serialize_field("maxVnodeKeyRangeBytes", ToString::to_string(&v).as_str())?;
918 }
919 if self.sstable_filter_type != 0 {
920 let v = SstableFilterType::try_from(self.sstable_filter_type)
921 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sstable_filter_type)))?;
922 struct_ser.serialize_field("sstableFilterType", &v)?;
923 }
924 if self.sstable_filter_layout != 0 {
925 let v = SstableFilterLayout::try_from(self.sstable_filter_layout)
926 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sstable_filter_layout)))?;
927 struct_ser.serialize_field("sstableFilterLayout", &v)?;
928 }
929 struct_ser.end()
930 }
931}
932impl<'de> serde::Deserialize<'de> for CompactTask {
933 #[allow(deprecated)]
934 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
935 where
936 D: serde::Deserializer<'de>,
937 {
938 const FIELDS: &[&str] = &[
939 "input_ssts",
940 "inputSsts",
941 "splits",
942 "sorted_output_ssts",
943 "sortedOutputSsts",
944 "task_id",
945 "taskId",
946 "target_level",
947 "targetLevel",
948 "gc_delete_keys",
949 "gcDeleteKeys",
950 "base_level",
951 "baseLevel",
952 "task_status",
953 "taskStatus",
954 "compaction_group_id",
955 "compactionGroupId",
956 "existing_table_ids",
957 "existingTableIds",
958 "compression_algorithm",
959 "compressionAlgorithm",
960 "target_file_size",
961 "targetFileSize",
962 "compaction_filter_mask",
963 "compactionFilterMask",
964 "table_options",
965 "tableOptions",
966 "current_epoch_time",
967 "currentEpochTime",
968 "target_sub_level_id",
969 "targetSubLevelId",
970 "task_type",
971 "taskType",
972 "split_by_state_table",
973 "splitByStateTable",
974 "split_weight_by_vnode",
975 "splitWeightByVnode",
976 "table_vnode_partition",
977 "tableVnodePartition",
978 "table_watermarks",
979 "tableWatermarks",
980 "table_schemas",
981 "tableSchemas",
982 "max_sub_compaction",
983 "maxSubCompaction",
984 "compaction_group_version_id",
985 "compactionGroupVersionId",
986 "max_kv_count_for_xor16",
987 "maxKvCountForXor16",
988 "max_vnode_key_range_bytes",
989 "maxVnodeKeyRangeBytes",
990 "sstable_filter_type",
991 "sstableFilterType",
992 "sstable_filter_layout",
993 "sstableFilterLayout",
994 ];
995
996 #[allow(clippy::enum_variant_names)]
997 enum GeneratedField {
998 InputSsts,
999 Splits,
1000 SortedOutputSsts,
1001 TaskId,
1002 TargetLevel,
1003 GcDeleteKeys,
1004 BaseLevel,
1005 TaskStatus,
1006 CompactionGroupId,
1007 ExistingTableIds,
1008 CompressionAlgorithm,
1009 TargetFileSize,
1010 CompactionFilterMask,
1011 TableOptions,
1012 CurrentEpochTime,
1013 TargetSubLevelId,
1014 TaskType,
1015 SplitByStateTable,
1016 SplitWeightByVnode,
1017 TableVnodePartition,
1018 TableWatermarks,
1019 TableSchemas,
1020 MaxSubCompaction,
1021 CompactionGroupVersionId,
1022 MaxKvCountForXor16,
1023 MaxVnodeKeyRangeBytes,
1024 SstableFilterType,
1025 SstableFilterLayout,
1026 }
1027 impl<'de> serde::Deserialize<'de> for GeneratedField {
1028 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1029 where
1030 D: serde::Deserializer<'de>,
1031 {
1032 struct GeneratedVisitor;
1033
1034 impl serde::de::Visitor<'_> for GeneratedVisitor {
1035 type Value = GeneratedField;
1036
1037 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1038 write!(formatter, "expected one of: {:?}", &FIELDS)
1039 }
1040
1041 #[allow(unused_variables)]
1042 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1043 where
1044 E: serde::de::Error,
1045 {
1046 match value {
1047 "inputSsts" | "input_ssts" => Ok(GeneratedField::InputSsts),
1048 "splits" => Ok(GeneratedField::Splits),
1049 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
1050 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1051 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
1052 "gcDeleteKeys" | "gc_delete_keys" => Ok(GeneratedField::GcDeleteKeys),
1053 "baseLevel" | "base_level" => Ok(GeneratedField::BaseLevel),
1054 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
1055 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
1056 "existingTableIds" | "existing_table_ids" => Ok(GeneratedField::ExistingTableIds),
1057 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
1058 "targetFileSize" | "target_file_size" => Ok(GeneratedField::TargetFileSize),
1059 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
1060 "tableOptions" | "table_options" => Ok(GeneratedField::TableOptions),
1061 "currentEpochTime" | "current_epoch_time" => Ok(GeneratedField::CurrentEpochTime),
1062 "targetSubLevelId" | "target_sub_level_id" => Ok(GeneratedField::TargetSubLevelId),
1063 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
1064 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
1065 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
1066 "tableVnodePartition" | "table_vnode_partition" => Ok(GeneratedField::TableVnodePartition),
1067 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
1068 "tableSchemas" | "table_schemas" => Ok(GeneratedField::TableSchemas),
1069 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
1070 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
1071 "maxKvCountForXor16" | "max_kv_count_for_xor16" => Ok(GeneratedField::MaxKvCountForXor16),
1072 "maxVnodeKeyRangeBytes" | "max_vnode_key_range_bytes" => Ok(GeneratedField::MaxVnodeKeyRangeBytes),
1073 "sstableFilterType" | "sstable_filter_type" => Ok(GeneratedField::SstableFilterType),
1074 "sstableFilterLayout" | "sstable_filter_layout" => Ok(GeneratedField::SstableFilterLayout),
1075 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1076 }
1077 }
1078 }
1079 deserializer.deserialize_identifier(GeneratedVisitor)
1080 }
1081 }
1082 struct GeneratedVisitor;
1083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1084 type Value = CompactTask;
1085
1086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1087 formatter.write_str("struct hummock.CompactTask")
1088 }
1089
1090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTask, V::Error>
1091 where
1092 V: serde::de::MapAccess<'de>,
1093 {
1094 let mut input_ssts__ = None;
1095 let mut splits__ = None;
1096 let mut sorted_output_ssts__ = None;
1097 let mut task_id__ = None;
1098 let mut target_level__ = None;
1099 let mut gc_delete_keys__ = None;
1100 let mut base_level__ = None;
1101 let mut task_status__ = None;
1102 let mut compaction_group_id__ = None;
1103 let mut existing_table_ids__ = None;
1104 let mut compression_algorithm__ = None;
1105 let mut target_file_size__ = None;
1106 let mut compaction_filter_mask__ = None;
1107 let mut table_options__ = None;
1108 let mut current_epoch_time__ = None;
1109 let mut target_sub_level_id__ = None;
1110 let mut task_type__ = None;
1111 let mut split_by_state_table__ = None;
1112 let mut split_weight_by_vnode__ = None;
1113 let mut table_vnode_partition__ = None;
1114 let mut table_watermarks__ = None;
1115 let mut table_schemas__ = None;
1116 let mut max_sub_compaction__ = None;
1117 let mut compaction_group_version_id__ = None;
1118 let mut max_kv_count_for_xor16__ = None;
1119 let mut max_vnode_key_range_bytes__ = None;
1120 let mut sstable_filter_type__ = None;
1121 let mut sstable_filter_layout__ = None;
1122 while let Some(k) = map_.next_key()? {
1123 match k {
1124 GeneratedField::InputSsts => {
1125 if input_ssts__.is_some() {
1126 return Err(serde::de::Error::duplicate_field("inputSsts"));
1127 }
1128 input_ssts__ = Some(map_.next_value()?);
1129 }
1130 GeneratedField::Splits => {
1131 if splits__.is_some() {
1132 return Err(serde::de::Error::duplicate_field("splits"));
1133 }
1134 splits__ = Some(map_.next_value()?);
1135 }
1136 GeneratedField::SortedOutputSsts => {
1137 if sorted_output_ssts__.is_some() {
1138 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
1139 }
1140 sorted_output_ssts__ = Some(map_.next_value()?);
1141 }
1142 GeneratedField::TaskId => {
1143 if task_id__.is_some() {
1144 return Err(serde::de::Error::duplicate_field("taskId"));
1145 }
1146 task_id__ =
1147 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1148 ;
1149 }
1150 GeneratedField::TargetLevel => {
1151 if target_level__.is_some() {
1152 return Err(serde::de::Error::duplicate_field("targetLevel"));
1153 }
1154 target_level__ =
1155 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1156 ;
1157 }
1158 GeneratedField::GcDeleteKeys => {
1159 if gc_delete_keys__.is_some() {
1160 return Err(serde::de::Error::duplicate_field("gcDeleteKeys"));
1161 }
1162 gc_delete_keys__ = Some(map_.next_value()?);
1163 }
1164 GeneratedField::BaseLevel => {
1165 if base_level__.is_some() {
1166 return Err(serde::de::Error::duplicate_field("baseLevel"));
1167 }
1168 base_level__ =
1169 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1170 ;
1171 }
1172 GeneratedField::TaskStatus => {
1173 if task_status__.is_some() {
1174 return Err(serde::de::Error::duplicate_field("taskStatus"));
1175 }
1176 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
1177 }
1178 GeneratedField::CompactionGroupId => {
1179 if compaction_group_id__.is_some() {
1180 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1181 }
1182 compaction_group_id__ =
1183 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1184 ;
1185 }
1186 GeneratedField::ExistingTableIds => {
1187 if existing_table_ids__.is_some() {
1188 return Err(serde::de::Error::duplicate_field("existingTableIds"));
1189 }
1190 existing_table_ids__ =
1191 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1192 .into_iter().map(|x| x.0).collect())
1193 ;
1194 }
1195 GeneratedField::CompressionAlgorithm => {
1196 if compression_algorithm__.is_some() {
1197 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
1198 }
1199 compression_algorithm__ =
1200 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1201 ;
1202 }
1203 GeneratedField::TargetFileSize => {
1204 if target_file_size__.is_some() {
1205 return Err(serde::de::Error::duplicate_field("targetFileSize"));
1206 }
1207 target_file_size__ =
1208 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1209 ;
1210 }
1211 GeneratedField::CompactionFilterMask => {
1212 if compaction_filter_mask__.is_some() {
1213 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
1214 }
1215 compaction_filter_mask__ =
1216 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1217 ;
1218 }
1219 GeneratedField::TableOptions => {
1220 if table_options__.is_some() {
1221 return Err(serde::de::Error::duplicate_field("tableOptions"));
1222 }
1223 table_options__ = Some(
1224 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1225 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1226 );
1227 }
1228 GeneratedField::CurrentEpochTime => {
1229 if current_epoch_time__.is_some() {
1230 return Err(serde::de::Error::duplicate_field("currentEpochTime"));
1231 }
1232 current_epoch_time__ =
1233 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1234 ;
1235 }
1236 GeneratedField::TargetSubLevelId => {
1237 if target_sub_level_id__.is_some() {
1238 return Err(serde::de::Error::duplicate_field("targetSubLevelId"));
1239 }
1240 target_sub_level_id__ =
1241 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1242 ;
1243 }
1244 GeneratedField::TaskType => {
1245 if task_type__.is_some() {
1246 return Err(serde::de::Error::duplicate_field("taskType"));
1247 }
1248 task_type__ = Some(map_.next_value::<compact_task::TaskType>()? as i32);
1249 }
1250 GeneratedField::SplitByStateTable => {
1251 if split_by_state_table__.is_some() {
1252 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
1253 }
1254 split_by_state_table__ = Some(map_.next_value()?);
1255 }
1256 GeneratedField::SplitWeightByVnode => {
1257 if split_weight_by_vnode__.is_some() {
1258 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
1259 }
1260 split_weight_by_vnode__ =
1261 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1262 ;
1263 }
1264 GeneratedField::TableVnodePartition => {
1265 if table_vnode_partition__.is_some() {
1266 return Err(serde::de::Error::duplicate_field("tableVnodePartition"));
1267 }
1268 table_vnode_partition__ = Some(
1269 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
1270 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
1271 );
1272 }
1273 GeneratedField::TableWatermarks => {
1274 if table_watermarks__.is_some() {
1275 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
1276 }
1277 table_watermarks__ = Some(
1278 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1279 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1280 );
1281 }
1282 GeneratedField::TableSchemas => {
1283 if table_schemas__.is_some() {
1284 return Err(serde::de::Error::duplicate_field("tableSchemas"));
1285 }
1286 table_schemas__ = Some(
1287 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1288 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1289 );
1290 }
1291 GeneratedField::MaxSubCompaction => {
1292 if max_sub_compaction__.is_some() {
1293 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
1294 }
1295 max_sub_compaction__ =
1296 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1297 ;
1298 }
1299 GeneratedField::CompactionGroupVersionId => {
1300 if compaction_group_version_id__.is_some() {
1301 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
1302 }
1303 compaction_group_version_id__ =
1304 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1305 ;
1306 }
1307 GeneratedField::MaxKvCountForXor16 => {
1308 if max_kv_count_for_xor16__.is_some() {
1309 return Err(serde::de::Error::duplicate_field("maxKvCountForXor16"));
1310 }
1311 max_kv_count_for_xor16__ =
1312 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1313 ;
1314 }
1315 GeneratedField::MaxVnodeKeyRangeBytes => {
1316 if max_vnode_key_range_bytes__.is_some() {
1317 return Err(serde::de::Error::duplicate_field("maxVnodeKeyRangeBytes"));
1318 }
1319 max_vnode_key_range_bytes__ =
1320 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1321 ;
1322 }
1323 GeneratedField::SstableFilterType => {
1324 if sstable_filter_type__.is_some() {
1325 return Err(serde::de::Error::duplicate_field("sstableFilterType"));
1326 }
1327 sstable_filter_type__ = Some(map_.next_value::<SstableFilterType>()? as i32);
1328 }
1329 GeneratedField::SstableFilterLayout => {
1330 if sstable_filter_layout__.is_some() {
1331 return Err(serde::de::Error::duplicate_field("sstableFilterLayout"));
1332 }
1333 sstable_filter_layout__ = Some(map_.next_value::<SstableFilterLayout>()? as i32);
1334 }
1335 }
1336 }
1337 Ok(CompactTask {
1338 input_ssts: input_ssts__.unwrap_or_default(),
1339 splits: splits__.unwrap_or_default(),
1340 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
1341 task_id: task_id__.unwrap_or_default(),
1342 target_level: target_level__.unwrap_or_default(),
1343 gc_delete_keys: gc_delete_keys__.unwrap_or_default(),
1344 base_level: base_level__.unwrap_or_default(),
1345 task_status: task_status__.unwrap_or_default(),
1346 compaction_group_id: compaction_group_id__.unwrap_or_default(),
1347 existing_table_ids: existing_table_ids__.unwrap_or_default(),
1348 compression_algorithm: compression_algorithm__.unwrap_or_default(),
1349 target_file_size: target_file_size__.unwrap_or_default(),
1350 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
1351 table_options: table_options__.unwrap_or_default(),
1352 current_epoch_time: current_epoch_time__.unwrap_or_default(),
1353 target_sub_level_id: target_sub_level_id__.unwrap_or_default(),
1354 task_type: task_type__.unwrap_or_default(),
1355 split_by_state_table: split_by_state_table__.unwrap_or_default(),
1356 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
1357 table_vnode_partition: table_vnode_partition__.unwrap_or_default(),
1358 table_watermarks: table_watermarks__.unwrap_or_default(),
1359 table_schemas: table_schemas__.unwrap_or_default(),
1360 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
1361 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
1362 max_kv_count_for_xor16: max_kv_count_for_xor16__,
1363 max_vnode_key_range_bytes: max_vnode_key_range_bytes__,
1364 sstable_filter_type: sstable_filter_type__.unwrap_or_default(),
1365 sstable_filter_layout: sstable_filter_layout__.unwrap_or_default(),
1366 })
1367 }
1368 }
1369 deserializer.deserialize_struct("hummock.CompactTask", FIELDS, GeneratedVisitor)
1370 }
1371}
1372impl serde::Serialize for compact_task::TaskStatus {
1373 #[allow(deprecated)]
1374 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1375 where
1376 S: serde::Serializer,
1377 {
1378 let variant = match self {
1379 Self::Unspecified => "UNSPECIFIED",
1380 Self::Pending => "PENDING",
1381 Self::Success => "SUCCESS",
1382 Self::HeartbeatCanceled => "HEARTBEAT_CANCELED",
1383 Self::NoAvailMemoryResourceCanceled => "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1384 Self::AssignFailCanceled => "ASSIGN_FAIL_CANCELED",
1385 Self::SendFailCanceled => "SEND_FAIL_CANCELED",
1386 Self::ManualCanceled => "MANUAL_CANCELED",
1387 Self::InvalidGroupCanceled => "INVALID_GROUP_CANCELED",
1388 Self::InputOutdatedCanceled => "INPUT_OUTDATED_CANCELED",
1389 Self::ExecuteFailed => "EXECUTE_FAILED",
1390 Self::JoinHandleFailed => "JOIN_HANDLE_FAILED",
1391 Self::TrackSstObjectIdFailed => "TRACK_SST_OBJECT_ID_FAILED",
1392 Self::NoAvailCpuResourceCanceled => "NO_AVAIL_CPU_RESOURCE_CANCELED",
1393 Self::HeartbeatProgressCanceled => "HEARTBEAT_PROGRESS_CANCELED",
1394 Self::RetentionTimeRejected => "RETENTION_TIME_REJECTED",
1395 Self::ServerlessSendFailCanceled => "SERVERLESS_SEND_FAIL_CANCELED",
1396 Self::ServerlessTableNotFoundCanceled => "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1397 };
1398 serializer.serialize_str(variant)
1399 }
1400}
1401impl<'de> serde::Deserialize<'de> for compact_task::TaskStatus {
1402 #[allow(deprecated)]
1403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1404 where
1405 D: serde::Deserializer<'de>,
1406 {
1407 const FIELDS: &[&str] = &[
1408 "UNSPECIFIED",
1409 "PENDING",
1410 "SUCCESS",
1411 "HEARTBEAT_CANCELED",
1412 "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1413 "ASSIGN_FAIL_CANCELED",
1414 "SEND_FAIL_CANCELED",
1415 "MANUAL_CANCELED",
1416 "INVALID_GROUP_CANCELED",
1417 "INPUT_OUTDATED_CANCELED",
1418 "EXECUTE_FAILED",
1419 "JOIN_HANDLE_FAILED",
1420 "TRACK_SST_OBJECT_ID_FAILED",
1421 "NO_AVAIL_CPU_RESOURCE_CANCELED",
1422 "HEARTBEAT_PROGRESS_CANCELED",
1423 "RETENTION_TIME_REJECTED",
1424 "SERVERLESS_SEND_FAIL_CANCELED",
1425 "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1426 ];
1427
1428 struct GeneratedVisitor;
1429
1430 impl serde::de::Visitor<'_> for GeneratedVisitor {
1431 type Value = compact_task::TaskStatus;
1432
1433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1434 write!(formatter, "expected one of: {:?}", &FIELDS)
1435 }
1436
1437 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1438 where
1439 E: serde::de::Error,
1440 {
1441 i32::try_from(v)
1442 .ok()
1443 .and_then(|x| x.try_into().ok())
1444 .ok_or_else(|| {
1445 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1446 })
1447 }
1448
1449 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1450 where
1451 E: serde::de::Error,
1452 {
1453 i32::try_from(v)
1454 .ok()
1455 .and_then(|x| x.try_into().ok())
1456 .ok_or_else(|| {
1457 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1458 })
1459 }
1460
1461 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1462 where
1463 E: serde::de::Error,
1464 {
1465 match value {
1466 "UNSPECIFIED" => Ok(compact_task::TaskStatus::Unspecified),
1467 "PENDING" => Ok(compact_task::TaskStatus::Pending),
1468 "SUCCESS" => Ok(compact_task::TaskStatus::Success),
1469 "HEARTBEAT_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatCanceled),
1470 "NO_AVAIL_MEMORY_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailMemoryResourceCanceled),
1471 "ASSIGN_FAIL_CANCELED" => Ok(compact_task::TaskStatus::AssignFailCanceled),
1472 "SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::SendFailCanceled),
1473 "MANUAL_CANCELED" => Ok(compact_task::TaskStatus::ManualCanceled),
1474 "INVALID_GROUP_CANCELED" => Ok(compact_task::TaskStatus::InvalidGroupCanceled),
1475 "INPUT_OUTDATED_CANCELED" => Ok(compact_task::TaskStatus::InputOutdatedCanceled),
1476 "EXECUTE_FAILED" => Ok(compact_task::TaskStatus::ExecuteFailed),
1477 "JOIN_HANDLE_FAILED" => Ok(compact_task::TaskStatus::JoinHandleFailed),
1478 "TRACK_SST_OBJECT_ID_FAILED" => Ok(compact_task::TaskStatus::TrackSstObjectIdFailed),
1479 "NO_AVAIL_CPU_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailCpuResourceCanceled),
1480 "HEARTBEAT_PROGRESS_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatProgressCanceled),
1481 "RETENTION_TIME_REJECTED" => Ok(compact_task::TaskStatus::RetentionTimeRejected),
1482 "SERVERLESS_SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::ServerlessSendFailCanceled),
1483 "SERVERLESS_TABLE_NOT_FOUND_CANCELED" => Ok(compact_task::TaskStatus::ServerlessTableNotFoundCanceled),
1484 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1485 }
1486 }
1487 }
1488 deserializer.deserialize_any(GeneratedVisitor)
1489 }
1490}
1491impl serde::Serialize for compact_task::TaskType {
1492 #[allow(deprecated)]
1493 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1494 where
1495 S: serde::Serializer,
1496 {
1497 let variant = match self {
1498 Self::TypeUnspecified => "TYPE_UNSPECIFIED",
1499 Self::Dynamic => "DYNAMIC",
1500 Self::SpaceReclaim => "SPACE_RECLAIM",
1501 Self::Manual => "MANUAL",
1502 Self::SharedBuffer => "SHARED_BUFFER",
1503 Self::Ttl => "TTL",
1504 Self::Tombstone => "TOMBSTONE",
1505 Self::Emergency => "EMERGENCY",
1506 Self::VnodeWatermark => "VNODE_WATERMARK",
1507 };
1508 serializer.serialize_str(variant)
1509 }
1510}
1511impl<'de> serde::Deserialize<'de> for compact_task::TaskType {
1512 #[allow(deprecated)]
1513 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1514 where
1515 D: serde::Deserializer<'de>,
1516 {
1517 const FIELDS: &[&str] = &[
1518 "TYPE_UNSPECIFIED",
1519 "DYNAMIC",
1520 "SPACE_RECLAIM",
1521 "MANUAL",
1522 "SHARED_BUFFER",
1523 "TTL",
1524 "TOMBSTONE",
1525 "EMERGENCY",
1526 "VNODE_WATERMARK",
1527 ];
1528
1529 struct GeneratedVisitor;
1530
1531 impl serde::de::Visitor<'_> for GeneratedVisitor {
1532 type Value = compact_task::TaskType;
1533
1534 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1535 write!(formatter, "expected one of: {:?}", &FIELDS)
1536 }
1537
1538 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1539 where
1540 E: serde::de::Error,
1541 {
1542 i32::try_from(v)
1543 .ok()
1544 .and_then(|x| x.try_into().ok())
1545 .ok_or_else(|| {
1546 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1547 })
1548 }
1549
1550 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1551 where
1552 E: serde::de::Error,
1553 {
1554 i32::try_from(v)
1555 .ok()
1556 .and_then(|x| x.try_into().ok())
1557 .ok_or_else(|| {
1558 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1559 })
1560 }
1561
1562 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1563 where
1564 E: serde::de::Error,
1565 {
1566 match value {
1567 "TYPE_UNSPECIFIED" => Ok(compact_task::TaskType::TypeUnspecified),
1568 "DYNAMIC" => Ok(compact_task::TaskType::Dynamic),
1569 "SPACE_RECLAIM" => Ok(compact_task::TaskType::SpaceReclaim),
1570 "MANUAL" => Ok(compact_task::TaskType::Manual),
1571 "SHARED_BUFFER" => Ok(compact_task::TaskType::SharedBuffer),
1572 "TTL" => Ok(compact_task::TaskType::Ttl),
1573 "TOMBSTONE" => Ok(compact_task::TaskType::Tombstone),
1574 "EMERGENCY" => Ok(compact_task::TaskType::Emergency),
1575 "VNODE_WATERMARK" => Ok(compact_task::TaskType::VnodeWatermark),
1576 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1577 }
1578 }
1579 }
1580 deserializer.deserialize_any(GeneratedVisitor)
1581 }
1582}
1583impl serde::Serialize for CompactTaskAssignment {
1584 #[allow(deprecated)]
1585 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1586 where
1587 S: serde::Serializer,
1588 {
1589 use serde::ser::SerializeStruct;
1590 let mut len = 0;
1591 if self.compact_task.is_some() {
1592 len += 1;
1593 }
1594 if self.context_id != 0 {
1595 len += 1;
1596 }
1597 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskAssignment", len)?;
1598 if let Some(v) = self.compact_task.as_ref() {
1599 struct_ser.serialize_field("compactTask", v)?;
1600 }
1601 if self.context_id != 0 {
1602 struct_ser.serialize_field("contextId", &self.context_id)?;
1603 }
1604 struct_ser.end()
1605 }
1606}
1607impl<'de> serde::Deserialize<'de> for CompactTaskAssignment {
1608 #[allow(deprecated)]
1609 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1610 where
1611 D: serde::Deserializer<'de>,
1612 {
1613 const FIELDS: &[&str] = &[
1614 "compact_task",
1615 "compactTask",
1616 "context_id",
1617 "contextId",
1618 ];
1619
1620 #[allow(clippy::enum_variant_names)]
1621 enum GeneratedField {
1622 CompactTask,
1623 ContextId,
1624 }
1625 impl<'de> serde::Deserialize<'de> for GeneratedField {
1626 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1627 where
1628 D: serde::Deserializer<'de>,
1629 {
1630 struct GeneratedVisitor;
1631
1632 impl serde::de::Visitor<'_> for GeneratedVisitor {
1633 type Value = GeneratedField;
1634
1635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1636 write!(formatter, "expected one of: {:?}", &FIELDS)
1637 }
1638
1639 #[allow(unused_variables)]
1640 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1641 where
1642 E: serde::de::Error,
1643 {
1644 match value {
1645 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
1646 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
1647 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1648 }
1649 }
1650 }
1651 deserializer.deserialize_identifier(GeneratedVisitor)
1652 }
1653 }
1654 struct GeneratedVisitor;
1655 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1656 type Value = CompactTaskAssignment;
1657
1658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1659 formatter.write_str("struct hummock.CompactTaskAssignment")
1660 }
1661
1662 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskAssignment, V::Error>
1663 where
1664 V: serde::de::MapAccess<'de>,
1665 {
1666 let mut compact_task__ = None;
1667 let mut context_id__ = None;
1668 while let Some(k) = map_.next_key()? {
1669 match k {
1670 GeneratedField::CompactTask => {
1671 if compact_task__.is_some() {
1672 return Err(serde::de::Error::duplicate_field("compactTask"));
1673 }
1674 compact_task__ = map_.next_value()?;
1675 }
1676 GeneratedField::ContextId => {
1677 if context_id__.is_some() {
1678 return Err(serde::de::Error::duplicate_field("contextId"));
1679 }
1680 context_id__ =
1681 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1682 ;
1683 }
1684 }
1685 }
1686 Ok(CompactTaskAssignment {
1687 compact_task: compact_task__,
1688 context_id: context_id__.unwrap_or_default(),
1689 })
1690 }
1691 }
1692 deserializer.deserialize_struct("hummock.CompactTaskAssignment", FIELDS, GeneratedVisitor)
1693 }
1694}
1695impl serde::Serialize for CompactTaskProgress {
1696 #[allow(deprecated)]
1697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1698 where
1699 S: serde::Serializer,
1700 {
1701 use serde::ser::SerializeStruct;
1702 let mut len = 0;
1703 if self.task_id != 0 {
1704 len += 1;
1705 }
1706 if self.num_ssts_sealed != 0 {
1707 len += 1;
1708 }
1709 if self.num_ssts_uploaded != 0 {
1710 len += 1;
1711 }
1712 if self.num_progress_key != 0 {
1713 len += 1;
1714 }
1715 if self.num_pending_read_io != 0 {
1716 len += 1;
1717 }
1718 if self.num_pending_write_io != 0 {
1719 len += 1;
1720 }
1721 if self.compaction_group_id.is_some() {
1722 len += 1;
1723 }
1724 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskProgress", len)?;
1725 if self.task_id != 0 {
1726 #[allow(clippy::needless_borrow)]
1727 #[allow(clippy::needless_borrows_for_generic_args)]
1728 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
1729 }
1730 if self.num_ssts_sealed != 0 {
1731 struct_ser.serialize_field("numSstsSealed", &self.num_ssts_sealed)?;
1732 }
1733 if self.num_ssts_uploaded != 0 {
1734 struct_ser.serialize_field("numSstsUploaded", &self.num_ssts_uploaded)?;
1735 }
1736 if self.num_progress_key != 0 {
1737 #[allow(clippy::needless_borrow)]
1738 #[allow(clippy::needless_borrows_for_generic_args)]
1739 struct_ser.serialize_field("numProgressKey", ToString::to_string(&self.num_progress_key).as_str())?;
1740 }
1741 if self.num_pending_read_io != 0 {
1742 #[allow(clippy::needless_borrow)]
1743 #[allow(clippy::needless_borrows_for_generic_args)]
1744 struct_ser.serialize_field("numPendingReadIo", ToString::to_string(&self.num_pending_read_io).as_str())?;
1745 }
1746 if self.num_pending_write_io != 0 {
1747 #[allow(clippy::needless_borrow)]
1748 #[allow(clippy::needless_borrows_for_generic_args)]
1749 struct_ser.serialize_field("numPendingWriteIo", ToString::to_string(&self.num_pending_write_io).as_str())?;
1750 }
1751 if let Some(v) = self.compaction_group_id.as_ref() {
1752 #[allow(clippy::needless_borrow)]
1753 #[allow(clippy::needless_borrows_for_generic_args)]
1754 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&v).as_str())?;
1755 }
1756 struct_ser.end()
1757 }
1758}
1759impl<'de> serde::Deserialize<'de> for CompactTaskProgress {
1760 #[allow(deprecated)]
1761 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1762 where
1763 D: serde::Deserializer<'de>,
1764 {
1765 const FIELDS: &[&str] = &[
1766 "task_id",
1767 "taskId",
1768 "num_ssts_sealed",
1769 "numSstsSealed",
1770 "num_ssts_uploaded",
1771 "numSstsUploaded",
1772 "num_progress_key",
1773 "numProgressKey",
1774 "num_pending_read_io",
1775 "numPendingReadIo",
1776 "num_pending_write_io",
1777 "numPendingWriteIo",
1778 "compaction_group_id",
1779 "compactionGroupId",
1780 ];
1781
1782 #[allow(clippy::enum_variant_names)]
1783 enum GeneratedField {
1784 TaskId,
1785 NumSstsSealed,
1786 NumSstsUploaded,
1787 NumProgressKey,
1788 NumPendingReadIo,
1789 NumPendingWriteIo,
1790 CompactionGroupId,
1791 }
1792 impl<'de> serde::Deserialize<'de> for GeneratedField {
1793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1794 where
1795 D: serde::Deserializer<'de>,
1796 {
1797 struct GeneratedVisitor;
1798
1799 impl serde::de::Visitor<'_> for GeneratedVisitor {
1800 type Value = GeneratedField;
1801
1802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1803 write!(formatter, "expected one of: {:?}", &FIELDS)
1804 }
1805
1806 #[allow(unused_variables)]
1807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1808 where
1809 E: serde::de::Error,
1810 {
1811 match value {
1812 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1813 "numSstsSealed" | "num_ssts_sealed" => Ok(GeneratedField::NumSstsSealed),
1814 "numSstsUploaded" | "num_ssts_uploaded" => Ok(GeneratedField::NumSstsUploaded),
1815 "numProgressKey" | "num_progress_key" => Ok(GeneratedField::NumProgressKey),
1816 "numPendingReadIo" | "num_pending_read_io" => Ok(GeneratedField::NumPendingReadIo),
1817 "numPendingWriteIo" | "num_pending_write_io" => Ok(GeneratedField::NumPendingWriteIo),
1818 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
1819 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1820 }
1821 }
1822 }
1823 deserializer.deserialize_identifier(GeneratedVisitor)
1824 }
1825 }
1826 struct GeneratedVisitor;
1827 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1828 type Value = CompactTaskProgress;
1829
1830 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1831 formatter.write_str("struct hummock.CompactTaskProgress")
1832 }
1833
1834 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskProgress, V::Error>
1835 where
1836 V: serde::de::MapAccess<'de>,
1837 {
1838 let mut task_id__ = None;
1839 let mut num_ssts_sealed__ = None;
1840 let mut num_ssts_uploaded__ = None;
1841 let mut num_progress_key__ = None;
1842 let mut num_pending_read_io__ = None;
1843 let mut num_pending_write_io__ = None;
1844 let mut compaction_group_id__ = None;
1845 while let Some(k) = map_.next_key()? {
1846 match k {
1847 GeneratedField::TaskId => {
1848 if task_id__.is_some() {
1849 return Err(serde::de::Error::duplicate_field("taskId"));
1850 }
1851 task_id__ =
1852 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1853 ;
1854 }
1855 GeneratedField::NumSstsSealed => {
1856 if num_ssts_sealed__.is_some() {
1857 return Err(serde::de::Error::duplicate_field("numSstsSealed"));
1858 }
1859 num_ssts_sealed__ =
1860 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1861 ;
1862 }
1863 GeneratedField::NumSstsUploaded => {
1864 if num_ssts_uploaded__.is_some() {
1865 return Err(serde::de::Error::duplicate_field("numSstsUploaded"));
1866 }
1867 num_ssts_uploaded__ =
1868 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1869 ;
1870 }
1871 GeneratedField::NumProgressKey => {
1872 if num_progress_key__.is_some() {
1873 return Err(serde::de::Error::duplicate_field("numProgressKey"));
1874 }
1875 num_progress_key__ =
1876 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1877 ;
1878 }
1879 GeneratedField::NumPendingReadIo => {
1880 if num_pending_read_io__.is_some() {
1881 return Err(serde::de::Error::duplicate_field("numPendingReadIo"));
1882 }
1883 num_pending_read_io__ =
1884 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1885 ;
1886 }
1887 GeneratedField::NumPendingWriteIo => {
1888 if num_pending_write_io__.is_some() {
1889 return Err(serde::de::Error::duplicate_field("numPendingWriteIo"));
1890 }
1891 num_pending_write_io__ =
1892 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1893 ;
1894 }
1895 GeneratedField::CompactionGroupId => {
1896 if compaction_group_id__.is_some() {
1897 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1898 }
1899 compaction_group_id__ =
1900 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1901 ;
1902 }
1903 }
1904 }
1905 Ok(CompactTaskProgress {
1906 task_id: task_id__.unwrap_or_default(),
1907 num_ssts_sealed: num_ssts_sealed__.unwrap_or_default(),
1908 num_ssts_uploaded: num_ssts_uploaded__.unwrap_or_default(),
1909 num_progress_key: num_progress_key__.unwrap_or_default(),
1910 num_pending_read_io: num_pending_read_io__.unwrap_or_default(),
1911 num_pending_write_io: num_pending_write_io__.unwrap_or_default(),
1912 compaction_group_id: compaction_group_id__,
1913 })
1914 }
1915 }
1916 deserializer.deserialize_struct("hummock.CompactTaskProgress", FIELDS, GeneratedVisitor)
1917 }
1918}
1919impl serde::Serialize for CompactionConfig {
1920 #[allow(deprecated)]
1921 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1922 where
1923 S: serde::Serializer,
1924 {
1925 use serde::ser::SerializeStruct;
1926 let mut len = 0;
1927 if self.max_bytes_for_level_base != 0 {
1928 len += 1;
1929 }
1930 if self.max_level != 0 {
1931 len += 1;
1932 }
1933 if self.max_bytes_for_level_multiplier != 0 {
1934 len += 1;
1935 }
1936 if self.max_compaction_bytes != 0 {
1937 len += 1;
1938 }
1939 if self.sub_level_max_compaction_bytes != 0 {
1940 len += 1;
1941 }
1942 if self.level0_tier_compact_file_number != 0 {
1943 len += 1;
1944 }
1945 if self.compaction_mode != 0 {
1946 len += 1;
1947 }
1948 if !self.compression_algorithm.is_empty() {
1949 len += 1;
1950 }
1951 if self.target_file_size_base != 0 {
1952 len += 1;
1953 }
1954 if self.compaction_filter_mask != 0 {
1955 len += 1;
1956 }
1957 if self.max_sub_compaction != 0 {
1958 len += 1;
1959 }
1960 if self.max_space_reclaim_bytes != 0 {
1961 len += 1;
1962 }
1963 if self.split_by_state_table {
1964 len += 1;
1965 }
1966 if self.split_weight_by_vnode != 0 {
1967 len += 1;
1968 }
1969 if self.level0_stop_write_threshold_sub_level_number != 0 {
1970 len += 1;
1971 }
1972 if self.level0_max_compact_file_number != 0 {
1973 len += 1;
1974 }
1975 if self.level0_sub_level_compact_level_count != 0 {
1976 len += 1;
1977 }
1978 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1979 len += 1;
1980 }
1981 if self.tombstone_reclaim_ratio != 0 {
1982 len += 1;
1983 }
1984 if self.enable_emergency_picker {
1985 len += 1;
1986 }
1987 if self.max_l0_compact_level_count.is_some() {
1988 len += 1;
1989 }
1990 if self.sst_allowed_trivial_move_min_size.is_some() {
1991 len += 1;
1992 }
1993 if self.disable_auto_group_scheduling.is_some() {
1994 len += 1;
1995 }
1996 if self.max_overlapping_level_size.is_some() {
1997 len += 1;
1998 }
1999 if self.emergency_level0_sst_file_count.is_some() {
2000 len += 1;
2001 }
2002 if self.emergency_level0_sub_level_partition.is_some() {
2003 len += 1;
2004 }
2005 if self.level0_stop_write_threshold_max_sst_count.is_some() {
2006 len += 1;
2007 }
2008 if self.level0_stop_write_threshold_max_size.is_some() {
2009 len += 1;
2010 }
2011 if self.sst_allowed_trivial_move_max_count.is_some() {
2012 len += 1;
2013 }
2014 if self.enable_optimize_l0_interval_selection.is_some() {
2015 len += 1;
2016 }
2017 if self.vnode_aligned_level_size_threshold.is_some() {
2018 len += 1;
2019 }
2020 if self.max_kv_count_for_xor16.is_some() {
2021 len += 1;
2022 }
2023 if self.max_vnode_key_range_bytes.is_some() {
2024 len += 1;
2025 }
2026 if !self.sstable_filter_type.is_empty() {
2027 len += 1;
2028 }
2029 if !self.sstable_filter_layout.is_empty() {
2030 len += 1;
2031 }
2032 let mut struct_ser = serializer.serialize_struct("hummock.CompactionConfig", len)?;
2033 if self.max_bytes_for_level_base != 0 {
2034 #[allow(clippy::needless_borrow)]
2035 #[allow(clippy::needless_borrows_for_generic_args)]
2036 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&self.max_bytes_for_level_base).as_str())?;
2037 }
2038 if self.max_level != 0 {
2039 #[allow(clippy::needless_borrow)]
2040 #[allow(clippy::needless_borrows_for_generic_args)]
2041 struct_ser.serialize_field("maxLevel", ToString::to_string(&self.max_level).as_str())?;
2042 }
2043 if self.max_bytes_for_level_multiplier != 0 {
2044 #[allow(clippy::needless_borrow)]
2045 #[allow(clippy::needless_borrows_for_generic_args)]
2046 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&self.max_bytes_for_level_multiplier).as_str())?;
2047 }
2048 if self.max_compaction_bytes != 0 {
2049 #[allow(clippy::needless_borrow)]
2050 #[allow(clippy::needless_borrows_for_generic_args)]
2051 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&self.max_compaction_bytes).as_str())?;
2052 }
2053 if self.sub_level_max_compaction_bytes != 0 {
2054 #[allow(clippy::needless_borrow)]
2055 #[allow(clippy::needless_borrows_for_generic_args)]
2056 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&self.sub_level_max_compaction_bytes).as_str())?;
2057 }
2058 if self.level0_tier_compact_file_number != 0 {
2059 #[allow(clippy::needless_borrow)]
2060 #[allow(clippy::needless_borrows_for_generic_args)]
2061 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&self.level0_tier_compact_file_number).as_str())?;
2062 }
2063 if self.compaction_mode != 0 {
2064 let v = compaction_config::CompactionMode::try_from(self.compaction_mode)
2065 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compaction_mode)))?;
2066 struct_ser.serialize_field("compactionMode", &v)?;
2067 }
2068 if !self.compression_algorithm.is_empty() {
2069 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
2070 }
2071 if self.target_file_size_base != 0 {
2072 #[allow(clippy::needless_borrow)]
2073 #[allow(clippy::needless_borrows_for_generic_args)]
2074 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&self.target_file_size_base).as_str())?;
2075 }
2076 if self.compaction_filter_mask != 0 {
2077 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
2078 }
2079 if self.max_sub_compaction != 0 {
2080 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
2081 }
2082 if self.max_space_reclaim_bytes != 0 {
2083 #[allow(clippy::needless_borrow)]
2084 #[allow(clippy::needless_borrows_for_generic_args)]
2085 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&self.max_space_reclaim_bytes).as_str())?;
2086 }
2087 if self.split_by_state_table {
2088 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
2089 }
2090 if self.split_weight_by_vnode != 0 {
2091 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
2092 }
2093 if self.level0_stop_write_threshold_sub_level_number != 0 {
2094 #[allow(clippy::needless_borrow)]
2095 #[allow(clippy::needless_borrows_for_generic_args)]
2096 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&self.level0_stop_write_threshold_sub_level_number).as_str())?;
2097 }
2098 if self.level0_max_compact_file_number != 0 {
2099 #[allow(clippy::needless_borrow)]
2100 #[allow(clippy::needless_borrows_for_generic_args)]
2101 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&self.level0_max_compact_file_number).as_str())?;
2102 }
2103 if self.level0_sub_level_compact_level_count != 0 {
2104 struct_ser.serialize_field("level0SubLevelCompactLevelCount", &self.level0_sub_level_compact_level_count)?;
2105 }
2106 if self.level0_overlapping_sub_level_compact_level_count != 0 {
2107 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", &self.level0_overlapping_sub_level_compact_level_count)?;
2108 }
2109 if self.tombstone_reclaim_ratio != 0 {
2110 struct_ser.serialize_field("tombstoneReclaimRatio", &self.tombstone_reclaim_ratio)?;
2111 }
2112 if self.enable_emergency_picker {
2113 struct_ser.serialize_field("enableEmergencyPicker", &self.enable_emergency_picker)?;
2114 }
2115 if let Some(v) = self.max_l0_compact_level_count.as_ref() {
2116 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
2117 }
2118 if let Some(v) = self.sst_allowed_trivial_move_min_size.as_ref() {
2119 #[allow(clippy::needless_borrow)]
2120 #[allow(clippy::needless_borrows_for_generic_args)]
2121 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
2122 }
2123 if let Some(v) = self.disable_auto_group_scheduling.as_ref() {
2124 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
2125 }
2126 if let Some(v) = self.max_overlapping_level_size.as_ref() {
2127 #[allow(clippy::needless_borrow)]
2128 #[allow(clippy::needless_borrows_for_generic_args)]
2129 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
2130 }
2131 if let Some(v) = self.emergency_level0_sst_file_count.as_ref() {
2132 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
2133 }
2134 if let Some(v) = self.emergency_level0_sub_level_partition.as_ref() {
2135 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
2136 }
2137 if let Some(v) = self.level0_stop_write_threshold_max_sst_count.as_ref() {
2138 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
2139 }
2140 if let Some(v) = self.level0_stop_write_threshold_max_size.as_ref() {
2141 #[allow(clippy::needless_borrow)]
2142 #[allow(clippy::needless_borrows_for_generic_args)]
2143 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
2144 }
2145 if let Some(v) = self.sst_allowed_trivial_move_max_count.as_ref() {
2146 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
2147 }
2148 if let Some(v) = self.enable_optimize_l0_interval_selection.as_ref() {
2149 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
2150 }
2151 if let Some(v) = self.vnode_aligned_level_size_threshold.as_ref() {
2152 #[allow(clippy::needless_borrow)]
2153 #[allow(clippy::needless_borrows_for_generic_args)]
2154 struct_ser.serialize_field("vnodeAlignedLevelSizeThreshold", ToString::to_string(&v).as_str())?;
2155 }
2156 if let Some(v) = self.max_kv_count_for_xor16.as_ref() {
2157 #[allow(clippy::needless_borrow)]
2158 #[allow(clippy::needless_borrows_for_generic_args)]
2159 struct_ser.serialize_field("maxKvCountForXor16", ToString::to_string(&v).as_str())?;
2160 }
2161 if let Some(v) = self.max_vnode_key_range_bytes.as_ref() {
2162 #[allow(clippy::needless_borrow)]
2163 #[allow(clippy::needless_borrows_for_generic_args)]
2164 struct_ser.serialize_field("maxVnodeKeyRangeBytes", ToString::to_string(&v).as_str())?;
2165 }
2166 if !self.sstable_filter_type.is_empty() {
2167 struct_ser.serialize_field("sstableFilterType", &self.sstable_filter_type)?;
2168 }
2169 if !self.sstable_filter_layout.is_empty() {
2170 struct_ser.serialize_field("sstableFilterLayout", &self.sstable_filter_layout)?;
2171 }
2172 struct_ser.end()
2173 }
2174}
2175impl<'de> serde::Deserialize<'de> for CompactionConfig {
2176 #[allow(deprecated)]
2177 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2178 where
2179 D: serde::Deserializer<'de>,
2180 {
2181 const FIELDS: &[&str] = &[
2182 "max_bytes_for_level_base",
2183 "maxBytesForLevelBase",
2184 "max_level",
2185 "maxLevel",
2186 "max_bytes_for_level_multiplier",
2187 "maxBytesForLevelMultiplier",
2188 "max_compaction_bytes",
2189 "maxCompactionBytes",
2190 "sub_level_max_compaction_bytes",
2191 "subLevelMaxCompactionBytes",
2192 "level0_tier_compact_file_number",
2193 "level0TierCompactFileNumber",
2194 "compaction_mode",
2195 "compactionMode",
2196 "compression_algorithm",
2197 "compressionAlgorithm",
2198 "target_file_size_base",
2199 "targetFileSizeBase",
2200 "compaction_filter_mask",
2201 "compactionFilterMask",
2202 "max_sub_compaction",
2203 "maxSubCompaction",
2204 "max_space_reclaim_bytes",
2205 "maxSpaceReclaimBytes",
2206 "split_by_state_table",
2207 "splitByStateTable",
2208 "split_weight_by_vnode",
2209 "splitWeightByVnode",
2210 "level0_stop_write_threshold_sub_level_number",
2211 "level0StopWriteThresholdSubLevelNumber",
2212 "level0_max_compact_file_number",
2213 "level0MaxCompactFileNumber",
2214 "level0_sub_level_compact_level_count",
2215 "level0SubLevelCompactLevelCount",
2216 "level0_overlapping_sub_level_compact_level_count",
2217 "level0OverlappingSubLevelCompactLevelCount",
2218 "tombstone_reclaim_ratio",
2219 "tombstoneReclaimRatio",
2220 "enable_emergency_picker",
2221 "enableEmergencyPicker",
2222 "max_l0_compact_level_count",
2223 "maxL0CompactLevelCount",
2224 "sst_allowed_trivial_move_min_size",
2225 "sstAllowedTrivialMoveMinSize",
2226 "disable_auto_group_scheduling",
2227 "disableAutoGroupScheduling",
2228 "max_overlapping_level_size",
2229 "maxOverlappingLevelSize",
2230 "emergency_level0_sst_file_count",
2231 "emergencyLevel0SstFileCount",
2232 "emergency_level0_sub_level_partition",
2233 "emergencyLevel0SubLevelPartition",
2234 "level0_stop_write_threshold_max_sst_count",
2235 "level0StopWriteThresholdMaxSstCount",
2236 "level0_stop_write_threshold_max_size",
2237 "level0StopWriteThresholdMaxSize",
2238 "sst_allowed_trivial_move_max_count",
2239 "sstAllowedTrivialMoveMaxCount",
2240 "enable_optimize_l0_interval_selection",
2241 "enableOptimizeL0IntervalSelection",
2242 "vnode_aligned_level_size_threshold",
2243 "vnodeAlignedLevelSizeThreshold",
2244 "max_kv_count_for_xor16",
2245 "maxKvCountForXor16",
2246 "max_vnode_key_range_bytes",
2247 "maxVnodeKeyRangeBytes",
2248 "sstable_filter_type",
2249 "sstableFilterType",
2250 "sstable_filter_layout",
2251 "sstableFilterLayout",
2252 ];
2253
2254 #[allow(clippy::enum_variant_names)]
2255 enum GeneratedField {
2256 MaxBytesForLevelBase,
2257 MaxLevel,
2258 MaxBytesForLevelMultiplier,
2259 MaxCompactionBytes,
2260 SubLevelMaxCompactionBytes,
2261 Level0TierCompactFileNumber,
2262 CompactionMode,
2263 CompressionAlgorithm,
2264 TargetFileSizeBase,
2265 CompactionFilterMask,
2266 MaxSubCompaction,
2267 MaxSpaceReclaimBytes,
2268 SplitByStateTable,
2269 SplitWeightByVnode,
2270 Level0StopWriteThresholdSubLevelNumber,
2271 Level0MaxCompactFileNumber,
2272 Level0SubLevelCompactLevelCount,
2273 Level0OverlappingSubLevelCompactLevelCount,
2274 TombstoneReclaimRatio,
2275 EnableEmergencyPicker,
2276 MaxL0CompactLevelCount,
2277 SstAllowedTrivialMoveMinSize,
2278 DisableAutoGroupScheduling,
2279 MaxOverlappingLevelSize,
2280 EmergencyLevel0SstFileCount,
2281 EmergencyLevel0SubLevelPartition,
2282 Level0StopWriteThresholdMaxSstCount,
2283 Level0StopWriteThresholdMaxSize,
2284 SstAllowedTrivialMoveMaxCount,
2285 EnableOptimizeL0IntervalSelection,
2286 VnodeAlignedLevelSizeThreshold,
2287 MaxKvCountForXor16,
2288 MaxVnodeKeyRangeBytes,
2289 SstableFilterType,
2290 SstableFilterLayout,
2291 }
2292 impl<'de> serde::Deserialize<'de> for GeneratedField {
2293 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2294 where
2295 D: serde::Deserializer<'de>,
2296 {
2297 struct GeneratedVisitor;
2298
2299 impl serde::de::Visitor<'_> for GeneratedVisitor {
2300 type Value = GeneratedField;
2301
2302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2303 write!(formatter, "expected one of: {:?}", &FIELDS)
2304 }
2305
2306 #[allow(unused_variables)]
2307 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2308 where
2309 E: serde::de::Error,
2310 {
2311 match value {
2312 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
2313 "maxLevel" | "max_level" => Ok(GeneratedField::MaxLevel),
2314 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
2315 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
2316 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
2317 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
2318 "compactionMode" | "compaction_mode" => Ok(GeneratedField::CompactionMode),
2319 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
2320 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
2321 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
2322 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
2323 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
2324 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
2325 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
2326 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
2327 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
2328 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
2329 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
2330 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
2331 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
2332 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
2333 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
2334 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
2335 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
2336 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
2337 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
2338 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
2339 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
2340 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
2341 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
2342 "vnodeAlignedLevelSizeThreshold" | "vnode_aligned_level_size_threshold" => Ok(GeneratedField::VnodeAlignedLevelSizeThreshold),
2343 "maxKvCountForXor16" | "max_kv_count_for_xor16" => Ok(GeneratedField::MaxKvCountForXor16),
2344 "maxVnodeKeyRangeBytes" | "max_vnode_key_range_bytes" => Ok(GeneratedField::MaxVnodeKeyRangeBytes),
2345 "sstableFilterType" | "sstable_filter_type" => Ok(GeneratedField::SstableFilterType),
2346 "sstableFilterLayout" | "sstable_filter_layout" => Ok(GeneratedField::SstableFilterLayout),
2347 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2348 }
2349 }
2350 }
2351 deserializer.deserialize_identifier(GeneratedVisitor)
2352 }
2353 }
2354 struct GeneratedVisitor;
2355 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2356 type Value = CompactionConfig;
2357
2358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2359 formatter.write_str("struct hummock.CompactionConfig")
2360 }
2361
2362 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionConfig, V::Error>
2363 where
2364 V: serde::de::MapAccess<'de>,
2365 {
2366 let mut max_bytes_for_level_base__ = None;
2367 let mut max_level__ = None;
2368 let mut max_bytes_for_level_multiplier__ = None;
2369 let mut max_compaction_bytes__ = None;
2370 let mut sub_level_max_compaction_bytes__ = None;
2371 let mut level0_tier_compact_file_number__ = None;
2372 let mut compaction_mode__ = None;
2373 let mut compression_algorithm__ = None;
2374 let mut target_file_size_base__ = None;
2375 let mut compaction_filter_mask__ = None;
2376 let mut max_sub_compaction__ = None;
2377 let mut max_space_reclaim_bytes__ = None;
2378 let mut split_by_state_table__ = None;
2379 let mut split_weight_by_vnode__ = None;
2380 let mut level0_stop_write_threshold_sub_level_number__ = None;
2381 let mut level0_max_compact_file_number__ = None;
2382 let mut level0_sub_level_compact_level_count__ = None;
2383 let mut level0_overlapping_sub_level_compact_level_count__ = None;
2384 let mut tombstone_reclaim_ratio__ = None;
2385 let mut enable_emergency_picker__ = None;
2386 let mut max_l0_compact_level_count__ = None;
2387 let mut sst_allowed_trivial_move_min_size__ = None;
2388 let mut disable_auto_group_scheduling__ = None;
2389 let mut max_overlapping_level_size__ = None;
2390 let mut emergency_level0_sst_file_count__ = None;
2391 let mut emergency_level0_sub_level_partition__ = None;
2392 let mut level0_stop_write_threshold_max_sst_count__ = None;
2393 let mut level0_stop_write_threshold_max_size__ = None;
2394 let mut sst_allowed_trivial_move_max_count__ = None;
2395 let mut enable_optimize_l0_interval_selection__ = None;
2396 let mut vnode_aligned_level_size_threshold__ = None;
2397 let mut max_kv_count_for_xor16__ = None;
2398 let mut max_vnode_key_range_bytes__ = None;
2399 let mut sstable_filter_type__ = None;
2400 let mut sstable_filter_layout__ = None;
2401 while let Some(k) = map_.next_key()? {
2402 match k {
2403 GeneratedField::MaxBytesForLevelBase => {
2404 if max_bytes_for_level_base__.is_some() {
2405 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
2406 }
2407 max_bytes_for_level_base__ =
2408 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2409 ;
2410 }
2411 GeneratedField::MaxLevel => {
2412 if max_level__.is_some() {
2413 return Err(serde::de::Error::duplicate_field("maxLevel"));
2414 }
2415 max_level__ =
2416 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2417 ;
2418 }
2419 GeneratedField::MaxBytesForLevelMultiplier => {
2420 if max_bytes_for_level_multiplier__.is_some() {
2421 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
2422 }
2423 max_bytes_for_level_multiplier__ =
2424 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2425 ;
2426 }
2427 GeneratedField::MaxCompactionBytes => {
2428 if max_compaction_bytes__.is_some() {
2429 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
2430 }
2431 max_compaction_bytes__ =
2432 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2433 ;
2434 }
2435 GeneratedField::SubLevelMaxCompactionBytes => {
2436 if sub_level_max_compaction_bytes__.is_some() {
2437 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
2438 }
2439 sub_level_max_compaction_bytes__ =
2440 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2441 ;
2442 }
2443 GeneratedField::Level0TierCompactFileNumber => {
2444 if level0_tier_compact_file_number__.is_some() {
2445 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
2446 }
2447 level0_tier_compact_file_number__ =
2448 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2449 ;
2450 }
2451 GeneratedField::CompactionMode => {
2452 if compaction_mode__.is_some() {
2453 return Err(serde::de::Error::duplicate_field("compactionMode"));
2454 }
2455 compaction_mode__ = Some(map_.next_value::<compaction_config::CompactionMode>()? as i32);
2456 }
2457 GeneratedField::CompressionAlgorithm => {
2458 if compression_algorithm__.is_some() {
2459 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
2460 }
2461 compression_algorithm__ = Some(map_.next_value()?);
2462 }
2463 GeneratedField::TargetFileSizeBase => {
2464 if target_file_size_base__.is_some() {
2465 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
2466 }
2467 target_file_size_base__ =
2468 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2469 ;
2470 }
2471 GeneratedField::CompactionFilterMask => {
2472 if compaction_filter_mask__.is_some() {
2473 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
2474 }
2475 compaction_filter_mask__ =
2476 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2477 ;
2478 }
2479 GeneratedField::MaxSubCompaction => {
2480 if max_sub_compaction__.is_some() {
2481 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
2482 }
2483 max_sub_compaction__ =
2484 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2485 ;
2486 }
2487 GeneratedField::MaxSpaceReclaimBytes => {
2488 if max_space_reclaim_bytes__.is_some() {
2489 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
2490 }
2491 max_space_reclaim_bytes__ =
2492 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2493 ;
2494 }
2495 GeneratedField::SplitByStateTable => {
2496 if split_by_state_table__.is_some() {
2497 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
2498 }
2499 split_by_state_table__ = Some(map_.next_value()?);
2500 }
2501 GeneratedField::SplitWeightByVnode => {
2502 if split_weight_by_vnode__.is_some() {
2503 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
2504 }
2505 split_weight_by_vnode__ =
2506 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2507 ;
2508 }
2509 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
2510 if level0_stop_write_threshold_sub_level_number__.is_some() {
2511 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
2512 }
2513 level0_stop_write_threshold_sub_level_number__ =
2514 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2515 ;
2516 }
2517 GeneratedField::Level0MaxCompactFileNumber => {
2518 if level0_max_compact_file_number__.is_some() {
2519 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
2520 }
2521 level0_max_compact_file_number__ =
2522 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2523 ;
2524 }
2525 GeneratedField::Level0SubLevelCompactLevelCount => {
2526 if level0_sub_level_compact_level_count__.is_some() {
2527 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
2528 }
2529 level0_sub_level_compact_level_count__ =
2530 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2531 ;
2532 }
2533 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
2534 if level0_overlapping_sub_level_compact_level_count__.is_some() {
2535 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
2536 }
2537 level0_overlapping_sub_level_compact_level_count__ =
2538 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2539 ;
2540 }
2541 GeneratedField::TombstoneReclaimRatio => {
2542 if tombstone_reclaim_ratio__.is_some() {
2543 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
2544 }
2545 tombstone_reclaim_ratio__ =
2546 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2547 ;
2548 }
2549 GeneratedField::EnableEmergencyPicker => {
2550 if enable_emergency_picker__.is_some() {
2551 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
2552 }
2553 enable_emergency_picker__ = Some(map_.next_value()?);
2554 }
2555 GeneratedField::MaxL0CompactLevelCount => {
2556 if max_l0_compact_level_count__.is_some() {
2557 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
2558 }
2559 max_l0_compact_level_count__ =
2560 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2561 ;
2562 }
2563 GeneratedField::SstAllowedTrivialMoveMinSize => {
2564 if sst_allowed_trivial_move_min_size__.is_some() {
2565 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
2566 }
2567 sst_allowed_trivial_move_min_size__ =
2568 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2569 ;
2570 }
2571 GeneratedField::DisableAutoGroupScheduling => {
2572 if disable_auto_group_scheduling__.is_some() {
2573 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
2574 }
2575 disable_auto_group_scheduling__ = map_.next_value()?;
2576 }
2577 GeneratedField::MaxOverlappingLevelSize => {
2578 if max_overlapping_level_size__.is_some() {
2579 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
2580 }
2581 max_overlapping_level_size__ =
2582 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2583 ;
2584 }
2585 GeneratedField::EmergencyLevel0SstFileCount => {
2586 if emergency_level0_sst_file_count__.is_some() {
2587 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
2588 }
2589 emergency_level0_sst_file_count__ =
2590 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2591 ;
2592 }
2593 GeneratedField::EmergencyLevel0SubLevelPartition => {
2594 if emergency_level0_sub_level_partition__.is_some() {
2595 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
2596 }
2597 emergency_level0_sub_level_partition__ =
2598 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2599 ;
2600 }
2601 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
2602 if level0_stop_write_threshold_max_sst_count__.is_some() {
2603 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
2604 }
2605 level0_stop_write_threshold_max_sst_count__ =
2606 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2607 ;
2608 }
2609 GeneratedField::Level0StopWriteThresholdMaxSize => {
2610 if level0_stop_write_threshold_max_size__.is_some() {
2611 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
2612 }
2613 level0_stop_write_threshold_max_size__ =
2614 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2615 ;
2616 }
2617 GeneratedField::SstAllowedTrivialMoveMaxCount => {
2618 if sst_allowed_trivial_move_max_count__.is_some() {
2619 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
2620 }
2621 sst_allowed_trivial_move_max_count__ =
2622 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2623 ;
2624 }
2625 GeneratedField::EnableOptimizeL0IntervalSelection => {
2626 if enable_optimize_l0_interval_selection__.is_some() {
2627 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
2628 }
2629 enable_optimize_l0_interval_selection__ = map_.next_value()?;
2630 }
2631 GeneratedField::VnodeAlignedLevelSizeThreshold => {
2632 if vnode_aligned_level_size_threshold__.is_some() {
2633 return Err(serde::de::Error::duplicate_field("vnodeAlignedLevelSizeThreshold"));
2634 }
2635 vnode_aligned_level_size_threshold__ =
2636 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2637 ;
2638 }
2639 GeneratedField::MaxKvCountForXor16 => {
2640 if max_kv_count_for_xor16__.is_some() {
2641 return Err(serde::de::Error::duplicate_field("maxKvCountForXor16"));
2642 }
2643 max_kv_count_for_xor16__ =
2644 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2645 ;
2646 }
2647 GeneratedField::MaxVnodeKeyRangeBytes => {
2648 if max_vnode_key_range_bytes__.is_some() {
2649 return Err(serde::de::Error::duplicate_field("maxVnodeKeyRangeBytes"));
2650 }
2651 max_vnode_key_range_bytes__ =
2652 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2653 ;
2654 }
2655 GeneratedField::SstableFilterType => {
2656 if sstable_filter_type__.is_some() {
2657 return Err(serde::de::Error::duplicate_field("sstableFilterType"));
2658 }
2659 sstable_filter_type__ = Some(map_.next_value()?);
2660 }
2661 GeneratedField::SstableFilterLayout => {
2662 if sstable_filter_layout__.is_some() {
2663 return Err(serde::de::Error::duplicate_field("sstableFilterLayout"));
2664 }
2665 sstable_filter_layout__ = Some(map_.next_value()?);
2666 }
2667 }
2668 }
2669 Ok(CompactionConfig {
2670 max_bytes_for_level_base: max_bytes_for_level_base__.unwrap_or_default(),
2671 max_level: max_level__.unwrap_or_default(),
2672 max_bytes_for_level_multiplier: max_bytes_for_level_multiplier__.unwrap_or_default(),
2673 max_compaction_bytes: max_compaction_bytes__.unwrap_or_default(),
2674 sub_level_max_compaction_bytes: sub_level_max_compaction_bytes__.unwrap_or_default(),
2675 level0_tier_compact_file_number: level0_tier_compact_file_number__.unwrap_or_default(),
2676 compaction_mode: compaction_mode__.unwrap_or_default(),
2677 compression_algorithm: compression_algorithm__.unwrap_or_default(),
2678 target_file_size_base: target_file_size_base__.unwrap_or_default(),
2679 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
2680 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
2681 max_space_reclaim_bytes: max_space_reclaim_bytes__.unwrap_or_default(),
2682 split_by_state_table: split_by_state_table__.unwrap_or_default(),
2683 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
2684 level0_stop_write_threshold_sub_level_number: level0_stop_write_threshold_sub_level_number__.unwrap_or_default(),
2685 level0_max_compact_file_number: level0_max_compact_file_number__.unwrap_or_default(),
2686 level0_sub_level_compact_level_count: level0_sub_level_compact_level_count__.unwrap_or_default(),
2687 level0_overlapping_sub_level_compact_level_count: level0_overlapping_sub_level_compact_level_count__.unwrap_or_default(),
2688 tombstone_reclaim_ratio: tombstone_reclaim_ratio__.unwrap_or_default(),
2689 enable_emergency_picker: enable_emergency_picker__.unwrap_or_default(),
2690 max_l0_compact_level_count: max_l0_compact_level_count__,
2691 sst_allowed_trivial_move_min_size: sst_allowed_trivial_move_min_size__,
2692 disable_auto_group_scheduling: disable_auto_group_scheduling__,
2693 max_overlapping_level_size: max_overlapping_level_size__,
2694 emergency_level0_sst_file_count: emergency_level0_sst_file_count__,
2695 emergency_level0_sub_level_partition: emergency_level0_sub_level_partition__,
2696 level0_stop_write_threshold_max_sst_count: level0_stop_write_threshold_max_sst_count__,
2697 level0_stop_write_threshold_max_size: level0_stop_write_threshold_max_size__,
2698 sst_allowed_trivial_move_max_count: sst_allowed_trivial_move_max_count__,
2699 enable_optimize_l0_interval_selection: enable_optimize_l0_interval_selection__,
2700 vnode_aligned_level_size_threshold: vnode_aligned_level_size_threshold__,
2701 max_kv_count_for_xor16: max_kv_count_for_xor16__,
2702 max_vnode_key_range_bytes: max_vnode_key_range_bytes__,
2703 sstable_filter_type: sstable_filter_type__.unwrap_or_default(),
2704 sstable_filter_layout: sstable_filter_layout__.unwrap_or_default(),
2705 })
2706 }
2707 }
2708 deserializer.deserialize_struct("hummock.CompactionConfig", FIELDS, GeneratedVisitor)
2709 }
2710}
2711impl serde::Serialize for compaction_config::CompactionMode {
2712 #[allow(deprecated)]
2713 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2714 where
2715 S: serde::Serializer,
2716 {
2717 let variant = match self {
2718 Self::Unspecified => "UNSPECIFIED",
2719 Self::Range => "RANGE",
2720 };
2721 serializer.serialize_str(variant)
2722 }
2723}
2724impl<'de> serde::Deserialize<'de> for compaction_config::CompactionMode {
2725 #[allow(deprecated)]
2726 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2727 where
2728 D: serde::Deserializer<'de>,
2729 {
2730 const FIELDS: &[&str] = &[
2731 "UNSPECIFIED",
2732 "RANGE",
2733 ];
2734
2735 struct GeneratedVisitor;
2736
2737 impl serde::de::Visitor<'_> for GeneratedVisitor {
2738 type Value = compaction_config::CompactionMode;
2739
2740 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2741 write!(formatter, "expected one of: {:?}", &FIELDS)
2742 }
2743
2744 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2745 where
2746 E: serde::de::Error,
2747 {
2748 i32::try_from(v)
2749 .ok()
2750 .and_then(|x| x.try_into().ok())
2751 .ok_or_else(|| {
2752 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2753 })
2754 }
2755
2756 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2757 where
2758 E: serde::de::Error,
2759 {
2760 i32::try_from(v)
2761 .ok()
2762 .and_then(|x| x.try_into().ok())
2763 .ok_or_else(|| {
2764 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2765 })
2766 }
2767
2768 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2769 where
2770 E: serde::de::Error,
2771 {
2772 match value {
2773 "UNSPECIFIED" => Ok(compaction_config::CompactionMode::Unspecified),
2774 "RANGE" => Ok(compaction_config::CompactionMode::Range),
2775 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2776 }
2777 }
2778 }
2779 deserializer.deserialize_any(GeneratedVisitor)
2780 }
2781}
2782impl serde::Serialize for CompactionGroup {
2783 #[allow(deprecated)]
2784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2785 where
2786 S: serde::Serializer,
2787 {
2788 use serde::ser::SerializeStruct;
2789 let mut len = 0;
2790 if self.id != 0 {
2791 len += 1;
2792 }
2793 if self.compaction_config.is_some() {
2794 len += 1;
2795 }
2796 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroup", len)?;
2797 if self.id != 0 {
2798 #[allow(clippy::needless_borrow)]
2799 #[allow(clippy::needless_borrows_for_generic_args)]
2800 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2801 }
2802 if let Some(v) = self.compaction_config.as_ref() {
2803 struct_ser.serialize_field("compactionConfig", v)?;
2804 }
2805 struct_ser.end()
2806 }
2807}
2808impl<'de> serde::Deserialize<'de> for CompactionGroup {
2809 #[allow(deprecated)]
2810 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2811 where
2812 D: serde::Deserializer<'de>,
2813 {
2814 const FIELDS: &[&str] = &[
2815 "id",
2816 "compaction_config",
2817 "compactionConfig",
2818 ];
2819
2820 #[allow(clippy::enum_variant_names)]
2821 enum GeneratedField {
2822 Id,
2823 CompactionConfig,
2824 }
2825 impl<'de> serde::Deserialize<'de> for GeneratedField {
2826 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2827 where
2828 D: serde::Deserializer<'de>,
2829 {
2830 struct GeneratedVisitor;
2831
2832 impl serde::de::Visitor<'_> for GeneratedVisitor {
2833 type Value = GeneratedField;
2834
2835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2836 write!(formatter, "expected one of: {:?}", &FIELDS)
2837 }
2838
2839 #[allow(unused_variables)]
2840 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2841 where
2842 E: serde::de::Error,
2843 {
2844 match value {
2845 "id" => Ok(GeneratedField::Id),
2846 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2847 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2848 }
2849 }
2850 }
2851 deserializer.deserialize_identifier(GeneratedVisitor)
2852 }
2853 }
2854 struct GeneratedVisitor;
2855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2856 type Value = CompactionGroup;
2857
2858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2859 formatter.write_str("struct hummock.CompactionGroup")
2860 }
2861
2862 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroup, V::Error>
2863 where
2864 V: serde::de::MapAccess<'de>,
2865 {
2866 let mut id__ = None;
2867 let mut compaction_config__ = None;
2868 while let Some(k) = map_.next_key()? {
2869 match k {
2870 GeneratedField::Id => {
2871 if id__.is_some() {
2872 return Err(serde::de::Error::duplicate_field("id"));
2873 }
2874 id__ =
2875 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2876 ;
2877 }
2878 GeneratedField::CompactionConfig => {
2879 if compaction_config__.is_some() {
2880 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2881 }
2882 compaction_config__ = map_.next_value()?;
2883 }
2884 }
2885 }
2886 Ok(CompactionGroup {
2887 id: id__.unwrap_or_default(),
2888 compaction_config: compaction_config__,
2889 })
2890 }
2891 }
2892 deserializer.deserialize_struct("hummock.CompactionGroup", FIELDS, GeneratedVisitor)
2893 }
2894}
2895impl serde::Serialize for CompactionGroupInfo {
2896 #[allow(deprecated)]
2897 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2898 where
2899 S: serde::Serializer,
2900 {
2901 use serde::ser::SerializeStruct;
2902 let mut len = 0;
2903 if self.id != 0 {
2904 len += 1;
2905 }
2906 if self.parent_id != 0 {
2907 len += 1;
2908 }
2909 if !self.member_table_ids.is_empty() {
2910 len += 1;
2911 }
2912 if self.compaction_config.is_some() {
2913 len += 1;
2914 }
2915 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroupInfo", len)?;
2916 if self.id != 0 {
2917 #[allow(clippy::needless_borrow)]
2918 #[allow(clippy::needless_borrows_for_generic_args)]
2919 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2920 }
2921 if self.parent_id != 0 {
2922 #[allow(clippy::needless_borrow)]
2923 #[allow(clippy::needless_borrows_for_generic_args)]
2924 struct_ser.serialize_field("parentId", ToString::to_string(&self.parent_id).as_str())?;
2925 }
2926 if !self.member_table_ids.is_empty() {
2927 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
2928 }
2929 if let Some(v) = self.compaction_config.as_ref() {
2930 struct_ser.serialize_field("compactionConfig", v)?;
2931 }
2932 struct_ser.end()
2933 }
2934}
2935impl<'de> serde::Deserialize<'de> for CompactionGroupInfo {
2936 #[allow(deprecated)]
2937 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2938 where
2939 D: serde::Deserializer<'de>,
2940 {
2941 const FIELDS: &[&str] = &[
2942 "id",
2943 "parent_id",
2944 "parentId",
2945 "member_table_ids",
2946 "memberTableIds",
2947 "compaction_config",
2948 "compactionConfig",
2949 ];
2950
2951 #[allow(clippy::enum_variant_names)]
2952 enum GeneratedField {
2953 Id,
2954 ParentId,
2955 MemberTableIds,
2956 CompactionConfig,
2957 }
2958 impl<'de> serde::Deserialize<'de> for GeneratedField {
2959 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2960 where
2961 D: serde::Deserializer<'de>,
2962 {
2963 struct GeneratedVisitor;
2964
2965 impl serde::de::Visitor<'_> for GeneratedVisitor {
2966 type Value = GeneratedField;
2967
2968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2969 write!(formatter, "expected one of: {:?}", &FIELDS)
2970 }
2971
2972 #[allow(unused_variables)]
2973 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2974 where
2975 E: serde::de::Error,
2976 {
2977 match value {
2978 "id" => Ok(GeneratedField::Id),
2979 "parentId" | "parent_id" => Ok(GeneratedField::ParentId),
2980 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
2981 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2982 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2983 }
2984 }
2985 }
2986 deserializer.deserialize_identifier(GeneratedVisitor)
2987 }
2988 }
2989 struct GeneratedVisitor;
2990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2991 type Value = CompactionGroupInfo;
2992
2993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2994 formatter.write_str("struct hummock.CompactionGroupInfo")
2995 }
2996
2997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroupInfo, V::Error>
2998 where
2999 V: serde::de::MapAccess<'de>,
3000 {
3001 let mut id__ = None;
3002 let mut parent_id__ = None;
3003 let mut member_table_ids__ = None;
3004 let mut compaction_config__ = None;
3005 while let Some(k) = map_.next_key()? {
3006 match k {
3007 GeneratedField::Id => {
3008 if id__.is_some() {
3009 return Err(serde::de::Error::duplicate_field("id"));
3010 }
3011 id__ =
3012 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3013 ;
3014 }
3015 GeneratedField::ParentId => {
3016 if parent_id__.is_some() {
3017 return Err(serde::de::Error::duplicate_field("parentId"));
3018 }
3019 parent_id__ =
3020 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3021 ;
3022 }
3023 GeneratedField::MemberTableIds => {
3024 if member_table_ids__.is_some() {
3025 return Err(serde::de::Error::duplicate_field("memberTableIds"));
3026 }
3027 member_table_ids__ =
3028 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3029 .into_iter().map(|x| x.0).collect())
3030 ;
3031 }
3032 GeneratedField::CompactionConfig => {
3033 if compaction_config__.is_some() {
3034 return Err(serde::de::Error::duplicate_field("compactionConfig"));
3035 }
3036 compaction_config__ = map_.next_value()?;
3037 }
3038 }
3039 }
3040 Ok(CompactionGroupInfo {
3041 id: id__.unwrap_or_default(),
3042 parent_id: parent_id__.unwrap_or_default(),
3043 member_table_ids: member_table_ids__.unwrap_or_default(),
3044 compaction_config: compaction_config__,
3045 })
3046 }
3047 }
3048 deserializer.deserialize_struct("hummock.CompactionGroupInfo", FIELDS, GeneratedVisitor)
3049 }
3050}
3051impl serde::Serialize for CompatibilityVersion {
3052 #[allow(deprecated)]
3053 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3054 where
3055 S: serde::Serializer,
3056 {
3057 let variant = match self {
3058 Self::VersionUnspecified => "VERSION_UNSPECIFIED",
3059 Self::NoTrivialSplit => "NO_TRIVIAL_SPLIT",
3060 Self::NoMemberTableIds => "NO_MEMBER_TABLE_IDS",
3061 Self::SplitGroupByTableId => "SPLIT_GROUP_BY_TABLE_ID",
3062 };
3063 serializer.serialize_str(variant)
3064 }
3065}
3066impl<'de> serde::Deserialize<'de> for CompatibilityVersion {
3067 #[allow(deprecated)]
3068 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3069 where
3070 D: serde::Deserializer<'de>,
3071 {
3072 const FIELDS: &[&str] = &[
3073 "VERSION_UNSPECIFIED",
3074 "NO_TRIVIAL_SPLIT",
3075 "NO_MEMBER_TABLE_IDS",
3076 "SPLIT_GROUP_BY_TABLE_ID",
3077 ];
3078
3079 struct GeneratedVisitor;
3080
3081 impl serde::de::Visitor<'_> for GeneratedVisitor {
3082 type Value = CompatibilityVersion;
3083
3084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3085 write!(formatter, "expected one of: {:?}", &FIELDS)
3086 }
3087
3088 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3089 where
3090 E: serde::de::Error,
3091 {
3092 i32::try_from(v)
3093 .ok()
3094 .and_then(|x| x.try_into().ok())
3095 .ok_or_else(|| {
3096 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3097 })
3098 }
3099
3100 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3101 where
3102 E: serde::de::Error,
3103 {
3104 i32::try_from(v)
3105 .ok()
3106 .and_then(|x| x.try_into().ok())
3107 .ok_or_else(|| {
3108 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3109 })
3110 }
3111
3112 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3113 where
3114 E: serde::de::Error,
3115 {
3116 match value {
3117 "VERSION_UNSPECIFIED" => Ok(CompatibilityVersion::VersionUnspecified),
3118 "NO_TRIVIAL_SPLIT" => Ok(CompatibilityVersion::NoTrivialSplit),
3119 "NO_MEMBER_TABLE_IDS" => Ok(CompatibilityVersion::NoMemberTableIds),
3120 "SPLIT_GROUP_BY_TABLE_ID" => Ok(CompatibilityVersion::SplitGroupByTableId),
3121 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3122 }
3123 }
3124 }
3125 deserializer.deserialize_any(GeneratedVisitor)
3126 }
3127}
3128impl serde::Serialize for DisableCommitEpochRequest {
3129 #[allow(deprecated)]
3130 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3131 where
3132 S: serde::Serializer,
3133 {
3134 use serde::ser::SerializeStruct;
3135 let len = 0;
3136 let struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochRequest", len)?;
3137 struct_ser.end()
3138 }
3139}
3140impl<'de> serde::Deserialize<'de> for DisableCommitEpochRequest {
3141 #[allow(deprecated)]
3142 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3143 where
3144 D: serde::Deserializer<'de>,
3145 {
3146 const FIELDS: &[&str] = &[
3147 ];
3148
3149 #[allow(clippy::enum_variant_names)]
3150 enum GeneratedField {
3151 }
3152 impl<'de> serde::Deserialize<'de> for GeneratedField {
3153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3154 where
3155 D: serde::Deserializer<'de>,
3156 {
3157 struct GeneratedVisitor;
3158
3159 impl serde::de::Visitor<'_> for GeneratedVisitor {
3160 type Value = GeneratedField;
3161
3162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3163 write!(formatter, "expected one of: {:?}", &FIELDS)
3164 }
3165
3166 #[allow(unused_variables)]
3167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3168 where
3169 E: serde::de::Error,
3170 {
3171 Err(serde::de::Error::unknown_field(value, FIELDS))
3172 }
3173 }
3174 deserializer.deserialize_identifier(GeneratedVisitor)
3175 }
3176 }
3177 struct GeneratedVisitor;
3178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3179 type Value = DisableCommitEpochRequest;
3180
3181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3182 formatter.write_str("struct hummock.DisableCommitEpochRequest")
3183 }
3184
3185 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochRequest, V::Error>
3186 where
3187 V: serde::de::MapAccess<'de>,
3188 {
3189 while map_.next_key::<GeneratedField>()?.is_some() {
3190 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3191 }
3192 Ok(DisableCommitEpochRequest {
3193 })
3194 }
3195 }
3196 deserializer.deserialize_struct("hummock.DisableCommitEpochRequest", FIELDS, GeneratedVisitor)
3197 }
3198}
3199impl serde::Serialize for DisableCommitEpochResponse {
3200 #[allow(deprecated)]
3201 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3202 where
3203 S: serde::Serializer,
3204 {
3205 use serde::ser::SerializeStruct;
3206 let mut len = 0;
3207 if self.current_version.is_some() {
3208 len += 1;
3209 }
3210 let mut struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochResponse", len)?;
3211 if let Some(v) = self.current_version.as_ref() {
3212 struct_ser.serialize_field("currentVersion", v)?;
3213 }
3214 struct_ser.end()
3215 }
3216}
3217impl<'de> serde::Deserialize<'de> for DisableCommitEpochResponse {
3218 #[allow(deprecated)]
3219 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3220 where
3221 D: serde::Deserializer<'de>,
3222 {
3223 const FIELDS: &[&str] = &[
3224 "current_version",
3225 "currentVersion",
3226 ];
3227
3228 #[allow(clippy::enum_variant_names)]
3229 enum GeneratedField {
3230 CurrentVersion,
3231 }
3232 impl<'de> serde::Deserialize<'de> for GeneratedField {
3233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3234 where
3235 D: serde::Deserializer<'de>,
3236 {
3237 struct GeneratedVisitor;
3238
3239 impl serde::de::Visitor<'_> for GeneratedVisitor {
3240 type Value = GeneratedField;
3241
3242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3243 write!(formatter, "expected one of: {:?}", &FIELDS)
3244 }
3245
3246 #[allow(unused_variables)]
3247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3248 where
3249 E: serde::de::Error,
3250 {
3251 match value {
3252 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
3253 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3254 }
3255 }
3256 }
3257 deserializer.deserialize_identifier(GeneratedVisitor)
3258 }
3259 }
3260 struct GeneratedVisitor;
3261 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3262 type Value = DisableCommitEpochResponse;
3263
3264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3265 formatter.write_str("struct hummock.DisableCommitEpochResponse")
3266 }
3267
3268 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochResponse, V::Error>
3269 where
3270 V: serde::de::MapAccess<'de>,
3271 {
3272 let mut current_version__ = None;
3273 while let Some(k) = map_.next_key()? {
3274 match k {
3275 GeneratedField::CurrentVersion => {
3276 if current_version__.is_some() {
3277 return Err(serde::de::Error::duplicate_field("currentVersion"));
3278 }
3279 current_version__ = map_.next_value()?;
3280 }
3281 }
3282 }
3283 Ok(DisableCommitEpochResponse {
3284 current_version: current_version__,
3285 })
3286 }
3287 }
3288 deserializer.deserialize_struct("hummock.DisableCommitEpochResponse", FIELDS, GeneratedVisitor)
3289 }
3290}
3291impl serde::Serialize for EpochNewChangeLog {
3292 #[allow(deprecated)]
3293 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3294 where
3295 S: serde::Serializer,
3296 {
3297 use serde::ser::SerializeStruct;
3298 let mut len = 0;
3299 if !self.old_value.is_empty() {
3300 len += 1;
3301 }
3302 if !self.new_value.is_empty() {
3303 len += 1;
3304 }
3305 if !self.epochs.is_empty() {
3306 len += 1;
3307 }
3308 let mut struct_ser = serializer.serialize_struct("hummock.EpochNewChangeLog", len)?;
3309 if !self.old_value.is_empty() {
3310 struct_ser.serialize_field("oldValue", &self.old_value)?;
3311 }
3312 if !self.new_value.is_empty() {
3313 struct_ser.serialize_field("newValue", &self.new_value)?;
3314 }
3315 if !self.epochs.is_empty() {
3316 struct_ser.serialize_field("epochs", &self.epochs.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3317 }
3318 struct_ser.end()
3319 }
3320}
3321impl<'de> serde::Deserialize<'de> for EpochNewChangeLog {
3322 #[allow(deprecated)]
3323 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3324 where
3325 D: serde::Deserializer<'de>,
3326 {
3327 const FIELDS: &[&str] = &[
3328 "old_value",
3329 "oldValue",
3330 "new_value",
3331 "newValue",
3332 "epochs",
3333 ];
3334
3335 #[allow(clippy::enum_variant_names)]
3336 enum GeneratedField {
3337 OldValue,
3338 NewValue,
3339 Epochs,
3340 }
3341 impl<'de> serde::Deserialize<'de> for GeneratedField {
3342 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3343 where
3344 D: serde::Deserializer<'de>,
3345 {
3346 struct GeneratedVisitor;
3347
3348 impl serde::de::Visitor<'_> for GeneratedVisitor {
3349 type Value = GeneratedField;
3350
3351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3352 write!(formatter, "expected one of: {:?}", &FIELDS)
3353 }
3354
3355 #[allow(unused_variables)]
3356 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3357 where
3358 E: serde::de::Error,
3359 {
3360 match value {
3361 "oldValue" | "old_value" => Ok(GeneratedField::OldValue),
3362 "newValue" | "new_value" => Ok(GeneratedField::NewValue),
3363 "epochs" => Ok(GeneratedField::Epochs),
3364 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3365 }
3366 }
3367 }
3368 deserializer.deserialize_identifier(GeneratedVisitor)
3369 }
3370 }
3371 struct GeneratedVisitor;
3372 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3373 type Value = EpochNewChangeLog;
3374
3375 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3376 formatter.write_str("struct hummock.EpochNewChangeLog")
3377 }
3378
3379 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EpochNewChangeLog, V::Error>
3380 where
3381 V: serde::de::MapAccess<'de>,
3382 {
3383 let mut old_value__ = None;
3384 let mut new_value__ = None;
3385 let mut epochs__ = None;
3386 while let Some(k) = map_.next_key()? {
3387 match k {
3388 GeneratedField::OldValue => {
3389 if old_value__.is_some() {
3390 return Err(serde::de::Error::duplicate_field("oldValue"));
3391 }
3392 old_value__ = Some(map_.next_value()?);
3393 }
3394 GeneratedField::NewValue => {
3395 if new_value__.is_some() {
3396 return Err(serde::de::Error::duplicate_field("newValue"));
3397 }
3398 new_value__ = Some(map_.next_value()?);
3399 }
3400 GeneratedField::Epochs => {
3401 if epochs__.is_some() {
3402 return Err(serde::de::Error::duplicate_field("epochs"));
3403 }
3404 epochs__ =
3405 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3406 .into_iter().map(|x| x.0).collect())
3407 ;
3408 }
3409 }
3410 }
3411 Ok(EpochNewChangeLog {
3412 old_value: old_value__.unwrap_or_default(),
3413 new_value: new_value__.unwrap_or_default(),
3414 epochs: epochs__.unwrap_or_default(),
3415 })
3416 }
3417 }
3418 deserializer.deserialize_struct("hummock.EpochNewChangeLog", FIELDS, GeneratedVisitor)
3419 }
3420}
3421impl serde::Serialize for FlatIndex {
3422 #[allow(deprecated)]
3423 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3424 where
3425 S: serde::Serializer,
3426 {
3427 use serde::ser::SerializeStruct;
3428 let mut len = 0;
3429 if self.config.is_some() {
3430 len += 1;
3431 }
3432 if !self.vector_files.is_empty() {
3433 len += 1;
3434 }
3435 if self.next_vector_id != 0 {
3436 len += 1;
3437 }
3438 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndex", len)?;
3439 if let Some(v) = self.config.as_ref() {
3440 struct_ser.serialize_field("config", v)?;
3441 }
3442 if !self.vector_files.is_empty() {
3443 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
3444 }
3445 if self.next_vector_id != 0 {
3446 #[allow(clippy::needless_borrow)]
3447 #[allow(clippy::needless_borrows_for_generic_args)]
3448 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3449 }
3450 struct_ser.end()
3451 }
3452}
3453impl<'de> serde::Deserialize<'de> for FlatIndex {
3454 #[allow(deprecated)]
3455 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3456 where
3457 D: serde::Deserializer<'de>,
3458 {
3459 const FIELDS: &[&str] = &[
3460 "config",
3461 "vector_files",
3462 "vectorFiles",
3463 "next_vector_id",
3464 "nextVectorId",
3465 ];
3466
3467 #[allow(clippy::enum_variant_names)]
3468 enum GeneratedField {
3469 Config,
3470 VectorFiles,
3471 NextVectorId,
3472 }
3473 impl<'de> serde::Deserialize<'de> for GeneratedField {
3474 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3475 where
3476 D: serde::Deserializer<'de>,
3477 {
3478 struct GeneratedVisitor;
3479
3480 impl serde::de::Visitor<'_> for GeneratedVisitor {
3481 type Value = GeneratedField;
3482
3483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3484 write!(formatter, "expected one of: {:?}", &FIELDS)
3485 }
3486
3487 #[allow(unused_variables)]
3488 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3489 where
3490 E: serde::de::Error,
3491 {
3492 match value {
3493 "config" => Ok(GeneratedField::Config),
3494 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
3495 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3496 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3497 }
3498 }
3499 }
3500 deserializer.deserialize_identifier(GeneratedVisitor)
3501 }
3502 }
3503 struct GeneratedVisitor;
3504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3505 type Value = FlatIndex;
3506
3507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3508 formatter.write_str("struct hummock.FlatIndex")
3509 }
3510
3511 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndex, V::Error>
3512 where
3513 V: serde::de::MapAccess<'de>,
3514 {
3515 let mut config__ = None;
3516 let mut vector_files__ = None;
3517 let mut next_vector_id__ = None;
3518 while let Some(k) = map_.next_key()? {
3519 match k {
3520 GeneratedField::Config => {
3521 if config__.is_some() {
3522 return Err(serde::de::Error::duplicate_field("config"));
3523 }
3524 config__ = map_.next_value()?;
3525 }
3526 GeneratedField::VectorFiles => {
3527 if vector_files__.is_some() {
3528 return Err(serde::de::Error::duplicate_field("vectorFiles"));
3529 }
3530 vector_files__ = Some(map_.next_value()?);
3531 }
3532 GeneratedField::NextVectorId => {
3533 if next_vector_id__.is_some() {
3534 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3535 }
3536 next_vector_id__ =
3537 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3538 ;
3539 }
3540 }
3541 }
3542 Ok(FlatIndex {
3543 config: config__,
3544 vector_files: vector_files__.unwrap_or_default(),
3545 next_vector_id: next_vector_id__.unwrap_or_default(),
3546 })
3547 }
3548 }
3549 deserializer.deserialize_struct("hummock.FlatIndex", FIELDS, GeneratedVisitor)
3550 }
3551}
3552impl serde::Serialize for FlatIndexAdd {
3553 #[allow(deprecated)]
3554 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3555 where
3556 S: serde::Serializer,
3557 {
3558 use serde::ser::SerializeStruct;
3559 let mut len = 0;
3560 if !self.added_vector_files.is_empty() {
3561 len += 1;
3562 }
3563 if self.next_vector_id != 0 {
3564 len += 1;
3565 }
3566 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndexAdd", len)?;
3567 if !self.added_vector_files.is_empty() {
3568 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
3569 }
3570 if self.next_vector_id != 0 {
3571 #[allow(clippy::needless_borrow)]
3572 #[allow(clippy::needless_borrows_for_generic_args)]
3573 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3574 }
3575 struct_ser.end()
3576 }
3577}
3578impl<'de> serde::Deserialize<'de> for FlatIndexAdd {
3579 #[allow(deprecated)]
3580 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3581 where
3582 D: serde::Deserializer<'de>,
3583 {
3584 const FIELDS: &[&str] = &[
3585 "added_vector_files",
3586 "addedVectorFiles",
3587 "next_vector_id",
3588 "nextVectorId",
3589 ];
3590
3591 #[allow(clippy::enum_variant_names)]
3592 enum GeneratedField {
3593 AddedVectorFiles,
3594 NextVectorId,
3595 }
3596 impl<'de> serde::Deserialize<'de> for GeneratedField {
3597 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3598 where
3599 D: serde::Deserializer<'de>,
3600 {
3601 struct GeneratedVisitor;
3602
3603 impl serde::de::Visitor<'_> for GeneratedVisitor {
3604 type Value = GeneratedField;
3605
3606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3607 write!(formatter, "expected one of: {:?}", &FIELDS)
3608 }
3609
3610 #[allow(unused_variables)]
3611 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3612 where
3613 E: serde::de::Error,
3614 {
3615 match value {
3616 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
3617 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3618 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3619 }
3620 }
3621 }
3622 deserializer.deserialize_identifier(GeneratedVisitor)
3623 }
3624 }
3625 struct GeneratedVisitor;
3626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3627 type Value = FlatIndexAdd;
3628
3629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3630 formatter.write_str("struct hummock.FlatIndexAdd")
3631 }
3632
3633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexAdd, V::Error>
3634 where
3635 V: serde::de::MapAccess<'de>,
3636 {
3637 let mut added_vector_files__ = None;
3638 let mut next_vector_id__ = None;
3639 while let Some(k) = map_.next_key()? {
3640 match k {
3641 GeneratedField::AddedVectorFiles => {
3642 if added_vector_files__.is_some() {
3643 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
3644 }
3645 added_vector_files__ = Some(map_.next_value()?);
3646 }
3647 GeneratedField::NextVectorId => {
3648 if next_vector_id__.is_some() {
3649 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3650 }
3651 next_vector_id__ =
3652 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3653 ;
3654 }
3655 }
3656 }
3657 Ok(FlatIndexAdd {
3658 added_vector_files: added_vector_files__.unwrap_or_default(),
3659 next_vector_id: next_vector_id__.unwrap_or_default(),
3660 })
3661 }
3662 }
3663 deserializer.deserialize_struct("hummock.FlatIndexAdd", FIELDS, GeneratedVisitor)
3664 }
3665}
3666impl serde::Serialize for FullScanTask {
3667 #[allow(deprecated)]
3668 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3669 where
3670 S: serde::Serializer,
3671 {
3672 use serde::ser::SerializeStruct;
3673 let mut len = 0;
3674 if self.sst_retention_watermark != 0 {
3675 len += 1;
3676 }
3677 if self.prefix.is_some() {
3678 len += 1;
3679 }
3680 if self.start_after.is_some() {
3681 len += 1;
3682 }
3683 if self.limit.is_some() {
3684 len += 1;
3685 }
3686 let mut struct_ser = serializer.serialize_struct("hummock.FullScanTask", len)?;
3687 if self.sst_retention_watermark != 0 {
3688 #[allow(clippy::needless_borrow)]
3689 #[allow(clippy::needless_borrows_for_generic_args)]
3690 struct_ser.serialize_field("sstRetentionWatermark", ToString::to_string(&self.sst_retention_watermark).as_str())?;
3691 }
3692 if let Some(v) = self.prefix.as_ref() {
3693 struct_ser.serialize_field("prefix", v)?;
3694 }
3695 if let Some(v) = self.start_after.as_ref() {
3696 struct_ser.serialize_field("startAfter", v)?;
3697 }
3698 if let Some(v) = self.limit.as_ref() {
3699 #[allow(clippy::needless_borrow)]
3700 #[allow(clippy::needless_borrows_for_generic_args)]
3701 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
3702 }
3703 struct_ser.end()
3704 }
3705}
3706impl<'de> serde::Deserialize<'de> for FullScanTask {
3707 #[allow(deprecated)]
3708 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3709 where
3710 D: serde::Deserializer<'de>,
3711 {
3712 const FIELDS: &[&str] = &[
3713 "sst_retention_watermark",
3714 "sstRetentionWatermark",
3715 "prefix",
3716 "start_after",
3717 "startAfter",
3718 "limit",
3719 ];
3720
3721 #[allow(clippy::enum_variant_names)]
3722 enum GeneratedField {
3723 SstRetentionWatermark,
3724 Prefix,
3725 StartAfter,
3726 Limit,
3727 }
3728 impl<'de> serde::Deserialize<'de> for GeneratedField {
3729 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3730 where
3731 D: serde::Deserializer<'de>,
3732 {
3733 struct GeneratedVisitor;
3734
3735 impl serde::de::Visitor<'_> for GeneratedVisitor {
3736 type Value = GeneratedField;
3737
3738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3739 write!(formatter, "expected one of: {:?}", &FIELDS)
3740 }
3741
3742 #[allow(unused_variables)]
3743 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3744 where
3745 E: serde::de::Error,
3746 {
3747 match value {
3748 "sstRetentionWatermark" | "sst_retention_watermark" => Ok(GeneratedField::SstRetentionWatermark),
3749 "prefix" => Ok(GeneratedField::Prefix),
3750 "startAfter" | "start_after" => Ok(GeneratedField::StartAfter),
3751 "limit" => Ok(GeneratedField::Limit),
3752 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3753 }
3754 }
3755 }
3756 deserializer.deserialize_identifier(GeneratedVisitor)
3757 }
3758 }
3759 struct GeneratedVisitor;
3760 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3761 type Value = FullScanTask;
3762
3763 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3764 formatter.write_str("struct hummock.FullScanTask")
3765 }
3766
3767 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FullScanTask, V::Error>
3768 where
3769 V: serde::de::MapAccess<'de>,
3770 {
3771 let mut sst_retention_watermark__ = None;
3772 let mut prefix__ = None;
3773 let mut start_after__ = None;
3774 let mut limit__ = None;
3775 while let Some(k) = map_.next_key()? {
3776 match k {
3777 GeneratedField::SstRetentionWatermark => {
3778 if sst_retention_watermark__.is_some() {
3779 return Err(serde::de::Error::duplicate_field("sstRetentionWatermark"));
3780 }
3781 sst_retention_watermark__ =
3782 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3783 ;
3784 }
3785 GeneratedField::Prefix => {
3786 if prefix__.is_some() {
3787 return Err(serde::de::Error::duplicate_field("prefix"));
3788 }
3789 prefix__ = map_.next_value()?;
3790 }
3791 GeneratedField::StartAfter => {
3792 if start_after__.is_some() {
3793 return Err(serde::de::Error::duplicate_field("startAfter"));
3794 }
3795 start_after__ = map_.next_value()?;
3796 }
3797 GeneratedField::Limit => {
3798 if limit__.is_some() {
3799 return Err(serde::de::Error::duplicate_field("limit"));
3800 }
3801 limit__ =
3802 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3803 ;
3804 }
3805 }
3806 }
3807 Ok(FullScanTask {
3808 sst_retention_watermark: sst_retention_watermark__.unwrap_or_default(),
3809 prefix: prefix__,
3810 start_after: start_after__,
3811 limit: limit__,
3812 })
3813 }
3814 }
3815 deserializer.deserialize_struct("hummock.FullScanTask", FIELDS, GeneratedVisitor)
3816 }
3817}
3818impl serde::Serialize for GetAssignedCompactTaskNumRequest {
3819 #[allow(deprecated)]
3820 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3821 where
3822 S: serde::Serializer,
3823 {
3824 use serde::ser::SerializeStruct;
3825 let len = 0;
3826 let struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumRequest", len)?;
3827 struct_ser.end()
3828 }
3829}
3830impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumRequest {
3831 #[allow(deprecated)]
3832 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3833 where
3834 D: serde::Deserializer<'de>,
3835 {
3836 const FIELDS: &[&str] = &[
3837 ];
3838
3839 #[allow(clippy::enum_variant_names)]
3840 enum GeneratedField {
3841 }
3842 impl<'de> serde::Deserialize<'de> for GeneratedField {
3843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3844 where
3845 D: serde::Deserializer<'de>,
3846 {
3847 struct GeneratedVisitor;
3848
3849 impl serde::de::Visitor<'_> for GeneratedVisitor {
3850 type Value = GeneratedField;
3851
3852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3853 write!(formatter, "expected one of: {:?}", &FIELDS)
3854 }
3855
3856 #[allow(unused_variables)]
3857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3858 where
3859 E: serde::de::Error,
3860 {
3861 Err(serde::de::Error::unknown_field(value, FIELDS))
3862 }
3863 }
3864 deserializer.deserialize_identifier(GeneratedVisitor)
3865 }
3866 }
3867 struct GeneratedVisitor;
3868 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3869 type Value = GetAssignedCompactTaskNumRequest;
3870
3871 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3872 formatter.write_str("struct hummock.GetAssignedCompactTaskNumRequest")
3873 }
3874
3875 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumRequest, V::Error>
3876 where
3877 V: serde::de::MapAccess<'de>,
3878 {
3879 while map_.next_key::<GeneratedField>()?.is_some() {
3880 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3881 }
3882 Ok(GetAssignedCompactTaskNumRequest {
3883 })
3884 }
3885 }
3886 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumRequest", FIELDS, GeneratedVisitor)
3887 }
3888}
3889impl serde::Serialize for GetAssignedCompactTaskNumResponse {
3890 #[allow(deprecated)]
3891 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3892 where
3893 S: serde::Serializer,
3894 {
3895 use serde::ser::SerializeStruct;
3896 let mut len = 0;
3897 if self.num_tasks != 0 {
3898 len += 1;
3899 }
3900 let mut struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumResponse", len)?;
3901 if self.num_tasks != 0 {
3902 struct_ser.serialize_field("numTasks", &self.num_tasks)?;
3903 }
3904 struct_ser.end()
3905 }
3906}
3907impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumResponse {
3908 #[allow(deprecated)]
3909 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3910 where
3911 D: serde::Deserializer<'de>,
3912 {
3913 const FIELDS: &[&str] = &[
3914 "num_tasks",
3915 "numTasks",
3916 ];
3917
3918 #[allow(clippy::enum_variant_names)]
3919 enum GeneratedField {
3920 NumTasks,
3921 }
3922 impl<'de> serde::Deserialize<'de> for GeneratedField {
3923 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3924 where
3925 D: serde::Deserializer<'de>,
3926 {
3927 struct GeneratedVisitor;
3928
3929 impl serde::de::Visitor<'_> for GeneratedVisitor {
3930 type Value = GeneratedField;
3931
3932 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3933 write!(formatter, "expected one of: {:?}", &FIELDS)
3934 }
3935
3936 #[allow(unused_variables)]
3937 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3938 where
3939 E: serde::de::Error,
3940 {
3941 match value {
3942 "numTasks" | "num_tasks" => Ok(GeneratedField::NumTasks),
3943 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3944 }
3945 }
3946 }
3947 deserializer.deserialize_identifier(GeneratedVisitor)
3948 }
3949 }
3950 struct GeneratedVisitor;
3951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3952 type Value = GetAssignedCompactTaskNumResponse;
3953
3954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3955 formatter.write_str("struct hummock.GetAssignedCompactTaskNumResponse")
3956 }
3957
3958 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumResponse, V::Error>
3959 where
3960 V: serde::de::MapAccess<'de>,
3961 {
3962 let mut num_tasks__ = None;
3963 while let Some(k) = map_.next_key()? {
3964 match k {
3965 GeneratedField::NumTasks => {
3966 if num_tasks__.is_some() {
3967 return Err(serde::de::Error::duplicate_field("numTasks"));
3968 }
3969 num_tasks__ =
3970 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3971 ;
3972 }
3973 }
3974 }
3975 Ok(GetAssignedCompactTaskNumResponse {
3976 num_tasks: num_tasks__.unwrap_or_default(),
3977 })
3978 }
3979 }
3980 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumResponse", FIELDS, GeneratedVisitor)
3981 }
3982}
3983impl serde::Serialize for GetCompactionScoreRequest {
3984 #[allow(deprecated)]
3985 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3986 where
3987 S: serde::Serializer,
3988 {
3989 use serde::ser::SerializeStruct;
3990 let mut len = 0;
3991 if self.compaction_group_id != 0 {
3992 len += 1;
3993 }
3994 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreRequest", len)?;
3995 if self.compaction_group_id != 0 {
3996 #[allow(clippy::needless_borrow)]
3997 #[allow(clippy::needless_borrows_for_generic_args)]
3998 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3999 }
4000 struct_ser.end()
4001 }
4002}
4003impl<'de> serde::Deserialize<'de> for GetCompactionScoreRequest {
4004 #[allow(deprecated)]
4005 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4006 where
4007 D: serde::Deserializer<'de>,
4008 {
4009 const FIELDS: &[&str] = &[
4010 "compaction_group_id",
4011 "compactionGroupId",
4012 ];
4013
4014 #[allow(clippy::enum_variant_names)]
4015 enum GeneratedField {
4016 CompactionGroupId,
4017 }
4018 impl<'de> serde::Deserialize<'de> for GeneratedField {
4019 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4020 where
4021 D: serde::Deserializer<'de>,
4022 {
4023 struct GeneratedVisitor;
4024
4025 impl serde::de::Visitor<'_> for GeneratedVisitor {
4026 type Value = GeneratedField;
4027
4028 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4029 write!(formatter, "expected one of: {:?}", &FIELDS)
4030 }
4031
4032 #[allow(unused_variables)]
4033 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4034 where
4035 E: serde::de::Error,
4036 {
4037 match value {
4038 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
4039 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4040 }
4041 }
4042 }
4043 deserializer.deserialize_identifier(GeneratedVisitor)
4044 }
4045 }
4046 struct GeneratedVisitor;
4047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4048 type Value = GetCompactionScoreRequest;
4049
4050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4051 formatter.write_str("struct hummock.GetCompactionScoreRequest")
4052 }
4053
4054 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreRequest, V::Error>
4055 where
4056 V: serde::de::MapAccess<'de>,
4057 {
4058 let mut compaction_group_id__ = None;
4059 while let Some(k) = map_.next_key()? {
4060 match k {
4061 GeneratedField::CompactionGroupId => {
4062 if compaction_group_id__.is_some() {
4063 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
4064 }
4065 compaction_group_id__ =
4066 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4067 ;
4068 }
4069 }
4070 }
4071 Ok(GetCompactionScoreRequest {
4072 compaction_group_id: compaction_group_id__.unwrap_or_default(),
4073 })
4074 }
4075 }
4076 deserializer.deserialize_struct("hummock.GetCompactionScoreRequest", FIELDS, GeneratedVisitor)
4077 }
4078}
4079impl serde::Serialize for GetCompactionScoreResponse {
4080 #[allow(deprecated)]
4081 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4082 where
4083 S: serde::Serializer,
4084 {
4085 use serde::ser::SerializeStruct;
4086 let mut len = 0;
4087 if self.compaction_group_id != 0 {
4088 len += 1;
4089 }
4090 if !self.scores.is_empty() {
4091 len += 1;
4092 }
4093 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse", len)?;
4094 if self.compaction_group_id != 0 {
4095 #[allow(clippy::needless_borrow)]
4096 #[allow(clippy::needless_borrows_for_generic_args)]
4097 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
4098 }
4099 if !self.scores.is_empty() {
4100 struct_ser.serialize_field("scores", &self.scores)?;
4101 }
4102 struct_ser.end()
4103 }
4104}
4105impl<'de> serde::Deserialize<'de> for GetCompactionScoreResponse {
4106 #[allow(deprecated)]
4107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4108 where
4109 D: serde::Deserializer<'de>,
4110 {
4111 const FIELDS: &[&str] = &[
4112 "compaction_group_id",
4113 "compactionGroupId",
4114 "scores",
4115 ];
4116
4117 #[allow(clippy::enum_variant_names)]
4118 enum GeneratedField {
4119 CompactionGroupId,
4120 Scores,
4121 }
4122 impl<'de> serde::Deserialize<'de> for GeneratedField {
4123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4124 where
4125 D: serde::Deserializer<'de>,
4126 {
4127 struct GeneratedVisitor;
4128
4129 impl serde::de::Visitor<'_> for GeneratedVisitor {
4130 type Value = GeneratedField;
4131
4132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4133 write!(formatter, "expected one of: {:?}", &FIELDS)
4134 }
4135
4136 #[allow(unused_variables)]
4137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4138 where
4139 E: serde::de::Error,
4140 {
4141 match value {
4142 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
4143 "scores" => Ok(GeneratedField::Scores),
4144 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4145 }
4146 }
4147 }
4148 deserializer.deserialize_identifier(GeneratedVisitor)
4149 }
4150 }
4151 struct GeneratedVisitor;
4152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4153 type Value = GetCompactionScoreResponse;
4154
4155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4156 formatter.write_str("struct hummock.GetCompactionScoreResponse")
4157 }
4158
4159 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreResponse, V::Error>
4160 where
4161 V: serde::de::MapAccess<'de>,
4162 {
4163 let mut compaction_group_id__ = None;
4164 let mut scores__ = None;
4165 while let Some(k) = map_.next_key()? {
4166 match k {
4167 GeneratedField::CompactionGroupId => {
4168 if compaction_group_id__.is_some() {
4169 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
4170 }
4171 compaction_group_id__ =
4172 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4173 ;
4174 }
4175 GeneratedField::Scores => {
4176 if scores__.is_some() {
4177 return Err(serde::de::Error::duplicate_field("scores"));
4178 }
4179 scores__ = Some(map_.next_value()?);
4180 }
4181 }
4182 }
4183 Ok(GetCompactionScoreResponse {
4184 compaction_group_id: compaction_group_id__.unwrap_or_default(),
4185 scores: scores__.unwrap_or_default(),
4186 })
4187 }
4188 }
4189 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse", FIELDS, GeneratedVisitor)
4190 }
4191}
4192impl serde::Serialize for get_compaction_score_response::PickerInfo {
4193 #[allow(deprecated)]
4194 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4195 where
4196 S: serde::Serializer,
4197 {
4198 use serde::ser::SerializeStruct;
4199 let mut len = 0;
4200 if self.score != 0 {
4201 len += 1;
4202 }
4203 if self.select_level != 0 {
4204 len += 1;
4205 }
4206 if self.target_level != 0 {
4207 len += 1;
4208 }
4209 if !self.picker_type.is_empty() {
4210 len += 1;
4211 }
4212 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", len)?;
4213 if self.score != 0 {
4214 #[allow(clippy::needless_borrow)]
4215 #[allow(clippy::needless_borrows_for_generic_args)]
4216 struct_ser.serialize_field("score", ToString::to_string(&self.score).as_str())?;
4217 }
4218 if self.select_level != 0 {
4219 #[allow(clippy::needless_borrow)]
4220 #[allow(clippy::needless_borrows_for_generic_args)]
4221 struct_ser.serialize_field("selectLevel", ToString::to_string(&self.select_level).as_str())?;
4222 }
4223 if self.target_level != 0 {
4224 #[allow(clippy::needless_borrow)]
4225 #[allow(clippy::needless_borrows_for_generic_args)]
4226 struct_ser.serialize_field("targetLevel", ToString::to_string(&self.target_level).as_str())?;
4227 }
4228 if !self.picker_type.is_empty() {
4229 struct_ser.serialize_field("pickerType", &self.picker_type)?;
4230 }
4231 struct_ser.end()
4232 }
4233}
4234impl<'de> serde::Deserialize<'de> for get_compaction_score_response::PickerInfo {
4235 #[allow(deprecated)]
4236 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4237 where
4238 D: serde::Deserializer<'de>,
4239 {
4240 const FIELDS: &[&str] = &[
4241 "score",
4242 "select_level",
4243 "selectLevel",
4244 "target_level",
4245 "targetLevel",
4246 "picker_type",
4247 "pickerType",
4248 ];
4249
4250 #[allow(clippy::enum_variant_names)]
4251 enum GeneratedField {
4252 Score,
4253 SelectLevel,
4254 TargetLevel,
4255 PickerType,
4256 }
4257 impl<'de> serde::Deserialize<'de> for GeneratedField {
4258 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4259 where
4260 D: serde::Deserializer<'de>,
4261 {
4262 struct GeneratedVisitor;
4263
4264 impl serde::de::Visitor<'_> for GeneratedVisitor {
4265 type Value = GeneratedField;
4266
4267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4268 write!(formatter, "expected one of: {:?}", &FIELDS)
4269 }
4270
4271 #[allow(unused_variables)]
4272 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4273 where
4274 E: serde::de::Error,
4275 {
4276 match value {
4277 "score" => Ok(GeneratedField::Score),
4278 "selectLevel" | "select_level" => Ok(GeneratedField::SelectLevel),
4279 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
4280 "pickerType" | "picker_type" => Ok(GeneratedField::PickerType),
4281 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4282 }
4283 }
4284 }
4285 deserializer.deserialize_identifier(GeneratedVisitor)
4286 }
4287 }
4288 struct GeneratedVisitor;
4289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4290 type Value = get_compaction_score_response::PickerInfo;
4291
4292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4293 formatter.write_str("struct hummock.GetCompactionScoreResponse.PickerInfo")
4294 }
4295
4296 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_compaction_score_response::PickerInfo, V::Error>
4297 where
4298 V: serde::de::MapAccess<'de>,
4299 {
4300 let mut score__ = None;
4301 let mut select_level__ = None;
4302 let mut target_level__ = None;
4303 let mut picker_type__ = None;
4304 while let Some(k) = map_.next_key()? {
4305 match k {
4306 GeneratedField::Score => {
4307 if score__.is_some() {
4308 return Err(serde::de::Error::duplicate_field("score"));
4309 }
4310 score__ =
4311 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4312 ;
4313 }
4314 GeneratedField::SelectLevel => {
4315 if select_level__.is_some() {
4316 return Err(serde::de::Error::duplicate_field("selectLevel"));
4317 }
4318 select_level__ =
4319 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4320 ;
4321 }
4322 GeneratedField::TargetLevel => {
4323 if target_level__.is_some() {
4324 return Err(serde::de::Error::duplicate_field("targetLevel"));
4325 }
4326 target_level__ =
4327 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4328 ;
4329 }
4330 GeneratedField::PickerType => {
4331 if picker_type__.is_some() {
4332 return Err(serde::de::Error::duplicate_field("pickerType"));
4333 }
4334 picker_type__ = Some(map_.next_value()?);
4335 }
4336 }
4337 }
4338 Ok(get_compaction_score_response::PickerInfo {
4339 score: score__.unwrap_or_default(),
4340 select_level: select_level__.unwrap_or_default(),
4341 target_level: target_level__.unwrap_or_default(),
4342 picker_type: picker_type__.unwrap_or_default(),
4343 })
4344 }
4345 }
4346 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", FIELDS, GeneratedVisitor)
4347 }
4348}
4349impl serde::Serialize for GetCurrentVersionRequest {
4350 #[allow(deprecated)]
4351 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4352 where
4353 S: serde::Serializer,
4354 {
4355 use serde::ser::SerializeStruct;
4356 let len = 0;
4357 let struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionRequest", len)?;
4358 struct_ser.end()
4359 }
4360}
4361impl<'de> serde::Deserialize<'de> for GetCurrentVersionRequest {
4362 #[allow(deprecated)]
4363 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4364 where
4365 D: serde::Deserializer<'de>,
4366 {
4367 const FIELDS: &[&str] = &[
4368 ];
4369
4370 #[allow(clippy::enum_variant_names)]
4371 enum GeneratedField {
4372 }
4373 impl<'de> serde::Deserialize<'de> for GeneratedField {
4374 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4375 where
4376 D: serde::Deserializer<'de>,
4377 {
4378 struct GeneratedVisitor;
4379
4380 impl serde::de::Visitor<'_> for GeneratedVisitor {
4381 type Value = GeneratedField;
4382
4383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4384 write!(formatter, "expected one of: {:?}", &FIELDS)
4385 }
4386
4387 #[allow(unused_variables)]
4388 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4389 where
4390 E: serde::de::Error,
4391 {
4392 Err(serde::de::Error::unknown_field(value, FIELDS))
4393 }
4394 }
4395 deserializer.deserialize_identifier(GeneratedVisitor)
4396 }
4397 }
4398 struct GeneratedVisitor;
4399 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4400 type Value = GetCurrentVersionRequest;
4401
4402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4403 formatter.write_str("struct hummock.GetCurrentVersionRequest")
4404 }
4405
4406 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionRequest, V::Error>
4407 where
4408 V: serde::de::MapAccess<'de>,
4409 {
4410 while map_.next_key::<GeneratedField>()?.is_some() {
4411 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4412 }
4413 Ok(GetCurrentVersionRequest {
4414 })
4415 }
4416 }
4417 deserializer.deserialize_struct("hummock.GetCurrentVersionRequest", FIELDS, GeneratedVisitor)
4418 }
4419}
4420impl serde::Serialize for GetCurrentVersionResponse {
4421 #[allow(deprecated)]
4422 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4423 where
4424 S: serde::Serializer,
4425 {
4426 use serde::ser::SerializeStruct;
4427 let mut len = 0;
4428 if self.status.is_some() {
4429 len += 1;
4430 }
4431 if self.current_version.is_some() {
4432 len += 1;
4433 }
4434 let mut struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionResponse", len)?;
4435 if let Some(v) = self.status.as_ref() {
4436 struct_ser.serialize_field("status", v)?;
4437 }
4438 if let Some(v) = self.current_version.as_ref() {
4439 struct_ser.serialize_field("currentVersion", v)?;
4440 }
4441 struct_ser.end()
4442 }
4443}
4444impl<'de> serde::Deserialize<'de> for GetCurrentVersionResponse {
4445 #[allow(deprecated)]
4446 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4447 where
4448 D: serde::Deserializer<'de>,
4449 {
4450 const FIELDS: &[&str] = &[
4451 "status",
4452 "current_version",
4453 "currentVersion",
4454 ];
4455
4456 #[allow(clippy::enum_variant_names)]
4457 enum GeneratedField {
4458 Status,
4459 CurrentVersion,
4460 }
4461 impl<'de> serde::Deserialize<'de> for GeneratedField {
4462 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4463 where
4464 D: serde::Deserializer<'de>,
4465 {
4466 struct GeneratedVisitor;
4467
4468 impl serde::de::Visitor<'_> for GeneratedVisitor {
4469 type Value = GeneratedField;
4470
4471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4472 write!(formatter, "expected one of: {:?}", &FIELDS)
4473 }
4474
4475 #[allow(unused_variables)]
4476 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4477 where
4478 E: serde::de::Error,
4479 {
4480 match value {
4481 "status" => Ok(GeneratedField::Status),
4482 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
4483 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4484 }
4485 }
4486 }
4487 deserializer.deserialize_identifier(GeneratedVisitor)
4488 }
4489 }
4490 struct GeneratedVisitor;
4491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4492 type Value = GetCurrentVersionResponse;
4493
4494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4495 formatter.write_str("struct hummock.GetCurrentVersionResponse")
4496 }
4497
4498 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionResponse, V::Error>
4499 where
4500 V: serde::de::MapAccess<'de>,
4501 {
4502 let mut status__ = None;
4503 let mut current_version__ = None;
4504 while let Some(k) = map_.next_key()? {
4505 match k {
4506 GeneratedField::Status => {
4507 if status__.is_some() {
4508 return Err(serde::de::Error::duplicate_field("status"));
4509 }
4510 status__ = map_.next_value()?;
4511 }
4512 GeneratedField::CurrentVersion => {
4513 if current_version__.is_some() {
4514 return Err(serde::de::Error::duplicate_field("currentVersion"));
4515 }
4516 current_version__ = map_.next_value()?;
4517 }
4518 }
4519 }
4520 Ok(GetCurrentVersionResponse {
4521 status: status__,
4522 current_version: current_version__,
4523 })
4524 }
4525 }
4526 deserializer.deserialize_struct("hummock.GetCurrentVersionResponse", FIELDS, GeneratedVisitor)
4527 }
4528}
4529impl serde::Serialize for GetNewObjectIdsRequest {
4530 #[allow(deprecated)]
4531 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4532 where
4533 S: serde::Serializer,
4534 {
4535 use serde::ser::SerializeStruct;
4536 let mut len = 0;
4537 if self.number != 0 {
4538 len += 1;
4539 }
4540 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsRequest", len)?;
4541 if self.number != 0 {
4542 struct_ser.serialize_field("number", &self.number)?;
4543 }
4544 struct_ser.end()
4545 }
4546}
4547impl<'de> serde::Deserialize<'de> for GetNewObjectIdsRequest {
4548 #[allow(deprecated)]
4549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4550 where
4551 D: serde::Deserializer<'de>,
4552 {
4553 const FIELDS: &[&str] = &[
4554 "number",
4555 ];
4556
4557 #[allow(clippy::enum_variant_names)]
4558 enum GeneratedField {
4559 Number,
4560 }
4561 impl<'de> serde::Deserialize<'de> for GeneratedField {
4562 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4563 where
4564 D: serde::Deserializer<'de>,
4565 {
4566 struct GeneratedVisitor;
4567
4568 impl serde::de::Visitor<'_> for GeneratedVisitor {
4569 type Value = GeneratedField;
4570
4571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4572 write!(formatter, "expected one of: {:?}", &FIELDS)
4573 }
4574
4575 #[allow(unused_variables)]
4576 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4577 where
4578 E: serde::de::Error,
4579 {
4580 match value {
4581 "number" => Ok(GeneratedField::Number),
4582 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4583 }
4584 }
4585 }
4586 deserializer.deserialize_identifier(GeneratedVisitor)
4587 }
4588 }
4589 struct GeneratedVisitor;
4590 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4591 type Value = GetNewObjectIdsRequest;
4592
4593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4594 formatter.write_str("struct hummock.GetNewObjectIdsRequest")
4595 }
4596
4597 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsRequest, V::Error>
4598 where
4599 V: serde::de::MapAccess<'de>,
4600 {
4601 let mut number__ = None;
4602 while let Some(k) = map_.next_key()? {
4603 match k {
4604 GeneratedField::Number => {
4605 if number__.is_some() {
4606 return Err(serde::de::Error::duplicate_field("number"));
4607 }
4608 number__ =
4609 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4610 ;
4611 }
4612 }
4613 }
4614 Ok(GetNewObjectIdsRequest {
4615 number: number__.unwrap_or_default(),
4616 })
4617 }
4618 }
4619 deserializer.deserialize_struct("hummock.GetNewObjectIdsRequest", FIELDS, GeneratedVisitor)
4620 }
4621}
4622impl serde::Serialize for GetNewObjectIdsResponse {
4623 #[allow(deprecated)]
4624 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4625 where
4626 S: serde::Serializer,
4627 {
4628 use serde::ser::SerializeStruct;
4629 let mut len = 0;
4630 if self.status.is_some() {
4631 len += 1;
4632 }
4633 if self.start_id != 0 {
4634 len += 1;
4635 }
4636 if self.end_id != 0 {
4637 len += 1;
4638 }
4639 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsResponse", len)?;
4640 if let Some(v) = self.status.as_ref() {
4641 struct_ser.serialize_field("status", v)?;
4642 }
4643 if self.start_id != 0 {
4644 #[allow(clippy::needless_borrow)]
4645 #[allow(clippy::needless_borrows_for_generic_args)]
4646 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
4647 }
4648 if self.end_id != 0 {
4649 #[allow(clippy::needless_borrow)]
4650 #[allow(clippy::needless_borrows_for_generic_args)]
4651 struct_ser.serialize_field("endId", ToString::to_string(&self.end_id).as_str())?;
4652 }
4653 struct_ser.end()
4654 }
4655}
4656impl<'de> serde::Deserialize<'de> for GetNewObjectIdsResponse {
4657 #[allow(deprecated)]
4658 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4659 where
4660 D: serde::Deserializer<'de>,
4661 {
4662 const FIELDS: &[&str] = &[
4663 "status",
4664 "start_id",
4665 "startId",
4666 "end_id",
4667 "endId",
4668 ];
4669
4670 #[allow(clippy::enum_variant_names)]
4671 enum GeneratedField {
4672 Status,
4673 StartId,
4674 EndId,
4675 }
4676 impl<'de> serde::Deserialize<'de> for GeneratedField {
4677 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4678 where
4679 D: serde::Deserializer<'de>,
4680 {
4681 struct GeneratedVisitor;
4682
4683 impl serde::de::Visitor<'_> for GeneratedVisitor {
4684 type Value = GeneratedField;
4685
4686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4687 write!(formatter, "expected one of: {:?}", &FIELDS)
4688 }
4689
4690 #[allow(unused_variables)]
4691 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4692 where
4693 E: serde::de::Error,
4694 {
4695 match value {
4696 "status" => Ok(GeneratedField::Status),
4697 "startId" | "start_id" => Ok(GeneratedField::StartId),
4698 "endId" | "end_id" => Ok(GeneratedField::EndId),
4699 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4700 }
4701 }
4702 }
4703 deserializer.deserialize_identifier(GeneratedVisitor)
4704 }
4705 }
4706 struct GeneratedVisitor;
4707 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4708 type Value = GetNewObjectIdsResponse;
4709
4710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4711 formatter.write_str("struct hummock.GetNewObjectIdsResponse")
4712 }
4713
4714 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsResponse, V::Error>
4715 where
4716 V: serde::de::MapAccess<'de>,
4717 {
4718 let mut status__ = None;
4719 let mut start_id__ = None;
4720 let mut end_id__ = None;
4721 while let Some(k) = map_.next_key()? {
4722 match k {
4723 GeneratedField::Status => {
4724 if status__.is_some() {
4725 return Err(serde::de::Error::duplicate_field("status"));
4726 }
4727 status__ = map_.next_value()?;
4728 }
4729 GeneratedField::StartId => {
4730 if start_id__.is_some() {
4731 return Err(serde::de::Error::duplicate_field("startId"));
4732 }
4733 start_id__ =
4734 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4735 ;
4736 }
4737 GeneratedField::EndId => {
4738 if end_id__.is_some() {
4739 return Err(serde::de::Error::duplicate_field("endId"));
4740 }
4741 end_id__ =
4742 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4743 ;
4744 }
4745 }
4746 }
4747 Ok(GetNewObjectIdsResponse {
4748 status: status__,
4749 start_id: start_id__.unwrap_or_default(),
4750 end_id: end_id__.unwrap_or_default(),
4751 })
4752 }
4753 }
4754 deserializer.deserialize_struct("hummock.GetNewObjectIdsResponse", FIELDS, GeneratedVisitor)
4755 }
4756}
4757impl serde::Serialize for GetTableChangeLogsRequest {
4758 #[allow(deprecated)]
4759 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4760 where
4761 S: serde::Serializer,
4762 {
4763 use serde::ser::SerializeStruct;
4764 let mut len = 0;
4765 if self.epoch_only {
4766 len += 1;
4767 }
4768 if self.exclude_empty {
4769 len += 1;
4770 }
4771 if self.start_epoch_inclusive.is_some() {
4772 len += 1;
4773 }
4774 if self.end_epoch_inclusive.is_some() {
4775 len += 1;
4776 }
4777 if self.table_ids.is_some() {
4778 len += 1;
4779 }
4780 if self.limit.is_some() {
4781 len += 1;
4782 }
4783 let mut struct_ser = serializer.serialize_struct("hummock.GetTableChangeLogsRequest", len)?;
4784 if self.epoch_only {
4785 struct_ser.serialize_field("epochOnly", &self.epoch_only)?;
4786 }
4787 if self.exclude_empty {
4788 struct_ser.serialize_field("excludeEmpty", &self.exclude_empty)?;
4789 }
4790 if let Some(v) = self.start_epoch_inclusive.as_ref() {
4791 #[allow(clippy::needless_borrow)]
4792 #[allow(clippy::needless_borrows_for_generic_args)]
4793 struct_ser.serialize_field("startEpochInclusive", ToString::to_string(&v).as_str())?;
4794 }
4795 if let Some(v) = self.end_epoch_inclusive.as_ref() {
4796 #[allow(clippy::needless_borrow)]
4797 #[allow(clippy::needless_borrows_for_generic_args)]
4798 struct_ser.serialize_field("endEpochInclusive", ToString::to_string(&v).as_str())?;
4799 }
4800 if let Some(v) = self.table_ids.as_ref() {
4801 struct_ser.serialize_field("tableIds", v)?;
4802 }
4803 if let Some(v) = self.limit.as_ref() {
4804 struct_ser.serialize_field("limit", v)?;
4805 }
4806 struct_ser.end()
4807 }
4808}
4809impl<'de> serde::Deserialize<'de> for GetTableChangeLogsRequest {
4810 #[allow(deprecated)]
4811 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4812 where
4813 D: serde::Deserializer<'de>,
4814 {
4815 const FIELDS: &[&str] = &[
4816 "epoch_only",
4817 "epochOnly",
4818 "exclude_empty",
4819 "excludeEmpty",
4820 "start_epoch_inclusive",
4821 "startEpochInclusive",
4822 "end_epoch_inclusive",
4823 "endEpochInclusive",
4824 "table_ids",
4825 "tableIds",
4826 "limit",
4827 ];
4828
4829 #[allow(clippy::enum_variant_names)]
4830 enum GeneratedField {
4831 EpochOnly,
4832 ExcludeEmpty,
4833 StartEpochInclusive,
4834 EndEpochInclusive,
4835 TableIds,
4836 Limit,
4837 }
4838 impl<'de> serde::Deserialize<'de> for GeneratedField {
4839 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4840 where
4841 D: serde::Deserializer<'de>,
4842 {
4843 struct GeneratedVisitor;
4844
4845 impl serde::de::Visitor<'_> for GeneratedVisitor {
4846 type Value = GeneratedField;
4847
4848 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4849 write!(formatter, "expected one of: {:?}", &FIELDS)
4850 }
4851
4852 #[allow(unused_variables)]
4853 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4854 where
4855 E: serde::de::Error,
4856 {
4857 match value {
4858 "epochOnly" | "epoch_only" => Ok(GeneratedField::EpochOnly),
4859 "excludeEmpty" | "exclude_empty" => Ok(GeneratedField::ExcludeEmpty),
4860 "startEpochInclusive" | "start_epoch_inclusive" => Ok(GeneratedField::StartEpochInclusive),
4861 "endEpochInclusive" | "end_epoch_inclusive" => Ok(GeneratedField::EndEpochInclusive),
4862 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4863 "limit" => Ok(GeneratedField::Limit),
4864 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4865 }
4866 }
4867 }
4868 deserializer.deserialize_identifier(GeneratedVisitor)
4869 }
4870 }
4871 struct GeneratedVisitor;
4872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4873 type Value = GetTableChangeLogsRequest;
4874
4875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4876 formatter.write_str("struct hummock.GetTableChangeLogsRequest")
4877 }
4878
4879 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableChangeLogsRequest, V::Error>
4880 where
4881 V: serde::de::MapAccess<'de>,
4882 {
4883 let mut epoch_only__ = None;
4884 let mut exclude_empty__ = None;
4885 let mut start_epoch_inclusive__ = None;
4886 let mut end_epoch_inclusive__ = None;
4887 let mut table_ids__ = None;
4888 let mut limit__ = None;
4889 while let Some(k) = map_.next_key()? {
4890 match k {
4891 GeneratedField::EpochOnly => {
4892 if epoch_only__.is_some() {
4893 return Err(serde::de::Error::duplicate_field("epochOnly"));
4894 }
4895 epoch_only__ = Some(map_.next_value()?);
4896 }
4897 GeneratedField::ExcludeEmpty => {
4898 if exclude_empty__.is_some() {
4899 return Err(serde::de::Error::duplicate_field("excludeEmpty"));
4900 }
4901 exclude_empty__ = Some(map_.next_value()?);
4902 }
4903 GeneratedField::StartEpochInclusive => {
4904 if start_epoch_inclusive__.is_some() {
4905 return Err(serde::de::Error::duplicate_field("startEpochInclusive"));
4906 }
4907 start_epoch_inclusive__ =
4908 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4909 ;
4910 }
4911 GeneratedField::EndEpochInclusive => {
4912 if end_epoch_inclusive__.is_some() {
4913 return Err(serde::de::Error::duplicate_field("endEpochInclusive"));
4914 }
4915 end_epoch_inclusive__ =
4916 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4917 ;
4918 }
4919 GeneratedField::TableIds => {
4920 if table_ids__.is_some() {
4921 return Err(serde::de::Error::duplicate_field("tableIds"));
4922 }
4923 table_ids__ = map_.next_value()?;
4924 }
4925 GeneratedField::Limit => {
4926 if limit__.is_some() {
4927 return Err(serde::de::Error::duplicate_field("limit"));
4928 }
4929 limit__ =
4930 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4931 ;
4932 }
4933 }
4934 }
4935 Ok(GetTableChangeLogsRequest {
4936 epoch_only: epoch_only__.unwrap_or_default(),
4937 exclude_empty: exclude_empty__.unwrap_or_default(),
4938 start_epoch_inclusive: start_epoch_inclusive__,
4939 end_epoch_inclusive: end_epoch_inclusive__,
4940 table_ids: table_ids__,
4941 limit: limit__,
4942 })
4943 }
4944 }
4945 deserializer.deserialize_struct("hummock.GetTableChangeLogsRequest", FIELDS, GeneratedVisitor)
4946 }
4947}
4948impl serde::Serialize for get_table_change_logs_request::TableFilter {
4949 #[allow(deprecated)]
4950 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4951 where
4952 S: serde::Serializer,
4953 {
4954 use serde::ser::SerializeStruct;
4955 let mut len = 0;
4956 if !self.table_ids.is_empty() {
4957 len += 1;
4958 }
4959 let mut struct_ser = serializer.serialize_struct("hummock.GetTableChangeLogsRequest.TableFilter", len)?;
4960 if !self.table_ids.is_empty() {
4961 struct_ser.serialize_field("tableIds", &self.table_ids)?;
4962 }
4963 struct_ser.end()
4964 }
4965}
4966impl<'de> serde::Deserialize<'de> for get_table_change_logs_request::TableFilter {
4967 #[allow(deprecated)]
4968 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4969 where
4970 D: serde::Deserializer<'de>,
4971 {
4972 const FIELDS: &[&str] = &[
4973 "table_ids",
4974 "tableIds",
4975 ];
4976
4977 #[allow(clippy::enum_variant_names)]
4978 enum GeneratedField {
4979 TableIds,
4980 }
4981 impl<'de> serde::Deserialize<'de> for GeneratedField {
4982 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4983 where
4984 D: serde::Deserializer<'de>,
4985 {
4986 struct GeneratedVisitor;
4987
4988 impl serde::de::Visitor<'_> for GeneratedVisitor {
4989 type Value = GeneratedField;
4990
4991 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4992 write!(formatter, "expected one of: {:?}", &FIELDS)
4993 }
4994
4995 #[allow(unused_variables)]
4996 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4997 where
4998 E: serde::de::Error,
4999 {
5000 match value {
5001 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
5002 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5003 }
5004 }
5005 }
5006 deserializer.deserialize_identifier(GeneratedVisitor)
5007 }
5008 }
5009 struct GeneratedVisitor;
5010 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5011 type Value = get_table_change_logs_request::TableFilter;
5012
5013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5014 formatter.write_str("struct hummock.GetTableChangeLogsRequest.TableFilter")
5015 }
5016
5017 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_table_change_logs_request::TableFilter, V::Error>
5018 where
5019 V: serde::de::MapAccess<'de>,
5020 {
5021 let mut table_ids__ = None;
5022 while let Some(k) = map_.next_key()? {
5023 match k {
5024 GeneratedField::TableIds => {
5025 if table_ids__.is_some() {
5026 return Err(serde::de::Error::duplicate_field("tableIds"));
5027 }
5028 table_ids__ =
5029 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5030 .into_iter().map(|x| x.0).collect())
5031 ;
5032 }
5033 }
5034 }
5035 Ok(get_table_change_logs_request::TableFilter {
5036 table_ids: table_ids__.unwrap_or_default(),
5037 })
5038 }
5039 }
5040 deserializer.deserialize_struct("hummock.GetTableChangeLogsRequest.TableFilter", FIELDS, GeneratedVisitor)
5041 }
5042}
5043impl serde::Serialize for GetTableChangeLogsResponse {
5044 #[allow(deprecated)]
5045 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5046 where
5047 S: serde::Serializer,
5048 {
5049 use serde::ser::SerializeStruct;
5050 let mut len = 0;
5051 if !self.table_change_logs.is_empty() {
5052 len += 1;
5053 }
5054 let mut struct_ser = serializer.serialize_struct("hummock.GetTableChangeLogsResponse", len)?;
5055 if !self.table_change_logs.is_empty() {
5056 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
5057 }
5058 struct_ser.end()
5059 }
5060}
5061impl<'de> serde::Deserialize<'de> for GetTableChangeLogsResponse {
5062 #[allow(deprecated)]
5063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5064 where
5065 D: serde::Deserializer<'de>,
5066 {
5067 const FIELDS: &[&str] = &[
5068 "table_change_logs",
5069 "tableChangeLogs",
5070 ];
5071
5072 #[allow(clippy::enum_variant_names)]
5073 enum GeneratedField {
5074 TableChangeLogs,
5075 }
5076 impl<'de> serde::Deserialize<'de> for GeneratedField {
5077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5078 where
5079 D: serde::Deserializer<'de>,
5080 {
5081 struct GeneratedVisitor;
5082
5083 impl serde::de::Visitor<'_> for GeneratedVisitor {
5084 type Value = GeneratedField;
5085
5086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5087 write!(formatter, "expected one of: {:?}", &FIELDS)
5088 }
5089
5090 #[allow(unused_variables)]
5091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5092 where
5093 E: serde::de::Error,
5094 {
5095 match value {
5096 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
5097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5098 }
5099 }
5100 }
5101 deserializer.deserialize_identifier(GeneratedVisitor)
5102 }
5103 }
5104 struct GeneratedVisitor;
5105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5106 type Value = GetTableChangeLogsResponse;
5107
5108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5109 formatter.write_str("struct hummock.GetTableChangeLogsResponse")
5110 }
5111
5112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableChangeLogsResponse, V::Error>
5113 where
5114 V: serde::de::MapAccess<'de>,
5115 {
5116 let mut table_change_logs__ = None;
5117 while let Some(k) = map_.next_key()? {
5118 match k {
5119 GeneratedField::TableChangeLogs => {
5120 if table_change_logs__.is_some() {
5121 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
5122 }
5123 table_change_logs__ = Some(
5124 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5125 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5126 );
5127 }
5128 }
5129 }
5130 Ok(GetTableChangeLogsResponse {
5131 table_change_logs: table_change_logs__.unwrap_or_default(),
5132 })
5133 }
5134 }
5135 deserializer.deserialize_struct("hummock.GetTableChangeLogsResponse", FIELDS, GeneratedVisitor)
5136 }
5137}
5138impl serde::Serialize for GetVersionByEpochRequest {
5139 #[allow(deprecated)]
5140 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5141 where
5142 S: serde::Serializer,
5143 {
5144 use serde::ser::SerializeStruct;
5145 let mut len = 0;
5146 if self.epoch != 0 {
5147 len += 1;
5148 }
5149 if self.table_id != 0 {
5150 len += 1;
5151 }
5152 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochRequest", len)?;
5153 if self.epoch != 0 {
5154 #[allow(clippy::needless_borrow)]
5155 #[allow(clippy::needless_borrows_for_generic_args)]
5156 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
5157 }
5158 if self.table_id != 0 {
5159 struct_ser.serialize_field("tableId", &self.table_id)?;
5160 }
5161 struct_ser.end()
5162 }
5163}
5164impl<'de> serde::Deserialize<'de> for GetVersionByEpochRequest {
5165 #[allow(deprecated)]
5166 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5167 where
5168 D: serde::Deserializer<'de>,
5169 {
5170 const FIELDS: &[&str] = &[
5171 "epoch",
5172 "table_id",
5173 "tableId",
5174 ];
5175
5176 #[allow(clippy::enum_variant_names)]
5177 enum GeneratedField {
5178 Epoch,
5179 TableId,
5180 }
5181 impl<'de> serde::Deserialize<'de> for GeneratedField {
5182 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5183 where
5184 D: serde::Deserializer<'de>,
5185 {
5186 struct GeneratedVisitor;
5187
5188 impl serde::de::Visitor<'_> for GeneratedVisitor {
5189 type Value = GeneratedField;
5190
5191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5192 write!(formatter, "expected one of: {:?}", &FIELDS)
5193 }
5194
5195 #[allow(unused_variables)]
5196 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5197 where
5198 E: serde::de::Error,
5199 {
5200 match value {
5201 "epoch" => Ok(GeneratedField::Epoch),
5202 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5203 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5204 }
5205 }
5206 }
5207 deserializer.deserialize_identifier(GeneratedVisitor)
5208 }
5209 }
5210 struct GeneratedVisitor;
5211 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5212 type Value = GetVersionByEpochRequest;
5213
5214 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5215 formatter.write_str("struct hummock.GetVersionByEpochRequest")
5216 }
5217
5218 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochRequest, V::Error>
5219 where
5220 V: serde::de::MapAccess<'de>,
5221 {
5222 let mut epoch__ = None;
5223 let mut table_id__ = None;
5224 while let Some(k) = map_.next_key()? {
5225 match k {
5226 GeneratedField::Epoch => {
5227 if epoch__.is_some() {
5228 return Err(serde::de::Error::duplicate_field("epoch"));
5229 }
5230 epoch__ =
5231 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5232 ;
5233 }
5234 GeneratedField::TableId => {
5235 if table_id__.is_some() {
5236 return Err(serde::de::Error::duplicate_field("tableId"));
5237 }
5238 table_id__ =
5239 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5240 ;
5241 }
5242 }
5243 }
5244 Ok(GetVersionByEpochRequest {
5245 epoch: epoch__.unwrap_or_default(),
5246 table_id: table_id__.unwrap_or_default(),
5247 })
5248 }
5249 }
5250 deserializer.deserialize_struct("hummock.GetVersionByEpochRequest", FIELDS, GeneratedVisitor)
5251 }
5252}
5253impl serde::Serialize for GetVersionByEpochResponse {
5254 #[allow(deprecated)]
5255 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5256 where
5257 S: serde::Serializer,
5258 {
5259 use serde::ser::SerializeStruct;
5260 let mut len = 0;
5261 if self.version.is_some() {
5262 len += 1;
5263 }
5264 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochResponse", len)?;
5265 if let Some(v) = self.version.as_ref() {
5266 struct_ser.serialize_field("version", v)?;
5267 }
5268 struct_ser.end()
5269 }
5270}
5271impl<'de> serde::Deserialize<'de> for GetVersionByEpochResponse {
5272 #[allow(deprecated)]
5273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5274 where
5275 D: serde::Deserializer<'de>,
5276 {
5277 const FIELDS: &[&str] = &[
5278 "version",
5279 ];
5280
5281 #[allow(clippy::enum_variant_names)]
5282 enum GeneratedField {
5283 Version,
5284 }
5285 impl<'de> serde::Deserialize<'de> for GeneratedField {
5286 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5287 where
5288 D: serde::Deserializer<'de>,
5289 {
5290 struct GeneratedVisitor;
5291
5292 impl serde::de::Visitor<'_> for GeneratedVisitor {
5293 type Value = GeneratedField;
5294
5295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5296 write!(formatter, "expected one of: {:?}", &FIELDS)
5297 }
5298
5299 #[allow(unused_variables)]
5300 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5301 where
5302 E: serde::de::Error,
5303 {
5304 match value {
5305 "version" => Ok(GeneratedField::Version),
5306 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5307 }
5308 }
5309 }
5310 deserializer.deserialize_identifier(GeneratedVisitor)
5311 }
5312 }
5313 struct GeneratedVisitor;
5314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5315 type Value = GetVersionByEpochResponse;
5316
5317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5318 formatter.write_str("struct hummock.GetVersionByEpochResponse")
5319 }
5320
5321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochResponse, V::Error>
5322 where
5323 V: serde::de::MapAccess<'de>,
5324 {
5325 let mut version__ = None;
5326 while let Some(k) = map_.next_key()? {
5327 match k {
5328 GeneratedField::Version => {
5329 if version__.is_some() {
5330 return Err(serde::de::Error::duplicate_field("version"));
5331 }
5332 version__ = map_.next_value()?;
5333 }
5334 }
5335 }
5336 Ok(GetVersionByEpochResponse {
5337 version: version__,
5338 })
5339 }
5340 }
5341 deserializer.deserialize_struct("hummock.GetVersionByEpochResponse", FIELDS, GeneratedVisitor)
5342 }
5343}
5344impl serde::Serialize for GroupConstruct {
5345 #[allow(deprecated)]
5346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5347 where
5348 S: serde::Serializer,
5349 {
5350 use serde::ser::SerializeStruct;
5351 let mut len = 0;
5352 if self.group_config.is_some() {
5353 len += 1;
5354 }
5355 if self.parent_group_id != 0 {
5356 len += 1;
5357 }
5358 if !self.table_ids.is_empty() {
5359 len += 1;
5360 }
5361 if self.group_id != 0 {
5362 len += 1;
5363 }
5364 if self.new_sst_start_id != 0 {
5365 len += 1;
5366 }
5367 if self.version != 0 {
5368 len += 1;
5369 }
5370 if self.split_key.is_some() {
5371 len += 1;
5372 }
5373 let mut struct_ser = serializer.serialize_struct("hummock.GroupConstruct", len)?;
5374 if let Some(v) = self.group_config.as_ref() {
5375 struct_ser.serialize_field("groupConfig", v)?;
5376 }
5377 if self.parent_group_id != 0 {
5378 #[allow(clippy::needless_borrow)]
5379 #[allow(clippy::needless_borrows_for_generic_args)]
5380 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
5381 }
5382 if !self.table_ids.is_empty() {
5383 struct_ser.serialize_field("tableIds", &self.table_ids)?;
5384 }
5385 if self.group_id != 0 {
5386 #[allow(clippy::needless_borrow)]
5387 #[allow(clippy::needless_borrows_for_generic_args)]
5388 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
5389 }
5390 if self.new_sst_start_id != 0 {
5391 #[allow(clippy::needless_borrow)]
5392 #[allow(clippy::needless_borrows_for_generic_args)]
5393 struct_ser.serialize_field("newSstStartId", ToString::to_string(&self.new_sst_start_id).as_str())?;
5394 }
5395 if self.version != 0 {
5396 let v = CompatibilityVersion::try_from(self.version)
5397 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5398 struct_ser.serialize_field("version", &v)?;
5399 }
5400 if let Some(v) = self.split_key.as_ref() {
5401 #[allow(clippy::needless_borrow)]
5402 #[allow(clippy::needless_borrows_for_generic_args)]
5403 struct_ser.serialize_field("splitKey", pbjson::private::base64::encode(&v).as_str())?;
5404 }
5405 struct_ser.end()
5406 }
5407}
5408impl<'de> serde::Deserialize<'de> for GroupConstruct {
5409 #[allow(deprecated)]
5410 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5411 where
5412 D: serde::Deserializer<'de>,
5413 {
5414 const FIELDS: &[&str] = &[
5415 "group_config",
5416 "groupConfig",
5417 "parent_group_id",
5418 "parentGroupId",
5419 "table_ids",
5420 "tableIds",
5421 "group_id",
5422 "groupId",
5423 "new_sst_start_id",
5424 "newSstStartId",
5425 "version",
5426 "split_key",
5427 "splitKey",
5428 ];
5429
5430 #[allow(clippy::enum_variant_names)]
5431 enum GeneratedField {
5432 GroupConfig,
5433 ParentGroupId,
5434 TableIds,
5435 GroupId,
5436 NewSstStartId,
5437 Version,
5438 SplitKey,
5439 }
5440 impl<'de> serde::Deserialize<'de> for GeneratedField {
5441 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5442 where
5443 D: serde::Deserializer<'de>,
5444 {
5445 struct GeneratedVisitor;
5446
5447 impl serde::de::Visitor<'_> for GeneratedVisitor {
5448 type Value = GeneratedField;
5449
5450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5451 write!(formatter, "expected one of: {:?}", &FIELDS)
5452 }
5453
5454 #[allow(unused_variables)]
5455 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5456 where
5457 E: serde::de::Error,
5458 {
5459 match value {
5460 "groupConfig" | "group_config" => Ok(GeneratedField::GroupConfig),
5461 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
5462 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
5463 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
5464 "newSstStartId" | "new_sst_start_id" => Ok(GeneratedField::NewSstStartId),
5465 "version" => Ok(GeneratedField::Version),
5466 "splitKey" | "split_key" => Ok(GeneratedField::SplitKey),
5467 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5468 }
5469 }
5470 }
5471 deserializer.deserialize_identifier(GeneratedVisitor)
5472 }
5473 }
5474 struct GeneratedVisitor;
5475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5476 type Value = GroupConstruct;
5477
5478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5479 formatter.write_str("struct hummock.GroupConstruct")
5480 }
5481
5482 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupConstruct, V::Error>
5483 where
5484 V: serde::de::MapAccess<'de>,
5485 {
5486 let mut group_config__ = None;
5487 let mut parent_group_id__ = None;
5488 let mut table_ids__ = None;
5489 let mut group_id__ = None;
5490 let mut new_sst_start_id__ = None;
5491 let mut version__ = None;
5492 let mut split_key__ = None;
5493 while let Some(k) = map_.next_key()? {
5494 match k {
5495 GeneratedField::GroupConfig => {
5496 if group_config__.is_some() {
5497 return Err(serde::de::Error::duplicate_field("groupConfig"));
5498 }
5499 group_config__ = map_.next_value()?;
5500 }
5501 GeneratedField::ParentGroupId => {
5502 if parent_group_id__.is_some() {
5503 return Err(serde::de::Error::duplicate_field("parentGroupId"));
5504 }
5505 parent_group_id__ =
5506 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5507 ;
5508 }
5509 GeneratedField::TableIds => {
5510 if table_ids__.is_some() {
5511 return Err(serde::de::Error::duplicate_field("tableIds"));
5512 }
5513 table_ids__ =
5514 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5515 .into_iter().map(|x| x.0).collect())
5516 ;
5517 }
5518 GeneratedField::GroupId => {
5519 if group_id__.is_some() {
5520 return Err(serde::de::Error::duplicate_field("groupId"));
5521 }
5522 group_id__ =
5523 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5524 ;
5525 }
5526 GeneratedField::NewSstStartId => {
5527 if new_sst_start_id__.is_some() {
5528 return Err(serde::de::Error::duplicate_field("newSstStartId"));
5529 }
5530 new_sst_start_id__ =
5531 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5532 ;
5533 }
5534 GeneratedField::Version => {
5535 if version__.is_some() {
5536 return Err(serde::de::Error::duplicate_field("version"));
5537 }
5538 version__ = Some(map_.next_value::<CompatibilityVersion>()? as i32);
5539 }
5540 GeneratedField::SplitKey => {
5541 if split_key__.is_some() {
5542 return Err(serde::de::Error::duplicate_field("splitKey"));
5543 }
5544 split_key__ =
5545 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
5546 ;
5547 }
5548 }
5549 }
5550 Ok(GroupConstruct {
5551 group_config: group_config__,
5552 parent_group_id: parent_group_id__.unwrap_or_default(),
5553 table_ids: table_ids__.unwrap_or_default(),
5554 group_id: group_id__.unwrap_or_default(),
5555 new_sst_start_id: new_sst_start_id__.unwrap_or_default(),
5556 version: version__.unwrap_or_default(),
5557 split_key: split_key__,
5558 })
5559 }
5560 }
5561 deserializer.deserialize_struct("hummock.GroupConstruct", FIELDS, GeneratedVisitor)
5562 }
5563}
5564impl serde::Serialize for GroupDelta {
5565 #[allow(deprecated)]
5566 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5567 where
5568 S: serde::Serializer,
5569 {
5570 use serde::ser::SerializeStruct;
5571 let mut len = 0;
5572 if self.delta_type.is_some() {
5573 len += 1;
5574 }
5575 let mut struct_ser = serializer.serialize_struct("hummock.GroupDelta", len)?;
5576 if let Some(v) = self.delta_type.as_ref() {
5577 match v {
5578 group_delta::DeltaType::IntraLevel(v) => {
5579 struct_ser.serialize_field("intraLevel", v)?;
5580 }
5581 group_delta::DeltaType::GroupConstruct(v) => {
5582 struct_ser.serialize_field("groupConstruct", v)?;
5583 }
5584 group_delta::DeltaType::GroupDestroy(v) => {
5585 struct_ser.serialize_field("groupDestroy", v)?;
5586 }
5587 group_delta::DeltaType::GroupMerge(v) => {
5588 struct_ser.serialize_field("groupMerge", v)?;
5589 }
5590 group_delta::DeltaType::NewL0SubLevel(v) => {
5591 struct_ser.serialize_field("newL0SubLevel", v)?;
5592 }
5593 group_delta::DeltaType::TruncateTables(v) => {
5594 struct_ser.serialize_field("truncateTables", v)?;
5595 }
5596 }
5597 }
5598 struct_ser.end()
5599 }
5600}
5601impl<'de> serde::Deserialize<'de> for GroupDelta {
5602 #[allow(deprecated)]
5603 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5604 where
5605 D: serde::Deserializer<'de>,
5606 {
5607 const FIELDS: &[&str] = &[
5608 "intra_level",
5609 "intraLevel",
5610 "group_construct",
5611 "groupConstruct",
5612 "group_destroy",
5613 "groupDestroy",
5614 "group_merge",
5615 "groupMerge",
5616 "new_l0_sub_level",
5617 "newL0SubLevel",
5618 "truncate_tables",
5619 "truncateTables",
5620 ];
5621
5622 #[allow(clippy::enum_variant_names)]
5623 enum GeneratedField {
5624 IntraLevel,
5625 GroupConstruct,
5626 GroupDestroy,
5627 GroupMerge,
5628 NewL0SubLevel,
5629 TruncateTables,
5630 }
5631 impl<'de> serde::Deserialize<'de> for GeneratedField {
5632 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5633 where
5634 D: serde::Deserializer<'de>,
5635 {
5636 struct GeneratedVisitor;
5637
5638 impl serde::de::Visitor<'_> for GeneratedVisitor {
5639 type Value = GeneratedField;
5640
5641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5642 write!(formatter, "expected one of: {:?}", &FIELDS)
5643 }
5644
5645 #[allow(unused_variables)]
5646 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5647 where
5648 E: serde::de::Error,
5649 {
5650 match value {
5651 "intraLevel" | "intra_level" => Ok(GeneratedField::IntraLevel),
5652 "groupConstruct" | "group_construct" => Ok(GeneratedField::GroupConstruct),
5653 "groupDestroy" | "group_destroy" => Ok(GeneratedField::GroupDestroy),
5654 "groupMerge" | "group_merge" => Ok(GeneratedField::GroupMerge),
5655 "newL0SubLevel" | "new_l0_sub_level" => Ok(GeneratedField::NewL0SubLevel),
5656 "truncateTables" | "truncate_tables" => Ok(GeneratedField::TruncateTables),
5657 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5658 }
5659 }
5660 }
5661 deserializer.deserialize_identifier(GeneratedVisitor)
5662 }
5663 }
5664 struct GeneratedVisitor;
5665 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5666 type Value = GroupDelta;
5667
5668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5669 formatter.write_str("struct hummock.GroupDelta")
5670 }
5671
5672 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDelta, V::Error>
5673 where
5674 V: serde::de::MapAccess<'de>,
5675 {
5676 let mut delta_type__ = None;
5677 while let Some(k) = map_.next_key()? {
5678 match k {
5679 GeneratedField::IntraLevel => {
5680 if delta_type__.is_some() {
5681 return Err(serde::de::Error::duplicate_field("intraLevel"));
5682 }
5683 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::IntraLevel)
5684;
5685 }
5686 GeneratedField::GroupConstruct => {
5687 if delta_type__.is_some() {
5688 return Err(serde::de::Error::duplicate_field("groupConstruct"));
5689 }
5690 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupConstruct)
5691;
5692 }
5693 GeneratedField::GroupDestroy => {
5694 if delta_type__.is_some() {
5695 return Err(serde::de::Error::duplicate_field("groupDestroy"));
5696 }
5697 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupDestroy)
5698;
5699 }
5700 GeneratedField::GroupMerge => {
5701 if delta_type__.is_some() {
5702 return Err(serde::de::Error::duplicate_field("groupMerge"));
5703 }
5704 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupMerge)
5705;
5706 }
5707 GeneratedField::NewL0SubLevel => {
5708 if delta_type__.is_some() {
5709 return Err(serde::de::Error::duplicate_field("newL0SubLevel"));
5710 }
5711 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::NewL0SubLevel)
5712;
5713 }
5714 GeneratedField::TruncateTables => {
5715 if delta_type__.is_some() {
5716 return Err(serde::de::Error::duplicate_field("truncateTables"));
5717 }
5718 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::TruncateTables)
5719;
5720 }
5721 }
5722 }
5723 Ok(GroupDelta {
5724 delta_type: delta_type__,
5725 })
5726 }
5727 }
5728 deserializer.deserialize_struct("hummock.GroupDelta", FIELDS, GeneratedVisitor)
5729 }
5730}
5731impl serde::Serialize for GroupDestroy {
5732 #[allow(deprecated)]
5733 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5734 where
5735 S: serde::Serializer,
5736 {
5737 use serde::ser::SerializeStruct;
5738 let len = 0;
5739 let struct_ser = serializer.serialize_struct("hummock.GroupDestroy", len)?;
5740 struct_ser.end()
5741 }
5742}
5743impl<'de> serde::Deserialize<'de> for GroupDestroy {
5744 #[allow(deprecated)]
5745 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5746 where
5747 D: serde::Deserializer<'de>,
5748 {
5749 const FIELDS: &[&str] = &[
5750 ];
5751
5752 #[allow(clippy::enum_variant_names)]
5753 enum GeneratedField {
5754 }
5755 impl<'de> serde::Deserialize<'de> for GeneratedField {
5756 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5757 where
5758 D: serde::Deserializer<'de>,
5759 {
5760 struct GeneratedVisitor;
5761
5762 impl serde::de::Visitor<'_> for GeneratedVisitor {
5763 type Value = GeneratedField;
5764
5765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5766 write!(formatter, "expected one of: {:?}", &FIELDS)
5767 }
5768
5769 #[allow(unused_variables)]
5770 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5771 where
5772 E: serde::de::Error,
5773 {
5774 Err(serde::de::Error::unknown_field(value, FIELDS))
5775 }
5776 }
5777 deserializer.deserialize_identifier(GeneratedVisitor)
5778 }
5779 }
5780 struct GeneratedVisitor;
5781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5782 type Value = GroupDestroy;
5783
5784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5785 formatter.write_str("struct hummock.GroupDestroy")
5786 }
5787
5788 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDestroy, V::Error>
5789 where
5790 V: serde::de::MapAccess<'de>,
5791 {
5792 while map_.next_key::<GeneratedField>()?.is_some() {
5793 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5794 }
5795 Ok(GroupDestroy {
5796 })
5797 }
5798 }
5799 deserializer.deserialize_struct("hummock.GroupDestroy", FIELDS, GeneratedVisitor)
5800 }
5801}
5802impl serde::Serialize for GroupMerge {
5803 #[allow(deprecated)]
5804 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5805 where
5806 S: serde::Serializer,
5807 {
5808 use serde::ser::SerializeStruct;
5809 let mut len = 0;
5810 if self.left_group_id != 0 {
5811 len += 1;
5812 }
5813 if self.right_group_id != 0 {
5814 len += 1;
5815 }
5816 let mut struct_ser = serializer.serialize_struct("hummock.GroupMerge", len)?;
5817 if self.left_group_id != 0 {
5818 #[allow(clippy::needless_borrow)]
5819 #[allow(clippy::needless_borrows_for_generic_args)]
5820 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
5821 }
5822 if self.right_group_id != 0 {
5823 #[allow(clippy::needless_borrow)]
5824 #[allow(clippy::needless_borrows_for_generic_args)]
5825 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
5826 }
5827 struct_ser.end()
5828 }
5829}
5830impl<'de> serde::Deserialize<'de> for GroupMerge {
5831 #[allow(deprecated)]
5832 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5833 where
5834 D: serde::Deserializer<'de>,
5835 {
5836 const FIELDS: &[&str] = &[
5837 "left_group_id",
5838 "leftGroupId",
5839 "right_group_id",
5840 "rightGroupId",
5841 ];
5842
5843 #[allow(clippy::enum_variant_names)]
5844 enum GeneratedField {
5845 LeftGroupId,
5846 RightGroupId,
5847 }
5848 impl<'de> serde::Deserialize<'de> for GeneratedField {
5849 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5850 where
5851 D: serde::Deserializer<'de>,
5852 {
5853 struct GeneratedVisitor;
5854
5855 impl serde::de::Visitor<'_> for GeneratedVisitor {
5856 type Value = GeneratedField;
5857
5858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5859 write!(formatter, "expected one of: {:?}", &FIELDS)
5860 }
5861
5862 #[allow(unused_variables)]
5863 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5864 where
5865 E: serde::de::Error,
5866 {
5867 match value {
5868 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
5869 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
5870 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5871 }
5872 }
5873 }
5874 deserializer.deserialize_identifier(GeneratedVisitor)
5875 }
5876 }
5877 struct GeneratedVisitor;
5878 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5879 type Value = GroupMerge;
5880
5881 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5882 formatter.write_str("struct hummock.GroupMerge")
5883 }
5884
5885 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupMerge, V::Error>
5886 where
5887 V: serde::de::MapAccess<'de>,
5888 {
5889 let mut left_group_id__ = None;
5890 let mut right_group_id__ = None;
5891 while let Some(k) = map_.next_key()? {
5892 match k {
5893 GeneratedField::LeftGroupId => {
5894 if left_group_id__.is_some() {
5895 return Err(serde::de::Error::duplicate_field("leftGroupId"));
5896 }
5897 left_group_id__ =
5898 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5899 ;
5900 }
5901 GeneratedField::RightGroupId => {
5902 if right_group_id__.is_some() {
5903 return Err(serde::de::Error::duplicate_field("rightGroupId"));
5904 }
5905 right_group_id__ =
5906 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5907 ;
5908 }
5909 }
5910 }
5911 Ok(GroupMerge {
5912 left_group_id: left_group_id__.unwrap_or_default(),
5913 right_group_id: right_group_id__.unwrap_or_default(),
5914 })
5915 }
5916 }
5917 deserializer.deserialize_struct("hummock.GroupMerge", FIELDS, GeneratedVisitor)
5918 }
5919}
5920impl serde::Serialize for HnswFlatIndex {
5921 #[allow(deprecated)]
5922 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5923 where
5924 S: serde::Serializer,
5925 {
5926 use serde::ser::SerializeStruct;
5927 let mut len = 0;
5928 if self.config.is_some() {
5929 len += 1;
5930 }
5931 if !self.vector_files.is_empty() {
5932 len += 1;
5933 }
5934 if self.next_vector_id != 0 {
5935 len += 1;
5936 }
5937 if self.graph_file.is_some() {
5938 len += 1;
5939 }
5940 let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndex", len)?;
5941 if let Some(v) = self.config.as_ref() {
5942 struct_ser.serialize_field("config", v)?;
5943 }
5944 if !self.vector_files.is_empty() {
5945 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
5946 }
5947 if self.next_vector_id != 0 {
5948 #[allow(clippy::needless_borrow)]
5949 #[allow(clippy::needless_borrows_for_generic_args)]
5950 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
5951 }
5952 if let Some(v) = self.graph_file.as_ref() {
5953 struct_ser.serialize_field("graphFile", v)?;
5954 }
5955 struct_ser.end()
5956 }
5957}
5958impl<'de> serde::Deserialize<'de> for HnswFlatIndex {
5959 #[allow(deprecated)]
5960 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5961 where
5962 D: serde::Deserializer<'de>,
5963 {
5964 const FIELDS: &[&str] = &[
5965 "config",
5966 "vector_files",
5967 "vectorFiles",
5968 "next_vector_id",
5969 "nextVectorId",
5970 "graph_file",
5971 "graphFile",
5972 ];
5973
5974 #[allow(clippy::enum_variant_names)]
5975 enum GeneratedField {
5976 Config,
5977 VectorFiles,
5978 NextVectorId,
5979 GraphFile,
5980 }
5981 impl<'de> serde::Deserialize<'de> for GeneratedField {
5982 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5983 where
5984 D: serde::Deserializer<'de>,
5985 {
5986 struct GeneratedVisitor;
5987
5988 impl serde::de::Visitor<'_> for GeneratedVisitor {
5989 type Value = GeneratedField;
5990
5991 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5992 write!(formatter, "expected one of: {:?}", &FIELDS)
5993 }
5994
5995 #[allow(unused_variables)]
5996 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5997 where
5998 E: serde::de::Error,
5999 {
6000 match value {
6001 "config" => Ok(GeneratedField::Config),
6002 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
6003 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
6004 "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
6005 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6006 }
6007 }
6008 }
6009 deserializer.deserialize_identifier(GeneratedVisitor)
6010 }
6011 }
6012 struct GeneratedVisitor;
6013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6014 type Value = HnswFlatIndex;
6015
6016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6017 formatter.write_str("struct hummock.HnswFlatIndex")
6018 }
6019
6020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndex, V::Error>
6021 where
6022 V: serde::de::MapAccess<'de>,
6023 {
6024 let mut config__ = None;
6025 let mut vector_files__ = None;
6026 let mut next_vector_id__ = None;
6027 let mut graph_file__ = None;
6028 while let Some(k) = map_.next_key()? {
6029 match k {
6030 GeneratedField::Config => {
6031 if config__.is_some() {
6032 return Err(serde::de::Error::duplicate_field("config"));
6033 }
6034 config__ = map_.next_value()?;
6035 }
6036 GeneratedField::VectorFiles => {
6037 if vector_files__.is_some() {
6038 return Err(serde::de::Error::duplicate_field("vectorFiles"));
6039 }
6040 vector_files__ = Some(map_.next_value()?);
6041 }
6042 GeneratedField::NextVectorId => {
6043 if next_vector_id__.is_some() {
6044 return Err(serde::de::Error::duplicate_field("nextVectorId"));
6045 }
6046 next_vector_id__ =
6047 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6048 ;
6049 }
6050 GeneratedField::GraphFile => {
6051 if graph_file__.is_some() {
6052 return Err(serde::de::Error::duplicate_field("graphFile"));
6053 }
6054 graph_file__ = map_.next_value()?;
6055 }
6056 }
6057 }
6058 Ok(HnswFlatIndex {
6059 config: config__,
6060 vector_files: vector_files__.unwrap_or_default(),
6061 next_vector_id: next_vector_id__.unwrap_or_default(),
6062 graph_file: graph_file__,
6063 })
6064 }
6065 }
6066 deserializer.deserialize_struct("hummock.HnswFlatIndex", FIELDS, GeneratedVisitor)
6067 }
6068}
6069impl serde::Serialize for HnswFlatIndexAdd {
6070 #[allow(deprecated)]
6071 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6072 where
6073 S: serde::Serializer,
6074 {
6075 use serde::ser::SerializeStruct;
6076 let mut len = 0;
6077 if !self.added_vector_files.is_empty() {
6078 len += 1;
6079 }
6080 if self.next_vector_id != 0 {
6081 len += 1;
6082 }
6083 if self.graph_file.is_some() {
6084 len += 1;
6085 }
6086 let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndexAdd", len)?;
6087 if !self.added_vector_files.is_empty() {
6088 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
6089 }
6090 if self.next_vector_id != 0 {
6091 #[allow(clippy::needless_borrow)]
6092 #[allow(clippy::needless_borrows_for_generic_args)]
6093 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
6094 }
6095 if let Some(v) = self.graph_file.as_ref() {
6096 struct_ser.serialize_field("graphFile", v)?;
6097 }
6098 struct_ser.end()
6099 }
6100}
6101impl<'de> serde::Deserialize<'de> for HnswFlatIndexAdd {
6102 #[allow(deprecated)]
6103 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6104 where
6105 D: serde::Deserializer<'de>,
6106 {
6107 const FIELDS: &[&str] = &[
6108 "added_vector_files",
6109 "addedVectorFiles",
6110 "next_vector_id",
6111 "nextVectorId",
6112 "graph_file",
6113 "graphFile",
6114 ];
6115
6116 #[allow(clippy::enum_variant_names)]
6117 enum GeneratedField {
6118 AddedVectorFiles,
6119 NextVectorId,
6120 GraphFile,
6121 }
6122 impl<'de> serde::Deserialize<'de> for GeneratedField {
6123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6124 where
6125 D: serde::Deserializer<'de>,
6126 {
6127 struct GeneratedVisitor;
6128
6129 impl serde::de::Visitor<'_> for GeneratedVisitor {
6130 type Value = GeneratedField;
6131
6132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6133 write!(formatter, "expected one of: {:?}", &FIELDS)
6134 }
6135
6136 #[allow(unused_variables)]
6137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6138 where
6139 E: serde::de::Error,
6140 {
6141 match value {
6142 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
6143 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
6144 "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
6145 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6146 }
6147 }
6148 }
6149 deserializer.deserialize_identifier(GeneratedVisitor)
6150 }
6151 }
6152 struct GeneratedVisitor;
6153 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6154 type Value = HnswFlatIndexAdd;
6155
6156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6157 formatter.write_str("struct hummock.HnswFlatIndexAdd")
6158 }
6159
6160 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndexAdd, V::Error>
6161 where
6162 V: serde::de::MapAccess<'de>,
6163 {
6164 let mut added_vector_files__ = None;
6165 let mut next_vector_id__ = None;
6166 let mut graph_file__ = None;
6167 while let Some(k) = map_.next_key()? {
6168 match k {
6169 GeneratedField::AddedVectorFiles => {
6170 if added_vector_files__.is_some() {
6171 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
6172 }
6173 added_vector_files__ = Some(map_.next_value()?);
6174 }
6175 GeneratedField::NextVectorId => {
6176 if next_vector_id__.is_some() {
6177 return Err(serde::de::Error::duplicate_field("nextVectorId"));
6178 }
6179 next_vector_id__ =
6180 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6181 ;
6182 }
6183 GeneratedField::GraphFile => {
6184 if graph_file__.is_some() {
6185 return Err(serde::de::Error::duplicate_field("graphFile"));
6186 }
6187 graph_file__ = map_.next_value()?;
6188 }
6189 }
6190 }
6191 Ok(HnswFlatIndexAdd {
6192 added_vector_files: added_vector_files__.unwrap_or_default(),
6193 next_vector_id: next_vector_id__.unwrap_or_default(),
6194 graph_file: graph_file__,
6195 })
6196 }
6197 }
6198 deserializer.deserialize_struct("hummock.HnswFlatIndexAdd", FIELDS, GeneratedVisitor)
6199 }
6200}
6201impl serde::Serialize for HnswGraph {
6202 #[allow(deprecated)]
6203 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6204 where
6205 S: serde::Serializer,
6206 {
6207 use serde::ser::SerializeStruct;
6208 let mut len = 0;
6209 if !self.nodes.is_empty() {
6210 len += 1;
6211 }
6212 if self.entrypoint_id != 0 {
6213 len += 1;
6214 }
6215 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph", len)?;
6216 if !self.nodes.is_empty() {
6217 struct_ser.serialize_field("nodes", &self.nodes)?;
6218 }
6219 if self.entrypoint_id != 0 {
6220 #[allow(clippy::needless_borrow)]
6221 #[allow(clippy::needless_borrows_for_generic_args)]
6222 struct_ser.serialize_field("entrypointId", ToString::to_string(&self.entrypoint_id).as_str())?;
6223 }
6224 struct_ser.end()
6225 }
6226}
6227impl<'de> serde::Deserialize<'de> for HnswGraph {
6228 #[allow(deprecated)]
6229 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6230 where
6231 D: serde::Deserializer<'de>,
6232 {
6233 const FIELDS: &[&str] = &[
6234 "nodes",
6235 "entrypoint_id",
6236 "entrypointId",
6237 ];
6238
6239 #[allow(clippy::enum_variant_names)]
6240 enum GeneratedField {
6241 Nodes,
6242 EntrypointId,
6243 }
6244 impl<'de> serde::Deserialize<'de> for GeneratedField {
6245 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6246 where
6247 D: serde::Deserializer<'de>,
6248 {
6249 struct GeneratedVisitor;
6250
6251 impl serde::de::Visitor<'_> for GeneratedVisitor {
6252 type Value = GeneratedField;
6253
6254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6255 write!(formatter, "expected one of: {:?}", &FIELDS)
6256 }
6257
6258 #[allow(unused_variables)]
6259 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6260 where
6261 E: serde::de::Error,
6262 {
6263 match value {
6264 "nodes" => Ok(GeneratedField::Nodes),
6265 "entrypointId" | "entrypoint_id" => Ok(GeneratedField::EntrypointId),
6266 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6267 }
6268 }
6269 }
6270 deserializer.deserialize_identifier(GeneratedVisitor)
6271 }
6272 }
6273 struct GeneratedVisitor;
6274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6275 type Value = HnswGraph;
6276
6277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6278 formatter.write_str("struct hummock.HnswGraph")
6279 }
6280
6281 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraph, V::Error>
6282 where
6283 V: serde::de::MapAccess<'de>,
6284 {
6285 let mut nodes__ = None;
6286 let mut entrypoint_id__ = None;
6287 while let Some(k) = map_.next_key()? {
6288 match k {
6289 GeneratedField::Nodes => {
6290 if nodes__.is_some() {
6291 return Err(serde::de::Error::duplicate_field("nodes"));
6292 }
6293 nodes__ = Some(map_.next_value()?);
6294 }
6295 GeneratedField::EntrypointId => {
6296 if entrypoint_id__.is_some() {
6297 return Err(serde::de::Error::duplicate_field("entrypointId"));
6298 }
6299 entrypoint_id__ =
6300 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6301 ;
6302 }
6303 }
6304 }
6305 Ok(HnswGraph {
6306 nodes: nodes__.unwrap_or_default(),
6307 entrypoint_id: entrypoint_id__.unwrap_or_default(),
6308 })
6309 }
6310 }
6311 deserializer.deserialize_struct("hummock.HnswGraph", FIELDS, GeneratedVisitor)
6312 }
6313}
6314impl serde::Serialize for hnsw_graph::HnswLevel {
6315 #[allow(deprecated)]
6316 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6317 where
6318 S: serde::Serializer,
6319 {
6320 use serde::ser::SerializeStruct;
6321 let mut len = 0;
6322 if !self.neighbors.is_empty() {
6323 len += 1;
6324 }
6325 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswLevel", len)?;
6326 if !self.neighbors.is_empty() {
6327 struct_ser.serialize_field("neighbors", &self.neighbors)?;
6328 }
6329 struct_ser.end()
6330 }
6331}
6332impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswLevel {
6333 #[allow(deprecated)]
6334 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6335 where
6336 D: serde::Deserializer<'de>,
6337 {
6338 const FIELDS: &[&str] = &[
6339 "neighbors",
6340 ];
6341
6342 #[allow(clippy::enum_variant_names)]
6343 enum GeneratedField {
6344 Neighbors,
6345 }
6346 impl<'de> serde::Deserialize<'de> for GeneratedField {
6347 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6348 where
6349 D: serde::Deserializer<'de>,
6350 {
6351 struct GeneratedVisitor;
6352
6353 impl serde::de::Visitor<'_> for GeneratedVisitor {
6354 type Value = GeneratedField;
6355
6356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6357 write!(formatter, "expected one of: {:?}", &FIELDS)
6358 }
6359
6360 #[allow(unused_variables)]
6361 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6362 where
6363 E: serde::de::Error,
6364 {
6365 match value {
6366 "neighbors" => Ok(GeneratedField::Neighbors),
6367 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6368 }
6369 }
6370 }
6371 deserializer.deserialize_identifier(GeneratedVisitor)
6372 }
6373 }
6374 struct GeneratedVisitor;
6375 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6376 type Value = hnsw_graph::HnswLevel;
6377
6378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6379 formatter.write_str("struct hummock.HnswGraph.HnswLevel")
6380 }
6381
6382 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswLevel, V::Error>
6383 where
6384 V: serde::de::MapAccess<'de>,
6385 {
6386 let mut neighbors__ = None;
6387 while let Some(k) = map_.next_key()? {
6388 match k {
6389 GeneratedField::Neighbors => {
6390 if neighbors__.is_some() {
6391 return Err(serde::de::Error::duplicate_field("neighbors"));
6392 }
6393 neighbors__ = Some(map_.next_value()?);
6394 }
6395 }
6396 }
6397 Ok(hnsw_graph::HnswLevel {
6398 neighbors: neighbors__.unwrap_or_default(),
6399 })
6400 }
6401 }
6402 deserializer.deserialize_struct("hummock.HnswGraph.HnswLevel", FIELDS, GeneratedVisitor)
6403 }
6404}
6405impl serde::Serialize for hnsw_graph::HnswNeighbor {
6406 #[allow(deprecated)]
6407 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6408 where
6409 S: serde::Serializer,
6410 {
6411 use serde::ser::SerializeStruct;
6412 let mut len = 0;
6413 if self.vector_id != 0 {
6414 len += 1;
6415 }
6416 if self.distance != 0. {
6417 len += 1;
6418 }
6419 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNeighbor", len)?;
6420 if self.vector_id != 0 {
6421 #[allow(clippy::needless_borrow)]
6422 #[allow(clippy::needless_borrows_for_generic_args)]
6423 struct_ser.serialize_field("vectorId", ToString::to_string(&self.vector_id).as_str())?;
6424 }
6425 if self.distance != 0. {
6426 struct_ser.serialize_field("distance", &self.distance)?;
6427 }
6428 struct_ser.end()
6429 }
6430}
6431impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNeighbor {
6432 #[allow(deprecated)]
6433 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6434 where
6435 D: serde::Deserializer<'de>,
6436 {
6437 const FIELDS: &[&str] = &[
6438 "vector_id",
6439 "vectorId",
6440 "distance",
6441 ];
6442
6443 #[allow(clippy::enum_variant_names)]
6444 enum GeneratedField {
6445 VectorId,
6446 Distance,
6447 }
6448 impl<'de> serde::Deserialize<'de> for GeneratedField {
6449 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6450 where
6451 D: serde::Deserializer<'de>,
6452 {
6453 struct GeneratedVisitor;
6454
6455 impl serde::de::Visitor<'_> for GeneratedVisitor {
6456 type Value = GeneratedField;
6457
6458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6459 write!(formatter, "expected one of: {:?}", &FIELDS)
6460 }
6461
6462 #[allow(unused_variables)]
6463 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6464 where
6465 E: serde::de::Error,
6466 {
6467 match value {
6468 "vectorId" | "vector_id" => Ok(GeneratedField::VectorId),
6469 "distance" => Ok(GeneratedField::Distance),
6470 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6471 }
6472 }
6473 }
6474 deserializer.deserialize_identifier(GeneratedVisitor)
6475 }
6476 }
6477 struct GeneratedVisitor;
6478 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6479 type Value = hnsw_graph::HnswNeighbor;
6480
6481 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6482 formatter.write_str("struct hummock.HnswGraph.HnswNeighbor")
6483 }
6484
6485 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNeighbor, V::Error>
6486 where
6487 V: serde::de::MapAccess<'de>,
6488 {
6489 let mut vector_id__ = None;
6490 let mut distance__ = None;
6491 while let Some(k) = map_.next_key()? {
6492 match k {
6493 GeneratedField::VectorId => {
6494 if vector_id__.is_some() {
6495 return Err(serde::de::Error::duplicate_field("vectorId"));
6496 }
6497 vector_id__ =
6498 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6499 ;
6500 }
6501 GeneratedField::Distance => {
6502 if distance__.is_some() {
6503 return Err(serde::de::Error::duplicate_field("distance"));
6504 }
6505 distance__ =
6506 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6507 ;
6508 }
6509 }
6510 }
6511 Ok(hnsw_graph::HnswNeighbor {
6512 vector_id: vector_id__.unwrap_or_default(),
6513 distance: distance__.unwrap_or_default(),
6514 })
6515 }
6516 }
6517 deserializer.deserialize_struct("hummock.HnswGraph.HnswNeighbor", FIELDS, GeneratedVisitor)
6518 }
6519}
6520impl serde::Serialize for hnsw_graph::HnswNode {
6521 #[allow(deprecated)]
6522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6523 where
6524 S: serde::Serializer,
6525 {
6526 use serde::ser::SerializeStruct;
6527 let mut len = 0;
6528 if !self.levels.is_empty() {
6529 len += 1;
6530 }
6531 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNode", len)?;
6532 if !self.levels.is_empty() {
6533 struct_ser.serialize_field("levels", &self.levels)?;
6534 }
6535 struct_ser.end()
6536 }
6537}
6538impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNode {
6539 #[allow(deprecated)]
6540 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6541 where
6542 D: serde::Deserializer<'de>,
6543 {
6544 const FIELDS: &[&str] = &[
6545 "levels",
6546 ];
6547
6548 #[allow(clippy::enum_variant_names)]
6549 enum GeneratedField {
6550 Levels,
6551 }
6552 impl<'de> serde::Deserialize<'de> for GeneratedField {
6553 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6554 where
6555 D: serde::Deserializer<'de>,
6556 {
6557 struct GeneratedVisitor;
6558
6559 impl serde::de::Visitor<'_> for GeneratedVisitor {
6560 type Value = GeneratedField;
6561
6562 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6563 write!(formatter, "expected one of: {:?}", &FIELDS)
6564 }
6565
6566 #[allow(unused_variables)]
6567 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6568 where
6569 E: serde::de::Error,
6570 {
6571 match value {
6572 "levels" => Ok(GeneratedField::Levels),
6573 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6574 }
6575 }
6576 }
6577 deserializer.deserialize_identifier(GeneratedVisitor)
6578 }
6579 }
6580 struct GeneratedVisitor;
6581 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6582 type Value = hnsw_graph::HnswNode;
6583
6584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6585 formatter.write_str("struct hummock.HnswGraph.HnswNode")
6586 }
6587
6588 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNode, V::Error>
6589 where
6590 V: serde::de::MapAccess<'de>,
6591 {
6592 let mut levels__ = None;
6593 while let Some(k) = map_.next_key()? {
6594 match k {
6595 GeneratedField::Levels => {
6596 if levels__.is_some() {
6597 return Err(serde::de::Error::duplicate_field("levels"));
6598 }
6599 levels__ = Some(map_.next_value()?);
6600 }
6601 }
6602 }
6603 Ok(hnsw_graph::HnswNode {
6604 levels: levels__.unwrap_or_default(),
6605 })
6606 }
6607 }
6608 deserializer.deserialize_struct("hummock.HnswGraph.HnswNode", FIELDS, GeneratedVisitor)
6609 }
6610}
6611impl serde::Serialize for HnswGraphFileInfo {
6612 #[allow(deprecated)]
6613 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6614 where
6615 S: serde::Serializer,
6616 {
6617 use serde::ser::SerializeStruct;
6618 let mut len = 0;
6619 if self.object_id != 0 {
6620 len += 1;
6621 }
6622 if self.file_size != 0 {
6623 len += 1;
6624 }
6625 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraphFileInfo", len)?;
6626 if self.object_id != 0 {
6627 #[allow(clippy::needless_borrow)]
6628 #[allow(clippy::needless_borrows_for_generic_args)]
6629 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
6630 }
6631 if self.file_size != 0 {
6632 #[allow(clippy::needless_borrow)]
6633 #[allow(clippy::needless_borrows_for_generic_args)]
6634 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
6635 }
6636 struct_ser.end()
6637 }
6638}
6639impl<'de> serde::Deserialize<'de> for HnswGraphFileInfo {
6640 #[allow(deprecated)]
6641 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6642 where
6643 D: serde::Deserializer<'de>,
6644 {
6645 const FIELDS: &[&str] = &[
6646 "object_id",
6647 "objectId",
6648 "file_size",
6649 "fileSize",
6650 ];
6651
6652 #[allow(clippy::enum_variant_names)]
6653 enum GeneratedField {
6654 ObjectId,
6655 FileSize,
6656 }
6657 impl<'de> serde::Deserialize<'de> for GeneratedField {
6658 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6659 where
6660 D: serde::Deserializer<'de>,
6661 {
6662 struct GeneratedVisitor;
6663
6664 impl serde::de::Visitor<'_> for GeneratedVisitor {
6665 type Value = GeneratedField;
6666
6667 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6668 write!(formatter, "expected one of: {:?}", &FIELDS)
6669 }
6670
6671 #[allow(unused_variables)]
6672 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6673 where
6674 E: serde::de::Error,
6675 {
6676 match value {
6677 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
6678 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
6679 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6680 }
6681 }
6682 }
6683 deserializer.deserialize_identifier(GeneratedVisitor)
6684 }
6685 }
6686 struct GeneratedVisitor;
6687 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6688 type Value = HnswGraphFileInfo;
6689
6690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6691 formatter.write_str("struct hummock.HnswGraphFileInfo")
6692 }
6693
6694 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraphFileInfo, V::Error>
6695 where
6696 V: serde::de::MapAccess<'de>,
6697 {
6698 let mut object_id__ = None;
6699 let mut file_size__ = None;
6700 while let Some(k) = map_.next_key()? {
6701 match k {
6702 GeneratedField::ObjectId => {
6703 if object_id__.is_some() {
6704 return Err(serde::de::Error::duplicate_field("objectId"));
6705 }
6706 object_id__ =
6707 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6708 ;
6709 }
6710 GeneratedField::FileSize => {
6711 if file_size__.is_some() {
6712 return Err(serde::de::Error::duplicate_field("fileSize"));
6713 }
6714 file_size__ =
6715 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6716 ;
6717 }
6718 }
6719 }
6720 Ok(HnswGraphFileInfo {
6721 object_id: object_id__.unwrap_or_default(),
6722 file_size: file_size__.unwrap_or_default(),
6723 })
6724 }
6725 }
6726 deserializer.deserialize_struct("hummock.HnswGraphFileInfo", FIELDS, GeneratedVisitor)
6727 }
6728}
6729impl serde::Serialize for HummockPinnedSnapshot {
6730 #[allow(deprecated)]
6731 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6732 where
6733 S: serde::Serializer,
6734 {
6735 use serde::ser::SerializeStruct;
6736 let mut len = 0;
6737 if self.context_id != 0 {
6738 len += 1;
6739 }
6740 if self.minimal_pinned_snapshot != 0 {
6741 len += 1;
6742 }
6743 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedSnapshot", len)?;
6744 if self.context_id != 0 {
6745 struct_ser.serialize_field("contextId", &self.context_id)?;
6746 }
6747 if self.minimal_pinned_snapshot != 0 {
6748 #[allow(clippy::needless_borrow)]
6749 #[allow(clippy::needless_borrows_for_generic_args)]
6750 struct_ser.serialize_field("minimalPinnedSnapshot", ToString::to_string(&self.minimal_pinned_snapshot).as_str())?;
6751 }
6752 struct_ser.end()
6753 }
6754}
6755impl<'de> serde::Deserialize<'de> for HummockPinnedSnapshot {
6756 #[allow(deprecated)]
6757 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6758 where
6759 D: serde::Deserializer<'de>,
6760 {
6761 const FIELDS: &[&str] = &[
6762 "context_id",
6763 "contextId",
6764 "minimal_pinned_snapshot",
6765 "minimalPinnedSnapshot",
6766 ];
6767
6768 #[allow(clippy::enum_variant_names)]
6769 enum GeneratedField {
6770 ContextId,
6771 MinimalPinnedSnapshot,
6772 }
6773 impl<'de> serde::Deserialize<'de> for GeneratedField {
6774 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6775 where
6776 D: serde::Deserializer<'de>,
6777 {
6778 struct GeneratedVisitor;
6779
6780 impl serde::de::Visitor<'_> for GeneratedVisitor {
6781 type Value = GeneratedField;
6782
6783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6784 write!(formatter, "expected one of: {:?}", &FIELDS)
6785 }
6786
6787 #[allow(unused_variables)]
6788 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6789 where
6790 E: serde::de::Error,
6791 {
6792 match value {
6793 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6794 "minimalPinnedSnapshot" | "minimal_pinned_snapshot" => Ok(GeneratedField::MinimalPinnedSnapshot),
6795 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6796 }
6797 }
6798 }
6799 deserializer.deserialize_identifier(GeneratedVisitor)
6800 }
6801 }
6802 struct GeneratedVisitor;
6803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6804 type Value = HummockPinnedSnapshot;
6805
6806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6807 formatter.write_str("struct hummock.HummockPinnedSnapshot")
6808 }
6809
6810 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedSnapshot, V::Error>
6811 where
6812 V: serde::de::MapAccess<'de>,
6813 {
6814 let mut context_id__ = None;
6815 let mut minimal_pinned_snapshot__ = None;
6816 while let Some(k) = map_.next_key()? {
6817 match k {
6818 GeneratedField::ContextId => {
6819 if context_id__.is_some() {
6820 return Err(serde::de::Error::duplicate_field("contextId"));
6821 }
6822 context_id__ =
6823 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6824 ;
6825 }
6826 GeneratedField::MinimalPinnedSnapshot => {
6827 if minimal_pinned_snapshot__.is_some() {
6828 return Err(serde::de::Error::duplicate_field("minimalPinnedSnapshot"));
6829 }
6830 minimal_pinned_snapshot__ =
6831 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6832 ;
6833 }
6834 }
6835 }
6836 Ok(HummockPinnedSnapshot {
6837 context_id: context_id__.unwrap_or_default(),
6838 minimal_pinned_snapshot: minimal_pinned_snapshot__.unwrap_or_default(),
6839 })
6840 }
6841 }
6842 deserializer.deserialize_struct("hummock.HummockPinnedSnapshot", FIELDS, GeneratedVisitor)
6843 }
6844}
6845impl serde::Serialize for HummockPinnedVersion {
6846 #[allow(deprecated)]
6847 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6848 where
6849 S: serde::Serializer,
6850 {
6851 use serde::ser::SerializeStruct;
6852 let mut len = 0;
6853 if self.context_id != 0 {
6854 len += 1;
6855 }
6856 if self.min_pinned_id != 0 {
6857 len += 1;
6858 }
6859 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedVersion", len)?;
6860 if self.context_id != 0 {
6861 struct_ser.serialize_field("contextId", &self.context_id)?;
6862 }
6863 if self.min_pinned_id != 0 {
6864 #[allow(clippy::needless_borrow)]
6865 #[allow(clippy::needless_borrows_for_generic_args)]
6866 struct_ser.serialize_field("minPinnedId", ToString::to_string(&self.min_pinned_id).as_str())?;
6867 }
6868 struct_ser.end()
6869 }
6870}
6871impl<'de> serde::Deserialize<'de> for HummockPinnedVersion {
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 "context_id",
6879 "contextId",
6880 "min_pinned_id",
6881 "minPinnedId",
6882 ];
6883
6884 #[allow(clippy::enum_variant_names)]
6885 enum GeneratedField {
6886 ContextId,
6887 MinPinnedId,
6888 }
6889 impl<'de> serde::Deserialize<'de> for GeneratedField {
6890 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6891 where
6892 D: serde::Deserializer<'de>,
6893 {
6894 struct GeneratedVisitor;
6895
6896 impl serde::de::Visitor<'_> for GeneratedVisitor {
6897 type Value = GeneratedField;
6898
6899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6900 write!(formatter, "expected one of: {:?}", &FIELDS)
6901 }
6902
6903 #[allow(unused_variables)]
6904 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6905 where
6906 E: serde::de::Error,
6907 {
6908 match value {
6909 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6910 "minPinnedId" | "min_pinned_id" => Ok(GeneratedField::MinPinnedId),
6911 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6912 }
6913 }
6914 }
6915 deserializer.deserialize_identifier(GeneratedVisitor)
6916 }
6917 }
6918 struct GeneratedVisitor;
6919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6920 type Value = HummockPinnedVersion;
6921
6922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6923 formatter.write_str("struct hummock.HummockPinnedVersion")
6924 }
6925
6926 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedVersion, V::Error>
6927 where
6928 V: serde::de::MapAccess<'de>,
6929 {
6930 let mut context_id__ = None;
6931 let mut min_pinned_id__ = None;
6932 while let Some(k) = map_.next_key()? {
6933 match k {
6934 GeneratedField::ContextId => {
6935 if context_id__.is_some() {
6936 return Err(serde::de::Error::duplicate_field("contextId"));
6937 }
6938 context_id__ =
6939 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6940 ;
6941 }
6942 GeneratedField::MinPinnedId => {
6943 if min_pinned_id__.is_some() {
6944 return Err(serde::de::Error::duplicate_field("minPinnedId"));
6945 }
6946 min_pinned_id__ =
6947 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6948 ;
6949 }
6950 }
6951 }
6952 Ok(HummockPinnedVersion {
6953 context_id: context_id__.unwrap_or_default(),
6954 min_pinned_id: min_pinned_id__.unwrap_or_default(),
6955 })
6956 }
6957 }
6958 deserializer.deserialize_struct("hummock.HummockPinnedVersion", FIELDS, GeneratedVisitor)
6959 }
6960}
6961impl serde::Serialize for HummockVersion {
6962 #[allow(deprecated)]
6963 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6964 where
6965 S: serde::Serializer,
6966 {
6967 use serde::ser::SerializeStruct;
6968 let mut len = 0;
6969 if self.id != 0 {
6970 len += 1;
6971 }
6972 if !self.levels.is_empty() {
6973 len += 1;
6974 }
6975 if self.max_committed_epoch != 0 {
6976 len += 1;
6977 }
6978 if !self.table_watermarks.is_empty() {
6979 len += 1;
6980 }
6981 if !self.table_change_logs.is_empty() {
6982 len += 1;
6983 }
6984 if !self.state_table_info.is_empty() {
6985 len += 1;
6986 }
6987 if !self.vector_indexes.is_empty() {
6988 len += 1;
6989 }
6990 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion", len)?;
6991 if self.id != 0 {
6992 #[allow(clippy::needless_borrow)]
6993 #[allow(clippy::needless_borrows_for_generic_args)]
6994 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6995 }
6996 if !self.levels.is_empty() {
6997 struct_ser.serialize_field("levels", &self.levels)?;
6998 }
6999 if self.max_committed_epoch != 0 {
7000 #[allow(clippy::needless_borrow)]
7001 #[allow(clippy::needless_borrows_for_generic_args)]
7002 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
7003 }
7004 if !self.table_watermarks.is_empty() {
7005 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
7006 }
7007 if !self.table_change_logs.is_empty() {
7008 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
7009 }
7010 if !self.state_table_info.is_empty() {
7011 struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
7012 }
7013 if !self.vector_indexes.is_empty() {
7014 struct_ser.serialize_field("vectorIndexes", &self.vector_indexes)?;
7015 }
7016 struct_ser.end()
7017 }
7018}
7019impl<'de> serde::Deserialize<'de> for HummockVersion {
7020 #[allow(deprecated)]
7021 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7022 where
7023 D: serde::Deserializer<'de>,
7024 {
7025 const FIELDS: &[&str] = &[
7026 "id",
7027 "levels",
7028 "max_committed_epoch",
7029 "maxCommittedEpoch",
7030 "table_watermarks",
7031 "tableWatermarks",
7032 "table_change_logs",
7033 "tableChangeLogs",
7034 "state_table_info",
7035 "stateTableInfo",
7036 "vector_indexes",
7037 "vectorIndexes",
7038 ];
7039
7040 #[allow(clippy::enum_variant_names)]
7041 enum GeneratedField {
7042 Id,
7043 Levels,
7044 MaxCommittedEpoch,
7045 TableWatermarks,
7046 TableChangeLogs,
7047 StateTableInfo,
7048 VectorIndexes,
7049 }
7050 impl<'de> serde::Deserialize<'de> for GeneratedField {
7051 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7052 where
7053 D: serde::Deserializer<'de>,
7054 {
7055 struct GeneratedVisitor;
7056
7057 impl serde::de::Visitor<'_> for GeneratedVisitor {
7058 type Value = GeneratedField;
7059
7060 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7061 write!(formatter, "expected one of: {:?}", &FIELDS)
7062 }
7063
7064 #[allow(unused_variables)]
7065 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7066 where
7067 E: serde::de::Error,
7068 {
7069 match value {
7070 "id" => Ok(GeneratedField::Id),
7071 "levels" => Ok(GeneratedField::Levels),
7072 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
7073 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
7074 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
7075 "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
7076 "vectorIndexes" | "vector_indexes" => Ok(GeneratedField::VectorIndexes),
7077 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7078 }
7079 }
7080 }
7081 deserializer.deserialize_identifier(GeneratedVisitor)
7082 }
7083 }
7084 struct GeneratedVisitor;
7085 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7086 type Value = HummockVersion;
7087
7088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7089 formatter.write_str("struct hummock.HummockVersion")
7090 }
7091
7092 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersion, V::Error>
7093 where
7094 V: serde::de::MapAccess<'de>,
7095 {
7096 let mut id__ = None;
7097 let mut levels__ = None;
7098 let mut max_committed_epoch__ = None;
7099 let mut table_watermarks__ = None;
7100 let mut table_change_logs__ = None;
7101 let mut state_table_info__ = None;
7102 let mut vector_indexes__ = None;
7103 while let Some(k) = map_.next_key()? {
7104 match k {
7105 GeneratedField::Id => {
7106 if id__.is_some() {
7107 return Err(serde::de::Error::duplicate_field("id"));
7108 }
7109 id__ =
7110 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7111 ;
7112 }
7113 GeneratedField::Levels => {
7114 if levels__.is_some() {
7115 return Err(serde::de::Error::duplicate_field("levels"));
7116 }
7117 levels__ = Some(
7118 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
7119 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7120 );
7121 }
7122 GeneratedField::MaxCommittedEpoch => {
7123 if max_committed_epoch__.is_some() {
7124 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
7125 }
7126 max_committed_epoch__ =
7127 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7128 ;
7129 }
7130 GeneratedField::TableWatermarks => {
7131 if table_watermarks__.is_some() {
7132 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
7133 }
7134 table_watermarks__ = Some(
7135 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7136 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7137 );
7138 }
7139 GeneratedField::TableChangeLogs => {
7140 if table_change_logs__.is_some() {
7141 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
7142 }
7143 table_change_logs__ = Some(
7144 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7145 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7146 );
7147 }
7148 GeneratedField::StateTableInfo => {
7149 if state_table_info__.is_some() {
7150 return Err(serde::de::Error::duplicate_field("stateTableInfo"));
7151 }
7152 state_table_info__ = Some(
7153 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7154 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7155 );
7156 }
7157 GeneratedField::VectorIndexes => {
7158 if vector_indexes__.is_some() {
7159 return Err(serde::de::Error::duplicate_field("vectorIndexes"));
7160 }
7161 vector_indexes__ = Some(
7162 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7163 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7164 );
7165 }
7166 }
7167 }
7168 Ok(HummockVersion {
7169 id: id__.unwrap_or_default(),
7170 levels: levels__.unwrap_or_default(),
7171 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
7172 table_watermarks: table_watermarks__.unwrap_or_default(),
7173 table_change_logs: table_change_logs__.unwrap_or_default(),
7174 state_table_info: state_table_info__.unwrap_or_default(),
7175 vector_indexes: vector_indexes__.unwrap_or_default(),
7176 })
7177 }
7178 }
7179 deserializer.deserialize_struct("hummock.HummockVersion", FIELDS, GeneratedVisitor)
7180 }
7181}
7182impl serde::Serialize for hummock_version::Levels {
7183 #[allow(deprecated)]
7184 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7185 where
7186 S: serde::Serializer,
7187 {
7188 use serde::ser::SerializeStruct;
7189 let mut len = 0;
7190 if !self.levels.is_empty() {
7191 len += 1;
7192 }
7193 if self.l0.is_some() {
7194 len += 1;
7195 }
7196 if self.group_id != 0 {
7197 len += 1;
7198 }
7199 if self.parent_group_id != 0 {
7200 len += 1;
7201 }
7202 if !self.member_table_ids.is_empty() {
7203 len += 1;
7204 }
7205 if self.compaction_group_version_id != 0 {
7206 len += 1;
7207 }
7208 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion.Levels", len)?;
7209 if !self.levels.is_empty() {
7210 struct_ser.serialize_field("levels", &self.levels)?;
7211 }
7212 if let Some(v) = self.l0.as_ref() {
7213 struct_ser.serialize_field("l0", v)?;
7214 }
7215 if self.group_id != 0 {
7216 #[allow(clippy::needless_borrow)]
7217 #[allow(clippy::needless_borrows_for_generic_args)]
7218 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
7219 }
7220 if self.parent_group_id != 0 {
7221 #[allow(clippy::needless_borrow)]
7222 #[allow(clippy::needless_borrows_for_generic_args)]
7223 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
7224 }
7225 if !self.member_table_ids.is_empty() {
7226 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
7227 }
7228 if self.compaction_group_version_id != 0 {
7229 #[allow(clippy::needless_borrow)]
7230 #[allow(clippy::needless_borrows_for_generic_args)]
7231 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
7232 }
7233 struct_ser.end()
7234 }
7235}
7236impl<'de> serde::Deserialize<'de> for hummock_version::Levels {
7237 #[allow(deprecated)]
7238 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7239 where
7240 D: serde::Deserializer<'de>,
7241 {
7242 const FIELDS: &[&str] = &[
7243 "levels",
7244 "l0",
7245 "group_id",
7246 "groupId",
7247 "parent_group_id",
7248 "parentGroupId",
7249 "member_table_ids",
7250 "memberTableIds",
7251 "compaction_group_version_id",
7252 "compactionGroupVersionId",
7253 ];
7254
7255 #[allow(clippy::enum_variant_names)]
7256 enum GeneratedField {
7257 Levels,
7258 L0,
7259 GroupId,
7260 ParentGroupId,
7261 MemberTableIds,
7262 CompactionGroupVersionId,
7263 }
7264 impl<'de> serde::Deserialize<'de> for GeneratedField {
7265 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7266 where
7267 D: serde::Deserializer<'de>,
7268 {
7269 struct GeneratedVisitor;
7270
7271 impl serde::de::Visitor<'_> for GeneratedVisitor {
7272 type Value = GeneratedField;
7273
7274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7275 write!(formatter, "expected one of: {:?}", &FIELDS)
7276 }
7277
7278 #[allow(unused_variables)]
7279 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7280 where
7281 E: serde::de::Error,
7282 {
7283 match value {
7284 "levels" => Ok(GeneratedField::Levels),
7285 "l0" => Ok(GeneratedField::L0),
7286 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
7287 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
7288 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
7289 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
7290 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7291 }
7292 }
7293 }
7294 deserializer.deserialize_identifier(GeneratedVisitor)
7295 }
7296 }
7297 struct GeneratedVisitor;
7298 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7299 type Value = hummock_version::Levels;
7300
7301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7302 formatter.write_str("struct hummock.HummockVersion.Levels")
7303 }
7304
7305 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version::Levels, V::Error>
7306 where
7307 V: serde::de::MapAccess<'de>,
7308 {
7309 let mut levels__ = None;
7310 let mut l0__ = None;
7311 let mut group_id__ = None;
7312 let mut parent_group_id__ = None;
7313 let mut member_table_ids__ = None;
7314 let mut compaction_group_version_id__ = None;
7315 while let Some(k) = map_.next_key()? {
7316 match k {
7317 GeneratedField::Levels => {
7318 if levels__.is_some() {
7319 return Err(serde::de::Error::duplicate_field("levels"));
7320 }
7321 levels__ = Some(map_.next_value()?);
7322 }
7323 GeneratedField::L0 => {
7324 if l0__.is_some() {
7325 return Err(serde::de::Error::duplicate_field("l0"));
7326 }
7327 l0__ = map_.next_value()?;
7328 }
7329 GeneratedField::GroupId => {
7330 if group_id__.is_some() {
7331 return Err(serde::de::Error::duplicate_field("groupId"));
7332 }
7333 group_id__ =
7334 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7335 ;
7336 }
7337 GeneratedField::ParentGroupId => {
7338 if parent_group_id__.is_some() {
7339 return Err(serde::de::Error::duplicate_field("parentGroupId"));
7340 }
7341 parent_group_id__ =
7342 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7343 ;
7344 }
7345 GeneratedField::MemberTableIds => {
7346 if member_table_ids__.is_some() {
7347 return Err(serde::de::Error::duplicate_field("memberTableIds"));
7348 }
7349 member_table_ids__ =
7350 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7351 .into_iter().map(|x| x.0).collect())
7352 ;
7353 }
7354 GeneratedField::CompactionGroupVersionId => {
7355 if compaction_group_version_id__.is_some() {
7356 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
7357 }
7358 compaction_group_version_id__ =
7359 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7360 ;
7361 }
7362 }
7363 }
7364 Ok(hummock_version::Levels {
7365 levels: levels__.unwrap_or_default(),
7366 l0: l0__,
7367 group_id: group_id__.unwrap_or_default(),
7368 parent_group_id: parent_group_id__.unwrap_or_default(),
7369 member_table_ids: member_table_ids__.unwrap_or_default(),
7370 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
7371 })
7372 }
7373 }
7374 deserializer.deserialize_struct("hummock.HummockVersion.Levels", FIELDS, GeneratedVisitor)
7375 }
7376}
7377impl serde::Serialize for HummockVersionArchive {
7378 #[allow(deprecated)]
7379 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7380 where
7381 S: serde::Serializer,
7382 {
7383 use serde::ser::SerializeStruct;
7384 let mut len = 0;
7385 if self.version.is_some() {
7386 len += 1;
7387 }
7388 if !self.version_deltas.is_empty() {
7389 len += 1;
7390 }
7391 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionArchive", len)?;
7392 if let Some(v) = self.version.as_ref() {
7393 struct_ser.serialize_field("version", v)?;
7394 }
7395 if !self.version_deltas.is_empty() {
7396 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
7397 }
7398 struct_ser.end()
7399 }
7400}
7401impl<'de> serde::Deserialize<'de> for HummockVersionArchive {
7402 #[allow(deprecated)]
7403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7404 where
7405 D: serde::Deserializer<'de>,
7406 {
7407 const FIELDS: &[&str] = &[
7408 "version",
7409 "version_deltas",
7410 "versionDeltas",
7411 ];
7412
7413 #[allow(clippy::enum_variant_names)]
7414 enum GeneratedField {
7415 Version,
7416 VersionDeltas,
7417 }
7418 impl<'de> serde::Deserialize<'de> for GeneratedField {
7419 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7420 where
7421 D: serde::Deserializer<'de>,
7422 {
7423 struct GeneratedVisitor;
7424
7425 impl serde::de::Visitor<'_> for GeneratedVisitor {
7426 type Value = GeneratedField;
7427
7428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7429 write!(formatter, "expected one of: {:?}", &FIELDS)
7430 }
7431
7432 #[allow(unused_variables)]
7433 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7434 where
7435 E: serde::de::Error,
7436 {
7437 match value {
7438 "version" => Ok(GeneratedField::Version),
7439 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
7440 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7441 }
7442 }
7443 }
7444 deserializer.deserialize_identifier(GeneratedVisitor)
7445 }
7446 }
7447 struct GeneratedVisitor;
7448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7449 type Value = HummockVersionArchive;
7450
7451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7452 formatter.write_str("struct hummock.HummockVersionArchive")
7453 }
7454
7455 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionArchive, V::Error>
7456 where
7457 V: serde::de::MapAccess<'de>,
7458 {
7459 let mut version__ = None;
7460 let mut version_deltas__ = None;
7461 while let Some(k) = map_.next_key()? {
7462 match k {
7463 GeneratedField::Version => {
7464 if version__.is_some() {
7465 return Err(serde::de::Error::duplicate_field("version"));
7466 }
7467 version__ = map_.next_value()?;
7468 }
7469 GeneratedField::VersionDeltas => {
7470 if version_deltas__.is_some() {
7471 return Err(serde::de::Error::duplicate_field("versionDeltas"));
7472 }
7473 version_deltas__ = Some(map_.next_value()?);
7474 }
7475 }
7476 }
7477 Ok(HummockVersionArchive {
7478 version: version__,
7479 version_deltas: version_deltas__.unwrap_or_default(),
7480 })
7481 }
7482 }
7483 deserializer.deserialize_struct("hummock.HummockVersionArchive", FIELDS, GeneratedVisitor)
7484 }
7485}
7486impl serde::Serialize for HummockVersionCheckpoint {
7487 #[allow(deprecated)]
7488 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7489 where
7490 S: serde::Serializer,
7491 {
7492 use serde::ser::SerializeStruct;
7493 let mut len = 0;
7494 if self.version.is_some() {
7495 len += 1;
7496 }
7497 if !self.stale_objects.is_empty() {
7498 len += 1;
7499 }
7500 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint", len)?;
7501 if let Some(v) = self.version.as_ref() {
7502 struct_ser.serialize_field("version", v)?;
7503 }
7504 if !self.stale_objects.is_empty() {
7505 struct_ser.serialize_field("staleObjects", &self.stale_objects)?;
7506 }
7507 struct_ser.end()
7508 }
7509}
7510impl<'de> serde::Deserialize<'de> for HummockVersionCheckpoint {
7511 #[allow(deprecated)]
7512 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7513 where
7514 D: serde::Deserializer<'de>,
7515 {
7516 const FIELDS: &[&str] = &[
7517 "version",
7518 "stale_objects",
7519 "staleObjects",
7520 ];
7521
7522 #[allow(clippy::enum_variant_names)]
7523 enum GeneratedField {
7524 Version,
7525 StaleObjects,
7526 }
7527 impl<'de> serde::Deserialize<'de> for GeneratedField {
7528 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7529 where
7530 D: serde::Deserializer<'de>,
7531 {
7532 struct GeneratedVisitor;
7533
7534 impl serde::de::Visitor<'_> for GeneratedVisitor {
7535 type Value = GeneratedField;
7536
7537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7538 write!(formatter, "expected one of: {:?}", &FIELDS)
7539 }
7540
7541 #[allow(unused_variables)]
7542 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7543 where
7544 E: serde::de::Error,
7545 {
7546 match value {
7547 "version" => Ok(GeneratedField::Version),
7548 "staleObjects" | "stale_objects" => Ok(GeneratedField::StaleObjects),
7549 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7550 }
7551 }
7552 }
7553 deserializer.deserialize_identifier(GeneratedVisitor)
7554 }
7555 }
7556 struct GeneratedVisitor;
7557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7558 type Value = HummockVersionCheckpoint;
7559
7560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7561 formatter.write_str("struct hummock.HummockVersionCheckpoint")
7562 }
7563
7564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpoint, V::Error>
7565 where
7566 V: serde::de::MapAccess<'de>,
7567 {
7568 let mut version__ = None;
7569 let mut stale_objects__ = None;
7570 while let Some(k) = map_.next_key()? {
7571 match k {
7572 GeneratedField::Version => {
7573 if version__.is_some() {
7574 return Err(serde::de::Error::duplicate_field("version"));
7575 }
7576 version__ = map_.next_value()?;
7577 }
7578 GeneratedField::StaleObjects => {
7579 if stale_objects__.is_some() {
7580 return Err(serde::de::Error::duplicate_field("staleObjects"));
7581 }
7582 stale_objects__ = Some(
7583 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
7584 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7585 );
7586 }
7587 }
7588 }
7589 Ok(HummockVersionCheckpoint {
7590 version: version__,
7591 stale_objects: stale_objects__.unwrap_or_default(),
7592 })
7593 }
7594 }
7595 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint", FIELDS, GeneratedVisitor)
7596 }
7597}
7598impl serde::Serialize for hummock_version_checkpoint::StaleObjects {
7599 #[allow(deprecated)]
7600 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7601 where
7602 S: serde::Serializer,
7603 {
7604 use serde::ser::SerializeStruct;
7605 let mut len = 0;
7606 if !self.id.is_empty() {
7607 len += 1;
7608 }
7609 if self.total_file_size != 0 {
7610 len += 1;
7611 }
7612 if !self.vector_files.is_empty() {
7613 len += 1;
7614 }
7615 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", len)?;
7616 if !self.id.is_empty() {
7617 struct_ser.serialize_field("id", &self.id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
7618 }
7619 if self.total_file_size != 0 {
7620 #[allow(clippy::needless_borrow)]
7621 #[allow(clippy::needless_borrows_for_generic_args)]
7622 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
7623 }
7624 if !self.vector_files.is_empty() {
7625 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
7626 }
7627 struct_ser.end()
7628 }
7629}
7630impl<'de> serde::Deserialize<'de> for hummock_version_checkpoint::StaleObjects {
7631 #[allow(deprecated)]
7632 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7633 where
7634 D: serde::Deserializer<'de>,
7635 {
7636 const FIELDS: &[&str] = &[
7637 "id",
7638 "total_file_size",
7639 "totalFileSize",
7640 "vector_files",
7641 "vectorFiles",
7642 ];
7643
7644 #[allow(clippy::enum_variant_names)]
7645 enum GeneratedField {
7646 Id,
7647 TotalFileSize,
7648 VectorFiles,
7649 }
7650 impl<'de> serde::Deserialize<'de> for GeneratedField {
7651 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7652 where
7653 D: serde::Deserializer<'de>,
7654 {
7655 struct GeneratedVisitor;
7656
7657 impl serde::de::Visitor<'_> for GeneratedVisitor {
7658 type Value = GeneratedField;
7659
7660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7661 write!(formatter, "expected one of: {:?}", &FIELDS)
7662 }
7663
7664 #[allow(unused_variables)]
7665 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7666 where
7667 E: serde::de::Error,
7668 {
7669 match value {
7670 "id" => Ok(GeneratedField::Id),
7671 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7672 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
7673 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7674 }
7675 }
7676 }
7677 deserializer.deserialize_identifier(GeneratedVisitor)
7678 }
7679 }
7680 struct GeneratedVisitor;
7681 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7682 type Value = hummock_version_checkpoint::StaleObjects;
7683
7684 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7685 formatter.write_str("struct hummock.HummockVersionCheckpoint.StaleObjects")
7686 }
7687
7688 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_checkpoint::StaleObjects, V::Error>
7689 where
7690 V: serde::de::MapAccess<'de>,
7691 {
7692 let mut id__ = None;
7693 let mut total_file_size__ = None;
7694 let mut vector_files__ = None;
7695 while let Some(k) = map_.next_key()? {
7696 match k {
7697 GeneratedField::Id => {
7698 if id__.is_some() {
7699 return Err(serde::de::Error::duplicate_field("id"));
7700 }
7701 id__ =
7702 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7703 .into_iter().map(|x| x.0).collect())
7704 ;
7705 }
7706 GeneratedField::TotalFileSize => {
7707 if total_file_size__.is_some() {
7708 return Err(serde::de::Error::duplicate_field("totalFileSize"));
7709 }
7710 total_file_size__ =
7711 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7712 ;
7713 }
7714 GeneratedField::VectorFiles => {
7715 if vector_files__.is_some() {
7716 return Err(serde::de::Error::duplicate_field("vectorFiles"));
7717 }
7718 vector_files__ = Some(map_.next_value()?);
7719 }
7720 }
7721 }
7722 Ok(hummock_version_checkpoint::StaleObjects {
7723 id: id__.unwrap_or_default(),
7724 total_file_size: total_file_size__.unwrap_or_default(),
7725 vector_files: vector_files__.unwrap_or_default(),
7726 })
7727 }
7728 }
7729 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", FIELDS, GeneratedVisitor)
7730 }
7731}
7732impl serde::Serialize for HummockVersionCheckpointEnvelope {
7733 #[allow(deprecated)]
7734 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7735 where
7736 S: serde::Serializer,
7737 {
7738 use serde::ser::SerializeStruct;
7739 let mut len = 0;
7740 if self.compression_algorithm != 0 {
7741 len += 1;
7742 }
7743 if !self.payload.is_empty() {
7744 len += 1;
7745 }
7746 if self.checksum.is_some() {
7747 len += 1;
7748 }
7749 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpointEnvelope", len)?;
7750 if self.compression_algorithm != 0 {
7751 let v = CheckpointCompressionAlgorithm::try_from(self.compression_algorithm)
7752 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compression_algorithm)))?;
7753 struct_ser.serialize_field("compressionAlgorithm", &v)?;
7754 }
7755 if !self.payload.is_empty() {
7756 #[allow(clippy::needless_borrow)]
7757 #[allow(clippy::needless_borrows_for_generic_args)]
7758 struct_ser.serialize_field("payload", pbjson::private::base64::encode(&self.payload).as_str())?;
7759 }
7760 if let Some(v) = self.checksum.as_ref() {
7761 #[allow(clippy::needless_borrow)]
7762 #[allow(clippy::needless_borrows_for_generic_args)]
7763 struct_ser.serialize_field("checksum", ToString::to_string(&v).as_str())?;
7764 }
7765 struct_ser.end()
7766 }
7767}
7768impl<'de> serde::Deserialize<'de> for HummockVersionCheckpointEnvelope {
7769 #[allow(deprecated)]
7770 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7771 where
7772 D: serde::Deserializer<'de>,
7773 {
7774 const FIELDS: &[&str] = &[
7775 "compression_algorithm",
7776 "compressionAlgorithm",
7777 "payload",
7778 "checksum",
7779 ];
7780
7781 #[allow(clippy::enum_variant_names)]
7782 enum GeneratedField {
7783 CompressionAlgorithm,
7784 Payload,
7785 Checksum,
7786 }
7787 impl<'de> serde::Deserialize<'de> for GeneratedField {
7788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7789 where
7790 D: serde::Deserializer<'de>,
7791 {
7792 struct GeneratedVisitor;
7793
7794 impl serde::de::Visitor<'_> for GeneratedVisitor {
7795 type Value = GeneratedField;
7796
7797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7798 write!(formatter, "expected one of: {:?}", &FIELDS)
7799 }
7800
7801 #[allow(unused_variables)]
7802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7803 where
7804 E: serde::de::Error,
7805 {
7806 match value {
7807 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
7808 "payload" => Ok(GeneratedField::Payload),
7809 "checksum" => Ok(GeneratedField::Checksum),
7810 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7811 }
7812 }
7813 }
7814 deserializer.deserialize_identifier(GeneratedVisitor)
7815 }
7816 }
7817 struct GeneratedVisitor;
7818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7819 type Value = HummockVersionCheckpointEnvelope;
7820
7821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7822 formatter.write_str("struct hummock.HummockVersionCheckpointEnvelope")
7823 }
7824
7825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpointEnvelope, V::Error>
7826 where
7827 V: serde::de::MapAccess<'de>,
7828 {
7829 let mut compression_algorithm__ = None;
7830 let mut payload__ = None;
7831 let mut checksum__ = None;
7832 while let Some(k) = map_.next_key()? {
7833 match k {
7834 GeneratedField::CompressionAlgorithm => {
7835 if compression_algorithm__.is_some() {
7836 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
7837 }
7838 compression_algorithm__ = Some(map_.next_value::<CheckpointCompressionAlgorithm>()? as i32);
7839 }
7840 GeneratedField::Payload => {
7841 if payload__.is_some() {
7842 return Err(serde::de::Error::duplicate_field("payload"));
7843 }
7844 payload__ =
7845 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7846 ;
7847 }
7848 GeneratedField::Checksum => {
7849 if checksum__.is_some() {
7850 return Err(serde::de::Error::duplicate_field("checksum"));
7851 }
7852 checksum__ =
7853 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
7854 ;
7855 }
7856 }
7857 }
7858 Ok(HummockVersionCheckpointEnvelope {
7859 compression_algorithm: compression_algorithm__.unwrap_or_default(),
7860 payload: payload__.unwrap_or_default(),
7861 checksum: checksum__,
7862 })
7863 }
7864 }
7865 deserializer.deserialize_struct("hummock.HummockVersionCheckpointEnvelope", FIELDS, GeneratedVisitor)
7866 }
7867}
7868impl serde::Serialize for HummockVersionDelta {
7869 #[allow(deprecated)]
7870 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7871 where
7872 S: serde::Serializer,
7873 {
7874 use serde::ser::SerializeStruct;
7875 let mut len = 0;
7876 if self.id != 0 {
7877 len += 1;
7878 }
7879 if self.prev_id != 0 {
7880 len += 1;
7881 }
7882 if !self.group_deltas.is_empty() {
7883 len += 1;
7884 }
7885 if self.max_committed_epoch != 0 {
7886 len += 1;
7887 }
7888 if self.trivial_move {
7889 len += 1;
7890 }
7891 if !self.new_table_watermarks.is_empty() {
7892 len += 1;
7893 }
7894 if !self.removed_table_ids.is_empty() {
7895 len += 1;
7896 }
7897 if !self.change_log_delta.is_empty() {
7898 len += 1;
7899 }
7900 if !self.state_table_info_delta.is_empty() {
7901 len += 1;
7902 }
7903 if !self.vector_index_delta.is_empty() {
7904 len += 1;
7905 }
7906 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta", len)?;
7907 if self.id != 0 {
7908 #[allow(clippy::needless_borrow)]
7909 #[allow(clippy::needless_borrows_for_generic_args)]
7910 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7911 }
7912 if self.prev_id != 0 {
7913 #[allow(clippy::needless_borrow)]
7914 #[allow(clippy::needless_borrows_for_generic_args)]
7915 struct_ser.serialize_field("prevId", ToString::to_string(&self.prev_id).as_str())?;
7916 }
7917 if !self.group_deltas.is_empty() {
7918 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
7919 }
7920 if self.max_committed_epoch != 0 {
7921 #[allow(clippy::needless_borrow)]
7922 #[allow(clippy::needless_borrows_for_generic_args)]
7923 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
7924 }
7925 if self.trivial_move {
7926 struct_ser.serialize_field("trivialMove", &self.trivial_move)?;
7927 }
7928 if !self.new_table_watermarks.is_empty() {
7929 struct_ser.serialize_field("newTableWatermarks", &self.new_table_watermarks)?;
7930 }
7931 if !self.removed_table_ids.is_empty() {
7932 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids)?;
7933 }
7934 if !self.change_log_delta.is_empty() {
7935 struct_ser.serialize_field("changeLogDelta", &self.change_log_delta)?;
7936 }
7937 if !self.state_table_info_delta.is_empty() {
7938 struct_ser.serialize_field("stateTableInfoDelta", &self.state_table_info_delta)?;
7939 }
7940 if !self.vector_index_delta.is_empty() {
7941 struct_ser.serialize_field("vectorIndexDelta", &self.vector_index_delta)?;
7942 }
7943 struct_ser.end()
7944 }
7945}
7946impl<'de> serde::Deserialize<'de> for HummockVersionDelta {
7947 #[allow(deprecated)]
7948 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7949 where
7950 D: serde::Deserializer<'de>,
7951 {
7952 const FIELDS: &[&str] = &[
7953 "id",
7954 "prev_id",
7955 "prevId",
7956 "group_deltas",
7957 "groupDeltas",
7958 "max_committed_epoch",
7959 "maxCommittedEpoch",
7960 "trivial_move",
7961 "trivialMove",
7962 "new_table_watermarks",
7963 "newTableWatermarks",
7964 "removed_table_ids",
7965 "removedTableIds",
7966 "change_log_delta",
7967 "changeLogDelta",
7968 "state_table_info_delta",
7969 "stateTableInfoDelta",
7970 "vector_index_delta",
7971 "vectorIndexDelta",
7972 ];
7973
7974 #[allow(clippy::enum_variant_names)]
7975 enum GeneratedField {
7976 Id,
7977 PrevId,
7978 GroupDeltas,
7979 MaxCommittedEpoch,
7980 TrivialMove,
7981 NewTableWatermarks,
7982 RemovedTableIds,
7983 ChangeLogDelta,
7984 StateTableInfoDelta,
7985 VectorIndexDelta,
7986 }
7987 impl<'de> serde::Deserialize<'de> for GeneratedField {
7988 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7989 where
7990 D: serde::Deserializer<'de>,
7991 {
7992 struct GeneratedVisitor;
7993
7994 impl serde::de::Visitor<'_> for GeneratedVisitor {
7995 type Value = GeneratedField;
7996
7997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7998 write!(formatter, "expected one of: {:?}", &FIELDS)
7999 }
8000
8001 #[allow(unused_variables)]
8002 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8003 where
8004 E: serde::de::Error,
8005 {
8006 match value {
8007 "id" => Ok(GeneratedField::Id),
8008 "prevId" | "prev_id" => Ok(GeneratedField::PrevId),
8009 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
8010 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
8011 "trivialMove" | "trivial_move" => Ok(GeneratedField::TrivialMove),
8012 "newTableWatermarks" | "new_table_watermarks" => Ok(GeneratedField::NewTableWatermarks),
8013 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
8014 "changeLogDelta" | "change_log_delta" => Ok(GeneratedField::ChangeLogDelta),
8015 "stateTableInfoDelta" | "state_table_info_delta" => Ok(GeneratedField::StateTableInfoDelta),
8016 "vectorIndexDelta" | "vector_index_delta" => Ok(GeneratedField::VectorIndexDelta),
8017 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8018 }
8019 }
8020 }
8021 deserializer.deserialize_identifier(GeneratedVisitor)
8022 }
8023 }
8024 struct GeneratedVisitor;
8025 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8026 type Value = HummockVersionDelta;
8027
8028 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8029 formatter.write_str("struct hummock.HummockVersionDelta")
8030 }
8031
8032 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDelta, V::Error>
8033 where
8034 V: serde::de::MapAccess<'de>,
8035 {
8036 let mut id__ = None;
8037 let mut prev_id__ = None;
8038 let mut group_deltas__ = None;
8039 let mut max_committed_epoch__ = None;
8040 let mut trivial_move__ = None;
8041 let mut new_table_watermarks__ = None;
8042 let mut removed_table_ids__ = None;
8043 let mut change_log_delta__ = None;
8044 let mut state_table_info_delta__ = None;
8045 let mut vector_index_delta__ = None;
8046 while let Some(k) = map_.next_key()? {
8047 match k {
8048 GeneratedField::Id => {
8049 if id__.is_some() {
8050 return Err(serde::de::Error::duplicate_field("id"));
8051 }
8052 id__ =
8053 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8054 ;
8055 }
8056 GeneratedField::PrevId => {
8057 if prev_id__.is_some() {
8058 return Err(serde::de::Error::duplicate_field("prevId"));
8059 }
8060 prev_id__ =
8061 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8062 ;
8063 }
8064 GeneratedField::GroupDeltas => {
8065 if group_deltas__.is_some() {
8066 return Err(serde::de::Error::duplicate_field("groupDeltas"));
8067 }
8068 group_deltas__ = Some(
8069 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
8070 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8071 );
8072 }
8073 GeneratedField::MaxCommittedEpoch => {
8074 if max_committed_epoch__.is_some() {
8075 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
8076 }
8077 max_committed_epoch__ =
8078 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8079 ;
8080 }
8081 GeneratedField::TrivialMove => {
8082 if trivial_move__.is_some() {
8083 return Err(serde::de::Error::duplicate_field("trivialMove"));
8084 }
8085 trivial_move__ = Some(map_.next_value()?);
8086 }
8087 GeneratedField::NewTableWatermarks => {
8088 if new_table_watermarks__.is_some() {
8089 return Err(serde::de::Error::duplicate_field("newTableWatermarks"));
8090 }
8091 new_table_watermarks__ = Some(
8092 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8093 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8094 );
8095 }
8096 GeneratedField::RemovedTableIds => {
8097 if removed_table_ids__.is_some() {
8098 return Err(serde::de::Error::duplicate_field("removedTableIds"));
8099 }
8100 removed_table_ids__ =
8101 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8102 .into_iter().map(|x| x.0).collect())
8103 ;
8104 }
8105 GeneratedField::ChangeLogDelta => {
8106 if change_log_delta__.is_some() {
8107 return Err(serde::de::Error::duplicate_field("changeLogDelta"));
8108 }
8109 change_log_delta__ = Some(
8110 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8111 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8112 );
8113 }
8114 GeneratedField::StateTableInfoDelta => {
8115 if state_table_info_delta__.is_some() {
8116 return Err(serde::de::Error::duplicate_field("stateTableInfoDelta"));
8117 }
8118 state_table_info_delta__ = Some(
8119 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8120 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8121 );
8122 }
8123 GeneratedField::VectorIndexDelta => {
8124 if vector_index_delta__.is_some() {
8125 return Err(serde::de::Error::duplicate_field("vectorIndexDelta"));
8126 }
8127 vector_index_delta__ = Some(
8128 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8129 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8130 );
8131 }
8132 }
8133 }
8134 Ok(HummockVersionDelta {
8135 id: id__.unwrap_or_default(),
8136 prev_id: prev_id__.unwrap_or_default(),
8137 group_deltas: group_deltas__.unwrap_or_default(),
8138 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
8139 trivial_move: trivial_move__.unwrap_or_default(),
8140 new_table_watermarks: new_table_watermarks__.unwrap_or_default(),
8141 removed_table_ids: removed_table_ids__.unwrap_or_default(),
8142 change_log_delta: change_log_delta__.unwrap_or_default(),
8143 state_table_info_delta: state_table_info_delta__.unwrap_or_default(),
8144 vector_index_delta: vector_index_delta__.unwrap_or_default(),
8145 })
8146 }
8147 }
8148 deserializer.deserialize_struct("hummock.HummockVersionDelta", FIELDS, GeneratedVisitor)
8149 }
8150}
8151impl serde::Serialize for hummock_version_delta::ChangeLogDelta {
8152 #[allow(deprecated)]
8153 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8154 where
8155 S: serde::Serializer,
8156 {
8157 use serde::ser::SerializeStruct;
8158 let mut len = 0;
8159 if self.new_log.is_some() {
8160 len += 1;
8161 }
8162 if self.truncate_epoch != 0 {
8163 len += 1;
8164 }
8165 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", len)?;
8166 if let Some(v) = self.new_log.as_ref() {
8167 struct_ser.serialize_field("newLog", v)?;
8168 }
8169 if self.truncate_epoch != 0 {
8170 #[allow(clippy::needless_borrow)]
8171 #[allow(clippy::needless_borrows_for_generic_args)]
8172 struct_ser.serialize_field("truncateEpoch", ToString::to_string(&self.truncate_epoch).as_str())?;
8173 }
8174 struct_ser.end()
8175 }
8176}
8177impl<'de> serde::Deserialize<'de> for hummock_version_delta::ChangeLogDelta {
8178 #[allow(deprecated)]
8179 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8180 where
8181 D: serde::Deserializer<'de>,
8182 {
8183 const FIELDS: &[&str] = &[
8184 "new_log",
8185 "newLog",
8186 "truncate_epoch",
8187 "truncateEpoch",
8188 ];
8189
8190 #[allow(clippy::enum_variant_names)]
8191 enum GeneratedField {
8192 NewLog,
8193 TruncateEpoch,
8194 }
8195 impl<'de> serde::Deserialize<'de> for GeneratedField {
8196 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8197 where
8198 D: serde::Deserializer<'de>,
8199 {
8200 struct GeneratedVisitor;
8201
8202 impl serde::de::Visitor<'_> for GeneratedVisitor {
8203 type Value = GeneratedField;
8204
8205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8206 write!(formatter, "expected one of: {:?}", &FIELDS)
8207 }
8208
8209 #[allow(unused_variables)]
8210 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8211 where
8212 E: serde::de::Error,
8213 {
8214 match value {
8215 "newLog" | "new_log" => Ok(GeneratedField::NewLog),
8216 "truncateEpoch" | "truncate_epoch" => Ok(GeneratedField::TruncateEpoch),
8217 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8218 }
8219 }
8220 }
8221 deserializer.deserialize_identifier(GeneratedVisitor)
8222 }
8223 }
8224 struct GeneratedVisitor;
8225 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8226 type Value = hummock_version_delta::ChangeLogDelta;
8227
8228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8229 formatter.write_str("struct hummock.HummockVersionDelta.ChangeLogDelta")
8230 }
8231
8232 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::ChangeLogDelta, V::Error>
8233 where
8234 V: serde::de::MapAccess<'de>,
8235 {
8236 let mut new_log__ = None;
8237 let mut truncate_epoch__ = None;
8238 while let Some(k) = map_.next_key()? {
8239 match k {
8240 GeneratedField::NewLog => {
8241 if new_log__.is_some() {
8242 return Err(serde::de::Error::duplicate_field("newLog"));
8243 }
8244 new_log__ = map_.next_value()?;
8245 }
8246 GeneratedField::TruncateEpoch => {
8247 if truncate_epoch__.is_some() {
8248 return Err(serde::de::Error::duplicate_field("truncateEpoch"));
8249 }
8250 truncate_epoch__ =
8251 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8252 ;
8253 }
8254 }
8255 }
8256 Ok(hummock_version_delta::ChangeLogDelta {
8257 new_log: new_log__,
8258 truncate_epoch: truncate_epoch__.unwrap_or_default(),
8259 })
8260 }
8261 }
8262 deserializer.deserialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", FIELDS, GeneratedVisitor)
8263 }
8264}
8265impl serde::Serialize for hummock_version_delta::GroupDeltas {
8266 #[allow(deprecated)]
8267 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8268 where
8269 S: serde::Serializer,
8270 {
8271 use serde::ser::SerializeStruct;
8272 let mut len = 0;
8273 if !self.group_deltas.is_empty() {
8274 len += 1;
8275 }
8276 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.GroupDeltas", len)?;
8277 if !self.group_deltas.is_empty() {
8278 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
8279 }
8280 struct_ser.end()
8281 }
8282}
8283impl<'de> serde::Deserialize<'de> for hummock_version_delta::GroupDeltas {
8284 #[allow(deprecated)]
8285 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8286 where
8287 D: serde::Deserializer<'de>,
8288 {
8289 const FIELDS: &[&str] = &[
8290 "group_deltas",
8291 "groupDeltas",
8292 ];
8293
8294 #[allow(clippy::enum_variant_names)]
8295 enum GeneratedField {
8296 GroupDeltas,
8297 }
8298 impl<'de> serde::Deserialize<'de> for GeneratedField {
8299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8300 where
8301 D: serde::Deserializer<'de>,
8302 {
8303 struct GeneratedVisitor;
8304
8305 impl serde::de::Visitor<'_> for GeneratedVisitor {
8306 type Value = GeneratedField;
8307
8308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8309 write!(formatter, "expected one of: {:?}", &FIELDS)
8310 }
8311
8312 #[allow(unused_variables)]
8313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8314 where
8315 E: serde::de::Error,
8316 {
8317 match value {
8318 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
8319 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8320 }
8321 }
8322 }
8323 deserializer.deserialize_identifier(GeneratedVisitor)
8324 }
8325 }
8326 struct GeneratedVisitor;
8327 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8328 type Value = hummock_version_delta::GroupDeltas;
8329
8330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8331 formatter.write_str("struct hummock.HummockVersionDelta.GroupDeltas")
8332 }
8333
8334 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::GroupDeltas, V::Error>
8335 where
8336 V: serde::de::MapAccess<'de>,
8337 {
8338 let mut group_deltas__ = None;
8339 while let Some(k) = map_.next_key()? {
8340 match k {
8341 GeneratedField::GroupDeltas => {
8342 if group_deltas__.is_some() {
8343 return Err(serde::de::Error::duplicate_field("groupDeltas"));
8344 }
8345 group_deltas__ = Some(map_.next_value()?);
8346 }
8347 }
8348 }
8349 Ok(hummock_version_delta::GroupDeltas {
8350 group_deltas: group_deltas__.unwrap_or_default(),
8351 })
8352 }
8353 }
8354 deserializer.deserialize_struct("hummock.HummockVersionDelta.GroupDeltas", FIELDS, GeneratedVisitor)
8355 }
8356}
8357impl serde::Serialize for HummockVersionDeltas {
8358 #[allow(deprecated)]
8359 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8360 where
8361 S: serde::Serializer,
8362 {
8363 use serde::ser::SerializeStruct;
8364 let mut len = 0;
8365 if !self.version_deltas.is_empty() {
8366 len += 1;
8367 }
8368 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDeltas", len)?;
8369 if !self.version_deltas.is_empty() {
8370 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
8371 }
8372 struct_ser.end()
8373 }
8374}
8375impl<'de> serde::Deserialize<'de> for HummockVersionDeltas {
8376 #[allow(deprecated)]
8377 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8378 where
8379 D: serde::Deserializer<'de>,
8380 {
8381 const FIELDS: &[&str] = &[
8382 "version_deltas",
8383 "versionDeltas",
8384 ];
8385
8386 #[allow(clippy::enum_variant_names)]
8387 enum GeneratedField {
8388 VersionDeltas,
8389 }
8390 impl<'de> serde::Deserialize<'de> for GeneratedField {
8391 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8392 where
8393 D: serde::Deserializer<'de>,
8394 {
8395 struct GeneratedVisitor;
8396
8397 impl serde::de::Visitor<'_> for GeneratedVisitor {
8398 type Value = GeneratedField;
8399
8400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8401 write!(formatter, "expected one of: {:?}", &FIELDS)
8402 }
8403
8404 #[allow(unused_variables)]
8405 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8406 where
8407 E: serde::de::Error,
8408 {
8409 match value {
8410 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
8411 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8412 }
8413 }
8414 }
8415 deserializer.deserialize_identifier(GeneratedVisitor)
8416 }
8417 }
8418 struct GeneratedVisitor;
8419 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8420 type Value = HummockVersionDeltas;
8421
8422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8423 formatter.write_str("struct hummock.HummockVersionDeltas")
8424 }
8425
8426 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDeltas, V::Error>
8427 where
8428 V: serde::de::MapAccess<'de>,
8429 {
8430 let mut version_deltas__ = None;
8431 while let Some(k) = map_.next_key()? {
8432 match k {
8433 GeneratedField::VersionDeltas => {
8434 if version_deltas__.is_some() {
8435 return Err(serde::de::Error::duplicate_field("versionDeltas"));
8436 }
8437 version_deltas__ = Some(map_.next_value()?);
8438 }
8439 }
8440 }
8441 Ok(HummockVersionDeltas {
8442 version_deltas: version_deltas__.unwrap_or_default(),
8443 })
8444 }
8445 }
8446 deserializer.deserialize_struct("hummock.HummockVersionDeltas", FIELDS, GeneratedVisitor)
8447 }
8448}
8449impl serde::Serialize for HummockVersionStats {
8450 #[allow(deprecated)]
8451 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8452 where
8453 S: serde::Serializer,
8454 {
8455 use serde::ser::SerializeStruct;
8456 let mut len = 0;
8457 if self.hummock_version_id != 0 {
8458 len += 1;
8459 }
8460 if !self.table_stats.is_empty() {
8461 len += 1;
8462 }
8463 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionStats", len)?;
8464 if self.hummock_version_id != 0 {
8465 #[allow(clippy::needless_borrow)]
8466 #[allow(clippy::needless_borrows_for_generic_args)]
8467 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
8468 }
8469 if !self.table_stats.is_empty() {
8470 struct_ser.serialize_field("tableStats", &self.table_stats)?;
8471 }
8472 struct_ser.end()
8473 }
8474}
8475impl<'de> serde::Deserialize<'de> for HummockVersionStats {
8476 #[allow(deprecated)]
8477 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8478 where
8479 D: serde::Deserializer<'de>,
8480 {
8481 const FIELDS: &[&str] = &[
8482 "hummock_version_id",
8483 "hummockVersionId",
8484 "table_stats",
8485 "tableStats",
8486 ];
8487
8488 #[allow(clippy::enum_variant_names)]
8489 enum GeneratedField {
8490 HummockVersionId,
8491 TableStats,
8492 }
8493 impl<'de> serde::Deserialize<'de> for GeneratedField {
8494 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8495 where
8496 D: serde::Deserializer<'de>,
8497 {
8498 struct GeneratedVisitor;
8499
8500 impl serde::de::Visitor<'_> for GeneratedVisitor {
8501 type Value = GeneratedField;
8502
8503 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8504 write!(formatter, "expected one of: {:?}", &FIELDS)
8505 }
8506
8507 #[allow(unused_variables)]
8508 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8509 where
8510 E: serde::de::Error,
8511 {
8512 match value {
8513 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
8514 "tableStats" | "table_stats" => Ok(GeneratedField::TableStats),
8515 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8516 }
8517 }
8518 }
8519 deserializer.deserialize_identifier(GeneratedVisitor)
8520 }
8521 }
8522 struct GeneratedVisitor;
8523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8524 type Value = HummockVersionStats;
8525
8526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8527 formatter.write_str("struct hummock.HummockVersionStats")
8528 }
8529
8530 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionStats, V::Error>
8531 where
8532 V: serde::de::MapAccess<'de>,
8533 {
8534 let mut hummock_version_id__ = None;
8535 let mut table_stats__ = None;
8536 while let Some(k) = map_.next_key()? {
8537 match k {
8538 GeneratedField::HummockVersionId => {
8539 if hummock_version_id__.is_some() {
8540 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
8541 }
8542 hummock_version_id__ =
8543 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8544 ;
8545 }
8546 GeneratedField::TableStats => {
8547 if table_stats__.is_some() {
8548 return Err(serde::de::Error::duplicate_field("tableStats"));
8549 }
8550 table_stats__ = Some(
8551 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8552 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8553 );
8554 }
8555 }
8556 }
8557 Ok(HummockVersionStats {
8558 hummock_version_id: hummock_version_id__.unwrap_or_default(),
8559 table_stats: table_stats__.unwrap_or_default(),
8560 })
8561 }
8562 }
8563 deserializer.deserialize_struct("hummock.HummockVersionStats", FIELDS, GeneratedVisitor)
8564 }
8565}
8566impl serde::Serialize for InitMetadataForReplayRequest {
8567 #[allow(deprecated)]
8568 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8569 where
8570 S: serde::Serializer,
8571 {
8572 use serde::ser::SerializeStruct;
8573 let mut len = 0;
8574 if !self.tables.is_empty() {
8575 len += 1;
8576 }
8577 if !self.compaction_groups.is_empty() {
8578 len += 1;
8579 }
8580 let mut struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayRequest", len)?;
8581 if !self.tables.is_empty() {
8582 struct_ser.serialize_field("tables", &self.tables)?;
8583 }
8584 if !self.compaction_groups.is_empty() {
8585 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
8586 }
8587 struct_ser.end()
8588 }
8589}
8590impl<'de> serde::Deserialize<'de> for InitMetadataForReplayRequest {
8591 #[allow(deprecated)]
8592 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8593 where
8594 D: serde::Deserializer<'de>,
8595 {
8596 const FIELDS: &[&str] = &[
8597 "tables",
8598 "compaction_groups",
8599 "compactionGroups",
8600 ];
8601
8602 #[allow(clippy::enum_variant_names)]
8603 enum GeneratedField {
8604 Tables,
8605 CompactionGroups,
8606 }
8607 impl<'de> serde::Deserialize<'de> for GeneratedField {
8608 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8609 where
8610 D: serde::Deserializer<'de>,
8611 {
8612 struct GeneratedVisitor;
8613
8614 impl serde::de::Visitor<'_> for GeneratedVisitor {
8615 type Value = GeneratedField;
8616
8617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8618 write!(formatter, "expected one of: {:?}", &FIELDS)
8619 }
8620
8621 #[allow(unused_variables)]
8622 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8623 where
8624 E: serde::de::Error,
8625 {
8626 match value {
8627 "tables" => Ok(GeneratedField::Tables),
8628 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
8629 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8630 }
8631 }
8632 }
8633 deserializer.deserialize_identifier(GeneratedVisitor)
8634 }
8635 }
8636 struct GeneratedVisitor;
8637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8638 type Value = InitMetadataForReplayRequest;
8639
8640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8641 formatter.write_str("struct hummock.InitMetadataForReplayRequest")
8642 }
8643
8644 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayRequest, V::Error>
8645 where
8646 V: serde::de::MapAccess<'de>,
8647 {
8648 let mut tables__ = None;
8649 let mut compaction_groups__ = None;
8650 while let Some(k) = map_.next_key()? {
8651 match k {
8652 GeneratedField::Tables => {
8653 if tables__.is_some() {
8654 return Err(serde::de::Error::duplicate_field("tables"));
8655 }
8656 tables__ = Some(map_.next_value()?);
8657 }
8658 GeneratedField::CompactionGroups => {
8659 if compaction_groups__.is_some() {
8660 return Err(serde::de::Error::duplicate_field("compactionGroups"));
8661 }
8662 compaction_groups__ = Some(map_.next_value()?);
8663 }
8664 }
8665 }
8666 Ok(InitMetadataForReplayRequest {
8667 tables: tables__.unwrap_or_default(),
8668 compaction_groups: compaction_groups__.unwrap_or_default(),
8669 })
8670 }
8671 }
8672 deserializer.deserialize_struct("hummock.InitMetadataForReplayRequest", FIELDS, GeneratedVisitor)
8673 }
8674}
8675impl serde::Serialize for InitMetadataForReplayResponse {
8676 #[allow(deprecated)]
8677 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8678 where
8679 S: serde::Serializer,
8680 {
8681 use serde::ser::SerializeStruct;
8682 let len = 0;
8683 let struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayResponse", len)?;
8684 struct_ser.end()
8685 }
8686}
8687impl<'de> serde::Deserialize<'de> for InitMetadataForReplayResponse {
8688 #[allow(deprecated)]
8689 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8690 where
8691 D: serde::Deserializer<'de>,
8692 {
8693 const FIELDS: &[&str] = &[
8694 ];
8695
8696 #[allow(clippy::enum_variant_names)]
8697 enum GeneratedField {
8698 }
8699 impl<'de> serde::Deserialize<'de> for GeneratedField {
8700 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8701 where
8702 D: serde::Deserializer<'de>,
8703 {
8704 struct GeneratedVisitor;
8705
8706 impl serde::de::Visitor<'_> for GeneratedVisitor {
8707 type Value = GeneratedField;
8708
8709 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8710 write!(formatter, "expected one of: {:?}", &FIELDS)
8711 }
8712
8713 #[allow(unused_variables)]
8714 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8715 where
8716 E: serde::de::Error,
8717 {
8718 Err(serde::de::Error::unknown_field(value, FIELDS))
8719 }
8720 }
8721 deserializer.deserialize_identifier(GeneratedVisitor)
8722 }
8723 }
8724 struct GeneratedVisitor;
8725 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8726 type Value = InitMetadataForReplayResponse;
8727
8728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8729 formatter.write_str("struct hummock.InitMetadataForReplayResponse")
8730 }
8731
8732 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayResponse, V::Error>
8733 where
8734 V: serde::de::MapAccess<'de>,
8735 {
8736 while map_.next_key::<GeneratedField>()?.is_some() {
8737 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8738 }
8739 Ok(InitMetadataForReplayResponse {
8740 })
8741 }
8742 }
8743 deserializer.deserialize_struct("hummock.InitMetadataForReplayResponse", FIELDS, GeneratedVisitor)
8744 }
8745}
8746impl serde::Serialize for InputLevel {
8747 #[allow(deprecated)]
8748 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8749 where
8750 S: serde::Serializer,
8751 {
8752 use serde::ser::SerializeStruct;
8753 let mut len = 0;
8754 if self.level_idx != 0 {
8755 len += 1;
8756 }
8757 if self.level_type != 0 {
8758 len += 1;
8759 }
8760 if !self.table_infos.is_empty() {
8761 len += 1;
8762 }
8763 let mut struct_ser = serializer.serialize_struct("hummock.InputLevel", len)?;
8764 if self.level_idx != 0 {
8765 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8766 }
8767 if self.level_type != 0 {
8768 let v = LevelType::try_from(self.level_type)
8769 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
8770 struct_ser.serialize_field("levelType", &v)?;
8771 }
8772 if !self.table_infos.is_empty() {
8773 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
8774 }
8775 struct_ser.end()
8776 }
8777}
8778impl<'de> serde::Deserialize<'de> for InputLevel {
8779 #[allow(deprecated)]
8780 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8781 where
8782 D: serde::Deserializer<'de>,
8783 {
8784 const FIELDS: &[&str] = &[
8785 "level_idx",
8786 "levelIdx",
8787 "level_type",
8788 "levelType",
8789 "table_infos",
8790 "tableInfos",
8791 ];
8792
8793 #[allow(clippy::enum_variant_names)]
8794 enum GeneratedField {
8795 LevelIdx,
8796 LevelType,
8797 TableInfos,
8798 }
8799 impl<'de> serde::Deserialize<'de> for GeneratedField {
8800 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8801 where
8802 D: serde::Deserializer<'de>,
8803 {
8804 struct GeneratedVisitor;
8805
8806 impl serde::de::Visitor<'_> for GeneratedVisitor {
8807 type Value = GeneratedField;
8808
8809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8810 write!(formatter, "expected one of: {:?}", &FIELDS)
8811 }
8812
8813 #[allow(unused_variables)]
8814 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8815 where
8816 E: serde::de::Error,
8817 {
8818 match value {
8819 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8820 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
8821 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
8822 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8823 }
8824 }
8825 }
8826 deserializer.deserialize_identifier(GeneratedVisitor)
8827 }
8828 }
8829 struct GeneratedVisitor;
8830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8831 type Value = InputLevel;
8832
8833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8834 formatter.write_str("struct hummock.InputLevel")
8835 }
8836
8837 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputLevel, V::Error>
8838 where
8839 V: serde::de::MapAccess<'de>,
8840 {
8841 let mut level_idx__ = None;
8842 let mut level_type__ = None;
8843 let mut table_infos__ = None;
8844 while let Some(k) = map_.next_key()? {
8845 match k {
8846 GeneratedField::LevelIdx => {
8847 if level_idx__.is_some() {
8848 return Err(serde::de::Error::duplicate_field("levelIdx"));
8849 }
8850 level_idx__ =
8851 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8852 ;
8853 }
8854 GeneratedField::LevelType => {
8855 if level_type__.is_some() {
8856 return Err(serde::de::Error::duplicate_field("levelType"));
8857 }
8858 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
8859 }
8860 GeneratedField::TableInfos => {
8861 if table_infos__.is_some() {
8862 return Err(serde::de::Error::duplicate_field("tableInfos"));
8863 }
8864 table_infos__ = Some(map_.next_value()?);
8865 }
8866 }
8867 }
8868 Ok(InputLevel {
8869 level_idx: level_idx__.unwrap_or_default(),
8870 level_type: level_type__.unwrap_or_default(),
8871 table_infos: table_infos__.unwrap_or_default(),
8872 })
8873 }
8874 }
8875 deserializer.deserialize_struct("hummock.InputLevel", FIELDS, GeneratedVisitor)
8876 }
8877}
8878impl serde::Serialize for IntraLevelDelta {
8879 #[allow(deprecated)]
8880 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8881 where
8882 S: serde::Serializer,
8883 {
8884 use serde::ser::SerializeStruct;
8885 let mut len = 0;
8886 if self.level_idx != 0 {
8887 len += 1;
8888 }
8889 if self.l0_sub_level_id != 0 {
8890 len += 1;
8891 }
8892 if !self.removed_table_ids.is_empty() {
8893 len += 1;
8894 }
8895 if !self.inserted_table_infos.is_empty() {
8896 len += 1;
8897 }
8898 if self.vnode_partition_count != 0 {
8899 len += 1;
8900 }
8901 if self.compaction_group_version_id != 0 {
8902 len += 1;
8903 }
8904 let mut struct_ser = serializer.serialize_struct("hummock.IntraLevelDelta", len)?;
8905 if self.level_idx != 0 {
8906 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8907 }
8908 if self.l0_sub_level_id != 0 {
8909 #[allow(clippy::needless_borrow)]
8910 #[allow(clippy::needless_borrows_for_generic_args)]
8911 struct_ser.serialize_field("l0SubLevelId", ToString::to_string(&self.l0_sub_level_id).as_str())?;
8912 }
8913 if !self.removed_table_ids.is_empty() {
8914 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8915 }
8916 if !self.inserted_table_infos.is_empty() {
8917 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
8918 }
8919 if self.vnode_partition_count != 0 {
8920 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
8921 }
8922 if self.compaction_group_version_id != 0 {
8923 #[allow(clippy::needless_borrow)]
8924 #[allow(clippy::needless_borrows_for_generic_args)]
8925 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
8926 }
8927 struct_ser.end()
8928 }
8929}
8930impl<'de> serde::Deserialize<'de> for IntraLevelDelta {
8931 #[allow(deprecated)]
8932 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8933 where
8934 D: serde::Deserializer<'de>,
8935 {
8936 const FIELDS: &[&str] = &[
8937 "level_idx",
8938 "levelIdx",
8939 "l0_sub_level_id",
8940 "l0SubLevelId",
8941 "removed_table_ids",
8942 "removedTableIds",
8943 "inserted_table_infos",
8944 "insertedTableInfos",
8945 "vnode_partition_count",
8946 "vnodePartitionCount",
8947 "compaction_group_version_id",
8948 "compactionGroupVersionId",
8949 ];
8950
8951 #[allow(clippy::enum_variant_names)]
8952 enum GeneratedField {
8953 LevelIdx,
8954 L0SubLevelId,
8955 RemovedTableIds,
8956 InsertedTableInfos,
8957 VnodePartitionCount,
8958 CompactionGroupVersionId,
8959 }
8960 impl<'de> serde::Deserialize<'de> for GeneratedField {
8961 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8962 where
8963 D: serde::Deserializer<'de>,
8964 {
8965 struct GeneratedVisitor;
8966
8967 impl serde::de::Visitor<'_> for GeneratedVisitor {
8968 type Value = GeneratedField;
8969
8970 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8971 write!(formatter, "expected one of: {:?}", &FIELDS)
8972 }
8973
8974 #[allow(unused_variables)]
8975 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8976 where
8977 E: serde::de::Error,
8978 {
8979 match value {
8980 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8981 "l0SubLevelId" | "l0_sub_level_id" => Ok(GeneratedField::L0SubLevelId),
8982 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
8983 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
8984 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
8985 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
8986 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8987 }
8988 }
8989 }
8990 deserializer.deserialize_identifier(GeneratedVisitor)
8991 }
8992 }
8993 struct GeneratedVisitor;
8994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8995 type Value = IntraLevelDelta;
8996
8997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8998 formatter.write_str("struct hummock.IntraLevelDelta")
8999 }
9000
9001 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntraLevelDelta, V::Error>
9002 where
9003 V: serde::de::MapAccess<'de>,
9004 {
9005 let mut level_idx__ = None;
9006 let mut l0_sub_level_id__ = None;
9007 let mut removed_table_ids__ = None;
9008 let mut inserted_table_infos__ = None;
9009 let mut vnode_partition_count__ = None;
9010 let mut compaction_group_version_id__ = None;
9011 while let Some(k) = map_.next_key()? {
9012 match k {
9013 GeneratedField::LevelIdx => {
9014 if level_idx__.is_some() {
9015 return Err(serde::de::Error::duplicate_field("levelIdx"));
9016 }
9017 level_idx__ =
9018 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9019 ;
9020 }
9021 GeneratedField::L0SubLevelId => {
9022 if l0_sub_level_id__.is_some() {
9023 return Err(serde::de::Error::duplicate_field("l0SubLevelId"));
9024 }
9025 l0_sub_level_id__ =
9026 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9027 ;
9028 }
9029 GeneratedField::RemovedTableIds => {
9030 if removed_table_ids__.is_some() {
9031 return Err(serde::de::Error::duplicate_field("removedTableIds"));
9032 }
9033 removed_table_ids__ =
9034 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9035 .into_iter().map(|x| x.0).collect())
9036 ;
9037 }
9038 GeneratedField::InsertedTableInfos => {
9039 if inserted_table_infos__.is_some() {
9040 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
9041 }
9042 inserted_table_infos__ = Some(map_.next_value()?);
9043 }
9044 GeneratedField::VnodePartitionCount => {
9045 if vnode_partition_count__.is_some() {
9046 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
9047 }
9048 vnode_partition_count__ =
9049 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9050 ;
9051 }
9052 GeneratedField::CompactionGroupVersionId => {
9053 if compaction_group_version_id__.is_some() {
9054 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
9055 }
9056 compaction_group_version_id__ =
9057 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9058 ;
9059 }
9060 }
9061 }
9062 Ok(IntraLevelDelta {
9063 level_idx: level_idx__.unwrap_or_default(),
9064 l0_sub_level_id: l0_sub_level_id__.unwrap_or_default(),
9065 removed_table_ids: removed_table_ids__.unwrap_or_default(),
9066 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
9067 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
9068 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
9069 })
9070 }
9071 }
9072 deserializer.deserialize_struct("hummock.IntraLevelDelta", FIELDS, GeneratedVisitor)
9073 }
9074}
9075impl serde::Serialize for KeyRange {
9076 #[allow(deprecated)]
9077 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9078 where
9079 S: serde::Serializer,
9080 {
9081 use serde::ser::SerializeStruct;
9082 let mut len = 0;
9083 if !self.left.is_empty() {
9084 len += 1;
9085 }
9086 if !self.right.is_empty() {
9087 len += 1;
9088 }
9089 if self.right_exclusive {
9090 len += 1;
9091 }
9092 let mut struct_ser = serializer.serialize_struct("hummock.KeyRange", len)?;
9093 if !self.left.is_empty() {
9094 #[allow(clippy::needless_borrow)]
9095 #[allow(clippy::needless_borrows_for_generic_args)]
9096 struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
9097 }
9098 if !self.right.is_empty() {
9099 #[allow(clippy::needless_borrow)]
9100 #[allow(clippy::needless_borrows_for_generic_args)]
9101 struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
9102 }
9103 if self.right_exclusive {
9104 struct_ser.serialize_field("rightExclusive", &self.right_exclusive)?;
9105 }
9106 struct_ser.end()
9107 }
9108}
9109impl<'de> serde::Deserialize<'de> for KeyRange {
9110 #[allow(deprecated)]
9111 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9112 where
9113 D: serde::Deserializer<'de>,
9114 {
9115 const FIELDS: &[&str] = &[
9116 "left",
9117 "right",
9118 "right_exclusive",
9119 "rightExclusive",
9120 ];
9121
9122 #[allow(clippy::enum_variant_names)]
9123 enum GeneratedField {
9124 Left,
9125 Right,
9126 RightExclusive,
9127 }
9128 impl<'de> serde::Deserialize<'de> for GeneratedField {
9129 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9130 where
9131 D: serde::Deserializer<'de>,
9132 {
9133 struct GeneratedVisitor;
9134
9135 impl serde::de::Visitor<'_> for GeneratedVisitor {
9136 type Value = GeneratedField;
9137
9138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9139 write!(formatter, "expected one of: {:?}", &FIELDS)
9140 }
9141
9142 #[allow(unused_variables)]
9143 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9144 where
9145 E: serde::de::Error,
9146 {
9147 match value {
9148 "left" => Ok(GeneratedField::Left),
9149 "right" => Ok(GeneratedField::Right),
9150 "rightExclusive" | "right_exclusive" => Ok(GeneratedField::RightExclusive),
9151 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9152 }
9153 }
9154 }
9155 deserializer.deserialize_identifier(GeneratedVisitor)
9156 }
9157 }
9158 struct GeneratedVisitor;
9159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9160 type Value = KeyRange;
9161
9162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9163 formatter.write_str("struct hummock.KeyRange")
9164 }
9165
9166 fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
9167 where
9168 V: serde::de::MapAccess<'de>,
9169 {
9170 let mut left__ = None;
9171 let mut right__ = None;
9172 let mut right_exclusive__ = None;
9173 while let Some(k) = map_.next_key()? {
9174 match k {
9175 GeneratedField::Left => {
9176 if left__.is_some() {
9177 return Err(serde::de::Error::duplicate_field("left"));
9178 }
9179 left__ =
9180 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
9181 ;
9182 }
9183 GeneratedField::Right => {
9184 if right__.is_some() {
9185 return Err(serde::de::Error::duplicate_field("right"));
9186 }
9187 right__ =
9188 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
9189 ;
9190 }
9191 GeneratedField::RightExclusive => {
9192 if right_exclusive__.is_some() {
9193 return Err(serde::de::Error::duplicate_field("rightExclusive"));
9194 }
9195 right_exclusive__ = Some(map_.next_value()?);
9196 }
9197 }
9198 }
9199 Ok(KeyRange {
9200 left: left__.unwrap_or_default(),
9201 right: right__.unwrap_or_default(),
9202 right_exclusive: right_exclusive__.unwrap_or_default(),
9203 })
9204 }
9205 }
9206 deserializer.deserialize_struct("hummock.KeyRange", FIELDS, GeneratedVisitor)
9207 }
9208}
9209impl serde::Serialize for Level {
9210 #[allow(deprecated)]
9211 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9212 where
9213 S: serde::Serializer,
9214 {
9215 use serde::ser::SerializeStruct;
9216 let mut len = 0;
9217 if self.level_idx != 0 {
9218 len += 1;
9219 }
9220 if self.level_type != 0 {
9221 len += 1;
9222 }
9223 if !self.table_infos.is_empty() {
9224 len += 1;
9225 }
9226 if self.total_file_size != 0 {
9227 len += 1;
9228 }
9229 if self.sub_level_id != 0 {
9230 len += 1;
9231 }
9232 if self.uncompressed_file_size != 0 {
9233 len += 1;
9234 }
9235 if self.vnode_partition_count != 0 {
9236 len += 1;
9237 }
9238 let mut struct_ser = serializer.serialize_struct("hummock.Level", len)?;
9239 if self.level_idx != 0 {
9240 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
9241 }
9242 if self.level_type != 0 {
9243 let v = LevelType::try_from(self.level_type)
9244 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
9245 struct_ser.serialize_field("levelType", &v)?;
9246 }
9247 if !self.table_infos.is_empty() {
9248 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
9249 }
9250 if self.total_file_size != 0 {
9251 #[allow(clippy::needless_borrow)]
9252 #[allow(clippy::needless_borrows_for_generic_args)]
9253 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
9254 }
9255 if self.sub_level_id != 0 {
9256 #[allow(clippy::needless_borrow)]
9257 #[allow(clippy::needless_borrows_for_generic_args)]
9258 struct_ser.serialize_field("subLevelId", ToString::to_string(&self.sub_level_id).as_str())?;
9259 }
9260 if self.uncompressed_file_size != 0 {
9261 #[allow(clippy::needless_borrow)]
9262 #[allow(clippy::needless_borrows_for_generic_args)]
9263 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
9264 }
9265 if self.vnode_partition_count != 0 {
9266 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
9267 }
9268 struct_ser.end()
9269 }
9270}
9271impl<'de> serde::Deserialize<'de> for Level {
9272 #[allow(deprecated)]
9273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9274 where
9275 D: serde::Deserializer<'de>,
9276 {
9277 const FIELDS: &[&str] = &[
9278 "level_idx",
9279 "levelIdx",
9280 "level_type",
9281 "levelType",
9282 "table_infos",
9283 "tableInfos",
9284 "total_file_size",
9285 "totalFileSize",
9286 "sub_level_id",
9287 "subLevelId",
9288 "uncompressed_file_size",
9289 "uncompressedFileSize",
9290 "vnode_partition_count",
9291 "vnodePartitionCount",
9292 ];
9293
9294 #[allow(clippy::enum_variant_names)]
9295 enum GeneratedField {
9296 LevelIdx,
9297 LevelType,
9298 TableInfos,
9299 TotalFileSize,
9300 SubLevelId,
9301 UncompressedFileSize,
9302 VnodePartitionCount,
9303 }
9304 impl<'de> serde::Deserialize<'de> for GeneratedField {
9305 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9306 where
9307 D: serde::Deserializer<'de>,
9308 {
9309 struct GeneratedVisitor;
9310
9311 impl serde::de::Visitor<'_> for GeneratedVisitor {
9312 type Value = GeneratedField;
9313
9314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9315 write!(formatter, "expected one of: {:?}", &FIELDS)
9316 }
9317
9318 #[allow(unused_variables)]
9319 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9320 where
9321 E: serde::de::Error,
9322 {
9323 match value {
9324 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
9325 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
9326 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
9327 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
9328 "subLevelId" | "sub_level_id" => Ok(GeneratedField::SubLevelId),
9329 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
9330 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
9331 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9332 }
9333 }
9334 }
9335 deserializer.deserialize_identifier(GeneratedVisitor)
9336 }
9337 }
9338 struct GeneratedVisitor;
9339 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9340 type Value = Level;
9341
9342 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9343 formatter.write_str("struct hummock.Level")
9344 }
9345
9346 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Level, V::Error>
9347 where
9348 V: serde::de::MapAccess<'de>,
9349 {
9350 let mut level_idx__ = None;
9351 let mut level_type__ = None;
9352 let mut table_infos__ = None;
9353 let mut total_file_size__ = None;
9354 let mut sub_level_id__ = None;
9355 let mut uncompressed_file_size__ = None;
9356 let mut vnode_partition_count__ = None;
9357 while let Some(k) = map_.next_key()? {
9358 match k {
9359 GeneratedField::LevelIdx => {
9360 if level_idx__.is_some() {
9361 return Err(serde::de::Error::duplicate_field("levelIdx"));
9362 }
9363 level_idx__ =
9364 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9365 ;
9366 }
9367 GeneratedField::LevelType => {
9368 if level_type__.is_some() {
9369 return Err(serde::de::Error::duplicate_field("levelType"));
9370 }
9371 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
9372 }
9373 GeneratedField::TableInfos => {
9374 if table_infos__.is_some() {
9375 return Err(serde::de::Error::duplicate_field("tableInfos"));
9376 }
9377 table_infos__ = Some(map_.next_value()?);
9378 }
9379 GeneratedField::TotalFileSize => {
9380 if total_file_size__.is_some() {
9381 return Err(serde::de::Error::duplicate_field("totalFileSize"));
9382 }
9383 total_file_size__ =
9384 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9385 ;
9386 }
9387 GeneratedField::SubLevelId => {
9388 if sub_level_id__.is_some() {
9389 return Err(serde::de::Error::duplicate_field("subLevelId"));
9390 }
9391 sub_level_id__ =
9392 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9393 ;
9394 }
9395 GeneratedField::UncompressedFileSize => {
9396 if uncompressed_file_size__.is_some() {
9397 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
9398 }
9399 uncompressed_file_size__ =
9400 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9401 ;
9402 }
9403 GeneratedField::VnodePartitionCount => {
9404 if vnode_partition_count__.is_some() {
9405 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
9406 }
9407 vnode_partition_count__ =
9408 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9409 ;
9410 }
9411 }
9412 }
9413 Ok(Level {
9414 level_idx: level_idx__.unwrap_or_default(),
9415 level_type: level_type__.unwrap_or_default(),
9416 table_infos: table_infos__.unwrap_or_default(),
9417 total_file_size: total_file_size__.unwrap_or_default(),
9418 sub_level_id: sub_level_id__.unwrap_or_default(),
9419 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
9420 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
9421 })
9422 }
9423 }
9424 deserializer.deserialize_struct("hummock.Level", FIELDS, GeneratedVisitor)
9425 }
9426}
9427impl serde::Serialize for LevelHandler {
9428 #[allow(deprecated)]
9429 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9430 where
9431 S: serde::Serializer,
9432 {
9433 use serde::ser::SerializeStruct;
9434 let mut len = 0;
9435 if self.level != 0 {
9436 len += 1;
9437 }
9438 if !self.tasks.is_empty() {
9439 len += 1;
9440 }
9441 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler", len)?;
9442 if self.level != 0 {
9443 struct_ser.serialize_field("level", &self.level)?;
9444 }
9445 if !self.tasks.is_empty() {
9446 struct_ser.serialize_field("tasks", &self.tasks)?;
9447 }
9448 struct_ser.end()
9449 }
9450}
9451impl<'de> serde::Deserialize<'de> for LevelHandler {
9452 #[allow(deprecated)]
9453 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9454 where
9455 D: serde::Deserializer<'de>,
9456 {
9457 const FIELDS: &[&str] = &[
9458 "level",
9459 "tasks",
9460 ];
9461
9462 #[allow(clippy::enum_variant_names)]
9463 enum GeneratedField {
9464 Level,
9465 Tasks,
9466 }
9467 impl<'de> serde::Deserialize<'de> for GeneratedField {
9468 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9469 where
9470 D: serde::Deserializer<'de>,
9471 {
9472 struct GeneratedVisitor;
9473
9474 impl serde::de::Visitor<'_> for GeneratedVisitor {
9475 type Value = GeneratedField;
9476
9477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9478 write!(formatter, "expected one of: {:?}", &FIELDS)
9479 }
9480
9481 #[allow(unused_variables)]
9482 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9483 where
9484 E: serde::de::Error,
9485 {
9486 match value {
9487 "level" => Ok(GeneratedField::Level),
9488 "tasks" => Ok(GeneratedField::Tasks),
9489 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9490 }
9491 }
9492 }
9493 deserializer.deserialize_identifier(GeneratedVisitor)
9494 }
9495 }
9496 struct GeneratedVisitor;
9497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9498 type Value = LevelHandler;
9499
9500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9501 formatter.write_str("struct hummock.LevelHandler")
9502 }
9503
9504 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LevelHandler, V::Error>
9505 where
9506 V: serde::de::MapAccess<'de>,
9507 {
9508 let mut level__ = None;
9509 let mut tasks__ = None;
9510 while let Some(k) = map_.next_key()? {
9511 match k {
9512 GeneratedField::Level => {
9513 if level__.is_some() {
9514 return Err(serde::de::Error::duplicate_field("level"));
9515 }
9516 level__ =
9517 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9518 ;
9519 }
9520 GeneratedField::Tasks => {
9521 if tasks__.is_some() {
9522 return Err(serde::de::Error::duplicate_field("tasks"));
9523 }
9524 tasks__ = Some(map_.next_value()?);
9525 }
9526 }
9527 }
9528 Ok(LevelHandler {
9529 level: level__.unwrap_or_default(),
9530 tasks: tasks__.unwrap_or_default(),
9531 })
9532 }
9533 }
9534 deserializer.deserialize_struct("hummock.LevelHandler", FIELDS, GeneratedVisitor)
9535 }
9536}
9537impl serde::Serialize for level_handler::RunningCompactTask {
9538 #[allow(deprecated)]
9539 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9540 where
9541 S: serde::Serializer,
9542 {
9543 use serde::ser::SerializeStruct;
9544 let mut len = 0;
9545 if self.task_id != 0 {
9546 len += 1;
9547 }
9548 if !self.ssts.is_empty() {
9549 len += 1;
9550 }
9551 if self.total_file_size != 0 {
9552 len += 1;
9553 }
9554 if self.target_level != 0 {
9555 len += 1;
9556 }
9557 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler.RunningCompactTask", len)?;
9558 if self.task_id != 0 {
9559 #[allow(clippy::needless_borrow)]
9560 #[allow(clippy::needless_borrows_for_generic_args)]
9561 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
9562 }
9563 if !self.ssts.is_empty() {
9564 struct_ser.serialize_field("ssts", &self.ssts.iter().map(ToString::to_string).collect::<Vec<_>>())?;
9565 }
9566 if self.total_file_size != 0 {
9567 #[allow(clippy::needless_borrow)]
9568 #[allow(clippy::needless_borrows_for_generic_args)]
9569 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
9570 }
9571 if self.target_level != 0 {
9572 struct_ser.serialize_field("targetLevel", &self.target_level)?;
9573 }
9574 struct_ser.end()
9575 }
9576}
9577impl<'de> serde::Deserialize<'de> for level_handler::RunningCompactTask {
9578 #[allow(deprecated)]
9579 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9580 where
9581 D: serde::Deserializer<'de>,
9582 {
9583 const FIELDS: &[&str] = &[
9584 "task_id",
9585 "taskId",
9586 "ssts",
9587 "total_file_size",
9588 "totalFileSize",
9589 "target_level",
9590 "targetLevel",
9591 ];
9592
9593 #[allow(clippy::enum_variant_names)]
9594 enum GeneratedField {
9595 TaskId,
9596 Ssts,
9597 TotalFileSize,
9598 TargetLevel,
9599 }
9600 impl<'de> serde::Deserialize<'de> for GeneratedField {
9601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9602 where
9603 D: serde::Deserializer<'de>,
9604 {
9605 struct GeneratedVisitor;
9606
9607 impl serde::de::Visitor<'_> for GeneratedVisitor {
9608 type Value = GeneratedField;
9609
9610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9611 write!(formatter, "expected one of: {:?}", &FIELDS)
9612 }
9613
9614 #[allow(unused_variables)]
9615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9616 where
9617 E: serde::de::Error,
9618 {
9619 match value {
9620 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
9621 "ssts" => Ok(GeneratedField::Ssts),
9622 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
9623 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
9624 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9625 }
9626 }
9627 }
9628 deserializer.deserialize_identifier(GeneratedVisitor)
9629 }
9630 }
9631 struct GeneratedVisitor;
9632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9633 type Value = level_handler::RunningCompactTask;
9634
9635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9636 formatter.write_str("struct hummock.LevelHandler.RunningCompactTask")
9637 }
9638
9639 fn visit_map<V>(self, mut map_: V) -> std::result::Result<level_handler::RunningCompactTask, V::Error>
9640 where
9641 V: serde::de::MapAccess<'de>,
9642 {
9643 let mut task_id__ = None;
9644 let mut ssts__ = None;
9645 let mut total_file_size__ = None;
9646 let mut target_level__ = None;
9647 while let Some(k) = map_.next_key()? {
9648 match k {
9649 GeneratedField::TaskId => {
9650 if task_id__.is_some() {
9651 return Err(serde::de::Error::duplicate_field("taskId"));
9652 }
9653 task_id__ =
9654 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9655 ;
9656 }
9657 GeneratedField::Ssts => {
9658 if ssts__.is_some() {
9659 return Err(serde::de::Error::duplicate_field("ssts"));
9660 }
9661 ssts__ =
9662 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9663 .into_iter().map(|x| x.0).collect())
9664 ;
9665 }
9666 GeneratedField::TotalFileSize => {
9667 if total_file_size__.is_some() {
9668 return Err(serde::de::Error::duplicate_field("totalFileSize"));
9669 }
9670 total_file_size__ =
9671 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9672 ;
9673 }
9674 GeneratedField::TargetLevel => {
9675 if target_level__.is_some() {
9676 return Err(serde::de::Error::duplicate_field("targetLevel"));
9677 }
9678 target_level__ =
9679 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9680 ;
9681 }
9682 }
9683 }
9684 Ok(level_handler::RunningCompactTask {
9685 task_id: task_id__.unwrap_or_default(),
9686 ssts: ssts__.unwrap_or_default(),
9687 total_file_size: total_file_size__.unwrap_or_default(),
9688 target_level: target_level__.unwrap_or_default(),
9689 })
9690 }
9691 }
9692 deserializer.deserialize_struct("hummock.LevelHandler.RunningCompactTask", FIELDS, GeneratedVisitor)
9693 }
9694}
9695impl serde::Serialize for LevelType {
9696 #[allow(deprecated)]
9697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9698 where
9699 S: serde::Serializer,
9700 {
9701 let variant = match self {
9702 Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
9703 Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
9704 Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
9705 };
9706 serializer.serialize_str(variant)
9707 }
9708}
9709impl<'de> serde::Deserialize<'de> for LevelType {
9710 #[allow(deprecated)]
9711 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9712 where
9713 D: serde::Deserializer<'de>,
9714 {
9715 const FIELDS: &[&str] = &[
9716 "LEVEL_TYPE_UNSPECIFIED",
9717 "LEVEL_TYPE_NONOVERLAPPING",
9718 "LEVEL_TYPE_OVERLAPPING",
9719 ];
9720
9721 struct GeneratedVisitor;
9722
9723 impl serde::de::Visitor<'_> for GeneratedVisitor {
9724 type Value = LevelType;
9725
9726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9727 write!(formatter, "expected one of: {:?}", &FIELDS)
9728 }
9729
9730 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9731 where
9732 E: serde::de::Error,
9733 {
9734 i32::try_from(v)
9735 .ok()
9736 .and_then(|x| x.try_into().ok())
9737 .ok_or_else(|| {
9738 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9739 })
9740 }
9741
9742 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9743 where
9744 E: serde::de::Error,
9745 {
9746 i32::try_from(v)
9747 .ok()
9748 .and_then(|x| x.try_into().ok())
9749 .ok_or_else(|| {
9750 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9751 })
9752 }
9753
9754 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9755 where
9756 E: serde::de::Error,
9757 {
9758 match value {
9759 "LEVEL_TYPE_UNSPECIFIED" => Ok(LevelType::Unspecified),
9760 "LEVEL_TYPE_NONOVERLAPPING" => Ok(LevelType::Nonoverlapping),
9761 "LEVEL_TYPE_OVERLAPPING" => Ok(LevelType::Overlapping),
9762 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9763 }
9764 }
9765 }
9766 deserializer.deserialize_any(GeneratedVisitor)
9767 }
9768}
9769impl serde::Serialize for ListActiveWriteLimitRequest {
9770 #[allow(deprecated)]
9771 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9772 where
9773 S: serde::Serializer,
9774 {
9775 use serde::ser::SerializeStruct;
9776 let len = 0;
9777 let struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitRequest", len)?;
9778 struct_ser.end()
9779 }
9780}
9781impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitRequest {
9782 #[allow(deprecated)]
9783 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9784 where
9785 D: serde::Deserializer<'de>,
9786 {
9787 const FIELDS: &[&str] = &[
9788 ];
9789
9790 #[allow(clippy::enum_variant_names)]
9791 enum GeneratedField {
9792 }
9793 impl<'de> serde::Deserialize<'de> for GeneratedField {
9794 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9795 where
9796 D: serde::Deserializer<'de>,
9797 {
9798 struct GeneratedVisitor;
9799
9800 impl serde::de::Visitor<'_> for GeneratedVisitor {
9801 type Value = GeneratedField;
9802
9803 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9804 write!(formatter, "expected one of: {:?}", &FIELDS)
9805 }
9806
9807 #[allow(unused_variables)]
9808 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9809 where
9810 E: serde::de::Error,
9811 {
9812 Err(serde::de::Error::unknown_field(value, FIELDS))
9813 }
9814 }
9815 deserializer.deserialize_identifier(GeneratedVisitor)
9816 }
9817 }
9818 struct GeneratedVisitor;
9819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9820 type Value = ListActiveWriteLimitRequest;
9821
9822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9823 formatter.write_str("struct hummock.ListActiveWriteLimitRequest")
9824 }
9825
9826 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitRequest, V::Error>
9827 where
9828 V: serde::de::MapAccess<'de>,
9829 {
9830 while map_.next_key::<GeneratedField>()?.is_some() {
9831 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9832 }
9833 Ok(ListActiveWriteLimitRequest {
9834 })
9835 }
9836 }
9837 deserializer.deserialize_struct("hummock.ListActiveWriteLimitRequest", FIELDS, GeneratedVisitor)
9838 }
9839}
9840impl serde::Serialize for ListActiveWriteLimitResponse {
9841 #[allow(deprecated)]
9842 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9843 where
9844 S: serde::Serializer,
9845 {
9846 use serde::ser::SerializeStruct;
9847 let mut len = 0;
9848 if !self.write_limits.is_empty() {
9849 len += 1;
9850 }
9851 let mut struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitResponse", len)?;
9852 if !self.write_limits.is_empty() {
9853 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
9854 }
9855 struct_ser.end()
9856 }
9857}
9858impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitResponse {
9859 #[allow(deprecated)]
9860 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9861 where
9862 D: serde::Deserializer<'de>,
9863 {
9864 const FIELDS: &[&str] = &[
9865 "write_limits",
9866 "writeLimits",
9867 ];
9868
9869 #[allow(clippy::enum_variant_names)]
9870 enum GeneratedField {
9871 WriteLimits,
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 serde::de::Visitor<'_> 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 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
9894 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9895 }
9896 }
9897 }
9898 deserializer.deserialize_identifier(GeneratedVisitor)
9899 }
9900 }
9901 struct GeneratedVisitor;
9902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9903 type Value = ListActiveWriteLimitResponse;
9904
9905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9906 formatter.write_str("struct hummock.ListActiveWriteLimitResponse")
9907 }
9908
9909 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitResponse, V::Error>
9910 where
9911 V: serde::de::MapAccess<'de>,
9912 {
9913 let mut write_limits__ = None;
9914 while let Some(k) = map_.next_key()? {
9915 match k {
9916 GeneratedField::WriteLimits => {
9917 if write_limits__.is_some() {
9918 return Err(serde::de::Error::duplicate_field("writeLimits"));
9919 }
9920 write_limits__ = Some(
9921 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
9922 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9923 );
9924 }
9925 }
9926 }
9927 Ok(ListActiveWriteLimitResponse {
9928 write_limits: write_limits__.unwrap_or_default(),
9929 })
9930 }
9931 }
9932 deserializer.deserialize_struct("hummock.ListActiveWriteLimitResponse", FIELDS, GeneratedVisitor)
9933 }
9934}
9935impl serde::Serialize for ListBranchedObjectRequest {
9936 #[allow(deprecated)]
9937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9938 where
9939 S: serde::Serializer,
9940 {
9941 use serde::ser::SerializeStruct;
9942 let len = 0;
9943 let struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectRequest", len)?;
9944 struct_ser.end()
9945 }
9946}
9947impl<'de> serde::Deserialize<'de> for ListBranchedObjectRequest {
9948 #[allow(deprecated)]
9949 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9950 where
9951 D: serde::Deserializer<'de>,
9952 {
9953 const FIELDS: &[&str] = &[
9954 ];
9955
9956 #[allow(clippy::enum_variant_names)]
9957 enum GeneratedField {
9958 }
9959 impl<'de> serde::Deserialize<'de> for GeneratedField {
9960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9961 where
9962 D: serde::Deserializer<'de>,
9963 {
9964 struct GeneratedVisitor;
9965
9966 impl serde::de::Visitor<'_> for GeneratedVisitor {
9967 type Value = GeneratedField;
9968
9969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9970 write!(formatter, "expected one of: {:?}", &FIELDS)
9971 }
9972
9973 #[allow(unused_variables)]
9974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9975 where
9976 E: serde::de::Error,
9977 {
9978 Err(serde::de::Error::unknown_field(value, FIELDS))
9979 }
9980 }
9981 deserializer.deserialize_identifier(GeneratedVisitor)
9982 }
9983 }
9984 struct GeneratedVisitor;
9985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9986 type Value = ListBranchedObjectRequest;
9987
9988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9989 formatter.write_str("struct hummock.ListBranchedObjectRequest")
9990 }
9991
9992 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectRequest, V::Error>
9993 where
9994 V: serde::de::MapAccess<'de>,
9995 {
9996 while map_.next_key::<GeneratedField>()?.is_some() {
9997 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9998 }
9999 Ok(ListBranchedObjectRequest {
10000 })
10001 }
10002 }
10003 deserializer.deserialize_struct("hummock.ListBranchedObjectRequest", FIELDS, GeneratedVisitor)
10004 }
10005}
10006impl serde::Serialize for ListBranchedObjectResponse {
10007 #[allow(deprecated)]
10008 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10009 where
10010 S: serde::Serializer,
10011 {
10012 use serde::ser::SerializeStruct;
10013 let mut len = 0;
10014 if !self.branched_objects.is_empty() {
10015 len += 1;
10016 }
10017 let mut struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectResponse", len)?;
10018 if !self.branched_objects.is_empty() {
10019 struct_ser.serialize_field("branchedObjects", &self.branched_objects)?;
10020 }
10021 struct_ser.end()
10022 }
10023}
10024impl<'de> serde::Deserialize<'de> for ListBranchedObjectResponse {
10025 #[allow(deprecated)]
10026 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10027 where
10028 D: serde::Deserializer<'de>,
10029 {
10030 const FIELDS: &[&str] = &[
10031 "branched_objects",
10032 "branchedObjects",
10033 ];
10034
10035 #[allow(clippy::enum_variant_names)]
10036 enum GeneratedField {
10037 BranchedObjects,
10038 }
10039 impl<'de> serde::Deserialize<'de> for GeneratedField {
10040 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10041 where
10042 D: serde::Deserializer<'de>,
10043 {
10044 struct GeneratedVisitor;
10045
10046 impl serde::de::Visitor<'_> for GeneratedVisitor {
10047 type Value = GeneratedField;
10048
10049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10050 write!(formatter, "expected one of: {:?}", &FIELDS)
10051 }
10052
10053 #[allow(unused_variables)]
10054 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10055 where
10056 E: serde::de::Error,
10057 {
10058 match value {
10059 "branchedObjects" | "branched_objects" => Ok(GeneratedField::BranchedObjects),
10060 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10061 }
10062 }
10063 }
10064 deserializer.deserialize_identifier(GeneratedVisitor)
10065 }
10066 }
10067 struct GeneratedVisitor;
10068 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10069 type Value = ListBranchedObjectResponse;
10070
10071 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10072 formatter.write_str("struct hummock.ListBranchedObjectResponse")
10073 }
10074
10075 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectResponse, V::Error>
10076 where
10077 V: serde::de::MapAccess<'de>,
10078 {
10079 let mut branched_objects__ = None;
10080 while let Some(k) = map_.next_key()? {
10081 match k {
10082 GeneratedField::BranchedObjects => {
10083 if branched_objects__.is_some() {
10084 return Err(serde::de::Error::duplicate_field("branchedObjects"));
10085 }
10086 branched_objects__ = Some(map_.next_value()?);
10087 }
10088 }
10089 }
10090 Ok(ListBranchedObjectResponse {
10091 branched_objects: branched_objects__.unwrap_or_default(),
10092 })
10093 }
10094 }
10095 deserializer.deserialize_struct("hummock.ListBranchedObjectResponse", FIELDS, GeneratedVisitor)
10096 }
10097}
10098impl serde::Serialize for ListCompactTaskAssignmentRequest {
10099 #[allow(deprecated)]
10100 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10101 where
10102 S: serde::Serializer,
10103 {
10104 use serde::ser::SerializeStruct;
10105 let len = 0;
10106 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentRequest", len)?;
10107 struct_ser.end()
10108 }
10109}
10110impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentRequest {
10111 #[allow(deprecated)]
10112 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10113 where
10114 D: serde::Deserializer<'de>,
10115 {
10116 const FIELDS: &[&str] = &[
10117 ];
10118
10119 #[allow(clippy::enum_variant_names)]
10120 enum GeneratedField {
10121 }
10122 impl<'de> serde::Deserialize<'de> for GeneratedField {
10123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10124 where
10125 D: serde::Deserializer<'de>,
10126 {
10127 struct GeneratedVisitor;
10128
10129 impl serde::de::Visitor<'_> for GeneratedVisitor {
10130 type Value = GeneratedField;
10131
10132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10133 write!(formatter, "expected one of: {:?}", &FIELDS)
10134 }
10135
10136 #[allow(unused_variables)]
10137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10138 where
10139 E: serde::de::Error,
10140 {
10141 Err(serde::de::Error::unknown_field(value, FIELDS))
10142 }
10143 }
10144 deserializer.deserialize_identifier(GeneratedVisitor)
10145 }
10146 }
10147 struct GeneratedVisitor;
10148 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10149 type Value = ListCompactTaskAssignmentRequest;
10150
10151 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10152 formatter.write_str("struct hummock.ListCompactTaskAssignmentRequest")
10153 }
10154
10155 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentRequest, V::Error>
10156 where
10157 V: serde::de::MapAccess<'de>,
10158 {
10159 while map_.next_key::<GeneratedField>()?.is_some() {
10160 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10161 }
10162 Ok(ListCompactTaskAssignmentRequest {
10163 })
10164 }
10165 }
10166 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentRequest", FIELDS, GeneratedVisitor)
10167 }
10168}
10169impl serde::Serialize for ListCompactTaskAssignmentResponse {
10170 #[allow(deprecated)]
10171 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10172 where
10173 S: serde::Serializer,
10174 {
10175 use serde::ser::SerializeStruct;
10176 let mut len = 0;
10177 if !self.task_assignment.is_empty() {
10178 len += 1;
10179 }
10180 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentResponse", len)?;
10181 if !self.task_assignment.is_empty() {
10182 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
10183 }
10184 struct_ser.end()
10185 }
10186}
10187impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentResponse {
10188 #[allow(deprecated)]
10189 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10190 where
10191 D: serde::Deserializer<'de>,
10192 {
10193 const FIELDS: &[&str] = &[
10194 "task_assignment",
10195 "taskAssignment",
10196 ];
10197
10198 #[allow(clippy::enum_variant_names)]
10199 enum GeneratedField {
10200 TaskAssignment,
10201 }
10202 impl<'de> serde::Deserialize<'de> for GeneratedField {
10203 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10204 where
10205 D: serde::Deserializer<'de>,
10206 {
10207 struct GeneratedVisitor;
10208
10209 impl serde::de::Visitor<'_> for GeneratedVisitor {
10210 type Value = GeneratedField;
10211
10212 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10213 write!(formatter, "expected one of: {:?}", &FIELDS)
10214 }
10215
10216 #[allow(unused_variables)]
10217 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10218 where
10219 E: serde::de::Error,
10220 {
10221 match value {
10222 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
10223 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10224 }
10225 }
10226 }
10227 deserializer.deserialize_identifier(GeneratedVisitor)
10228 }
10229 }
10230 struct GeneratedVisitor;
10231 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10232 type Value = ListCompactTaskAssignmentResponse;
10233
10234 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10235 formatter.write_str("struct hummock.ListCompactTaskAssignmentResponse")
10236 }
10237
10238 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentResponse, V::Error>
10239 where
10240 V: serde::de::MapAccess<'de>,
10241 {
10242 let mut task_assignment__ = None;
10243 while let Some(k) = map_.next_key()? {
10244 match k {
10245 GeneratedField::TaskAssignment => {
10246 if task_assignment__.is_some() {
10247 return Err(serde::de::Error::duplicate_field("taskAssignment"));
10248 }
10249 task_assignment__ = Some(map_.next_value()?);
10250 }
10251 }
10252 }
10253 Ok(ListCompactTaskAssignmentResponse {
10254 task_assignment: task_assignment__.unwrap_or_default(),
10255 })
10256 }
10257 }
10258 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentResponse", FIELDS, GeneratedVisitor)
10259 }
10260}
10261impl serde::Serialize for ListCompactTaskProgressRequest {
10262 #[allow(deprecated)]
10263 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10264 where
10265 S: serde::Serializer,
10266 {
10267 use serde::ser::SerializeStruct;
10268 let len = 0;
10269 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressRequest", len)?;
10270 struct_ser.end()
10271 }
10272}
10273impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressRequest {
10274 #[allow(deprecated)]
10275 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10276 where
10277 D: serde::Deserializer<'de>,
10278 {
10279 const FIELDS: &[&str] = &[
10280 ];
10281
10282 #[allow(clippy::enum_variant_names)]
10283 enum GeneratedField {
10284 }
10285 impl<'de> serde::Deserialize<'de> for GeneratedField {
10286 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10287 where
10288 D: serde::Deserializer<'de>,
10289 {
10290 struct GeneratedVisitor;
10291
10292 impl serde::de::Visitor<'_> for GeneratedVisitor {
10293 type Value = GeneratedField;
10294
10295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10296 write!(formatter, "expected one of: {:?}", &FIELDS)
10297 }
10298
10299 #[allow(unused_variables)]
10300 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10301 where
10302 E: serde::de::Error,
10303 {
10304 Err(serde::de::Error::unknown_field(value, FIELDS))
10305 }
10306 }
10307 deserializer.deserialize_identifier(GeneratedVisitor)
10308 }
10309 }
10310 struct GeneratedVisitor;
10311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10312 type Value = ListCompactTaskProgressRequest;
10313
10314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10315 formatter.write_str("struct hummock.ListCompactTaskProgressRequest")
10316 }
10317
10318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressRequest, V::Error>
10319 where
10320 V: serde::de::MapAccess<'de>,
10321 {
10322 while map_.next_key::<GeneratedField>()?.is_some() {
10323 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10324 }
10325 Ok(ListCompactTaskProgressRequest {
10326 })
10327 }
10328 }
10329 deserializer.deserialize_struct("hummock.ListCompactTaskProgressRequest", FIELDS, GeneratedVisitor)
10330 }
10331}
10332impl serde::Serialize for ListCompactTaskProgressResponse {
10333 #[allow(deprecated)]
10334 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10335 where
10336 S: serde::Serializer,
10337 {
10338 use serde::ser::SerializeStruct;
10339 let mut len = 0;
10340 if !self.task_progress.is_empty() {
10341 len += 1;
10342 }
10343 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressResponse", len)?;
10344 if !self.task_progress.is_empty() {
10345 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
10346 }
10347 struct_ser.end()
10348 }
10349}
10350impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressResponse {
10351 #[allow(deprecated)]
10352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10353 where
10354 D: serde::Deserializer<'de>,
10355 {
10356 const FIELDS: &[&str] = &[
10357 "task_progress",
10358 "taskProgress",
10359 ];
10360
10361 #[allow(clippy::enum_variant_names)]
10362 enum GeneratedField {
10363 TaskProgress,
10364 }
10365 impl<'de> serde::Deserialize<'de> for GeneratedField {
10366 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10367 where
10368 D: serde::Deserializer<'de>,
10369 {
10370 struct GeneratedVisitor;
10371
10372 impl serde::de::Visitor<'_> for GeneratedVisitor {
10373 type Value = GeneratedField;
10374
10375 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10376 write!(formatter, "expected one of: {:?}", &FIELDS)
10377 }
10378
10379 #[allow(unused_variables)]
10380 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10381 where
10382 E: serde::de::Error,
10383 {
10384 match value {
10385 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
10386 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10387 }
10388 }
10389 }
10390 deserializer.deserialize_identifier(GeneratedVisitor)
10391 }
10392 }
10393 struct GeneratedVisitor;
10394 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10395 type Value = ListCompactTaskProgressResponse;
10396
10397 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10398 formatter.write_str("struct hummock.ListCompactTaskProgressResponse")
10399 }
10400
10401 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressResponse, V::Error>
10402 where
10403 V: serde::de::MapAccess<'de>,
10404 {
10405 let mut task_progress__ = None;
10406 while let Some(k) = map_.next_key()? {
10407 match k {
10408 GeneratedField::TaskProgress => {
10409 if task_progress__.is_some() {
10410 return Err(serde::de::Error::duplicate_field("taskProgress"));
10411 }
10412 task_progress__ = Some(map_.next_value()?);
10413 }
10414 }
10415 }
10416 Ok(ListCompactTaskProgressResponse {
10417 task_progress: task_progress__.unwrap_or_default(),
10418 })
10419 }
10420 }
10421 deserializer.deserialize_struct("hummock.ListCompactTaskProgressResponse", FIELDS, GeneratedVisitor)
10422 }
10423}
10424impl serde::Serialize for ListHummockMetaConfigRequest {
10425 #[allow(deprecated)]
10426 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10427 where
10428 S: serde::Serializer,
10429 {
10430 use serde::ser::SerializeStruct;
10431 let len = 0;
10432 let struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigRequest", len)?;
10433 struct_ser.end()
10434 }
10435}
10436impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigRequest {
10437 #[allow(deprecated)]
10438 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10439 where
10440 D: serde::Deserializer<'de>,
10441 {
10442 const FIELDS: &[&str] = &[
10443 ];
10444
10445 #[allow(clippy::enum_variant_names)]
10446 enum GeneratedField {
10447 }
10448 impl<'de> serde::Deserialize<'de> for GeneratedField {
10449 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10450 where
10451 D: serde::Deserializer<'de>,
10452 {
10453 struct GeneratedVisitor;
10454
10455 impl serde::de::Visitor<'_> for GeneratedVisitor {
10456 type Value = GeneratedField;
10457
10458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10459 write!(formatter, "expected one of: {:?}", &FIELDS)
10460 }
10461
10462 #[allow(unused_variables)]
10463 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10464 where
10465 E: serde::de::Error,
10466 {
10467 Err(serde::de::Error::unknown_field(value, FIELDS))
10468 }
10469 }
10470 deserializer.deserialize_identifier(GeneratedVisitor)
10471 }
10472 }
10473 struct GeneratedVisitor;
10474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10475 type Value = ListHummockMetaConfigRequest;
10476
10477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10478 formatter.write_str("struct hummock.ListHummockMetaConfigRequest")
10479 }
10480
10481 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigRequest, V::Error>
10482 where
10483 V: serde::de::MapAccess<'de>,
10484 {
10485 while map_.next_key::<GeneratedField>()?.is_some() {
10486 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10487 }
10488 Ok(ListHummockMetaConfigRequest {
10489 })
10490 }
10491 }
10492 deserializer.deserialize_struct("hummock.ListHummockMetaConfigRequest", FIELDS, GeneratedVisitor)
10493 }
10494}
10495impl serde::Serialize for ListHummockMetaConfigResponse {
10496 #[allow(deprecated)]
10497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10498 where
10499 S: serde::Serializer,
10500 {
10501 use serde::ser::SerializeStruct;
10502 let mut len = 0;
10503 if !self.configs.is_empty() {
10504 len += 1;
10505 }
10506 let mut struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigResponse", len)?;
10507 if !self.configs.is_empty() {
10508 struct_ser.serialize_field("configs", &self.configs)?;
10509 }
10510 struct_ser.end()
10511 }
10512}
10513impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigResponse {
10514 #[allow(deprecated)]
10515 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10516 where
10517 D: serde::Deserializer<'de>,
10518 {
10519 const FIELDS: &[&str] = &[
10520 "configs",
10521 ];
10522
10523 #[allow(clippy::enum_variant_names)]
10524 enum GeneratedField {
10525 Configs,
10526 }
10527 impl<'de> serde::Deserialize<'de> for GeneratedField {
10528 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10529 where
10530 D: serde::Deserializer<'de>,
10531 {
10532 struct GeneratedVisitor;
10533
10534 impl serde::de::Visitor<'_> for GeneratedVisitor {
10535 type Value = GeneratedField;
10536
10537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10538 write!(formatter, "expected one of: {:?}", &FIELDS)
10539 }
10540
10541 #[allow(unused_variables)]
10542 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10543 where
10544 E: serde::de::Error,
10545 {
10546 match value {
10547 "configs" => Ok(GeneratedField::Configs),
10548 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10549 }
10550 }
10551 }
10552 deserializer.deserialize_identifier(GeneratedVisitor)
10553 }
10554 }
10555 struct GeneratedVisitor;
10556 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10557 type Value = ListHummockMetaConfigResponse;
10558
10559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10560 formatter.write_str("struct hummock.ListHummockMetaConfigResponse")
10561 }
10562
10563 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigResponse, V::Error>
10564 where
10565 V: serde::de::MapAccess<'de>,
10566 {
10567 let mut configs__ = None;
10568 while let Some(k) = map_.next_key()? {
10569 match k {
10570 GeneratedField::Configs => {
10571 if configs__.is_some() {
10572 return Err(serde::de::Error::duplicate_field("configs"));
10573 }
10574 configs__ = Some(
10575 map_.next_value::<std::collections::HashMap<_, _>>()?
10576 );
10577 }
10578 }
10579 }
10580 Ok(ListHummockMetaConfigResponse {
10581 configs: configs__.unwrap_or_default(),
10582 })
10583 }
10584 }
10585 deserializer.deserialize_struct("hummock.ListHummockMetaConfigResponse", FIELDS, GeneratedVisitor)
10586 }
10587}
10588impl serde::Serialize for ListVersionDeltasRequest {
10589 #[allow(deprecated)]
10590 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10591 where
10592 S: serde::Serializer,
10593 {
10594 use serde::ser::SerializeStruct;
10595 let mut len = 0;
10596 if self.start_id != 0 {
10597 len += 1;
10598 }
10599 if self.num_limit != 0 {
10600 len += 1;
10601 }
10602 if self.committed_epoch_limit != 0 {
10603 len += 1;
10604 }
10605 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasRequest", len)?;
10606 if self.start_id != 0 {
10607 #[allow(clippy::needless_borrow)]
10608 #[allow(clippy::needless_borrows_for_generic_args)]
10609 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
10610 }
10611 if self.num_limit != 0 {
10612 struct_ser.serialize_field("numLimit", &self.num_limit)?;
10613 }
10614 if self.committed_epoch_limit != 0 {
10615 #[allow(clippy::needless_borrow)]
10616 #[allow(clippy::needless_borrows_for_generic_args)]
10617 struct_ser.serialize_field("committedEpochLimit", ToString::to_string(&self.committed_epoch_limit).as_str())?;
10618 }
10619 struct_ser.end()
10620 }
10621}
10622impl<'de> serde::Deserialize<'de> for ListVersionDeltasRequest {
10623 #[allow(deprecated)]
10624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10625 where
10626 D: serde::Deserializer<'de>,
10627 {
10628 const FIELDS: &[&str] = &[
10629 "start_id",
10630 "startId",
10631 "num_limit",
10632 "numLimit",
10633 "committed_epoch_limit",
10634 "committedEpochLimit",
10635 ];
10636
10637 #[allow(clippy::enum_variant_names)]
10638 enum GeneratedField {
10639 StartId,
10640 NumLimit,
10641 CommittedEpochLimit,
10642 }
10643 impl<'de> serde::Deserialize<'de> for GeneratedField {
10644 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10645 where
10646 D: serde::Deserializer<'de>,
10647 {
10648 struct GeneratedVisitor;
10649
10650 impl serde::de::Visitor<'_> for GeneratedVisitor {
10651 type Value = GeneratedField;
10652
10653 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10654 write!(formatter, "expected one of: {:?}", &FIELDS)
10655 }
10656
10657 #[allow(unused_variables)]
10658 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10659 where
10660 E: serde::de::Error,
10661 {
10662 match value {
10663 "startId" | "start_id" => Ok(GeneratedField::StartId),
10664 "numLimit" | "num_limit" => Ok(GeneratedField::NumLimit),
10665 "committedEpochLimit" | "committed_epoch_limit" => Ok(GeneratedField::CommittedEpochLimit),
10666 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10667 }
10668 }
10669 }
10670 deserializer.deserialize_identifier(GeneratedVisitor)
10671 }
10672 }
10673 struct GeneratedVisitor;
10674 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10675 type Value = ListVersionDeltasRequest;
10676
10677 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10678 formatter.write_str("struct hummock.ListVersionDeltasRequest")
10679 }
10680
10681 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasRequest, V::Error>
10682 where
10683 V: serde::de::MapAccess<'de>,
10684 {
10685 let mut start_id__ = None;
10686 let mut num_limit__ = None;
10687 let mut committed_epoch_limit__ = None;
10688 while let Some(k) = map_.next_key()? {
10689 match k {
10690 GeneratedField::StartId => {
10691 if start_id__.is_some() {
10692 return Err(serde::de::Error::duplicate_field("startId"));
10693 }
10694 start_id__ =
10695 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10696 ;
10697 }
10698 GeneratedField::NumLimit => {
10699 if num_limit__.is_some() {
10700 return Err(serde::de::Error::duplicate_field("numLimit"));
10701 }
10702 num_limit__ =
10703 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10704 ;
10705 }
10706 GeneratedField::CommittedEpochLimit => {
10707 if committed_epoch_limit__.is_some() {
10708 return Err(serde::de::Error::duplicate_field("committedEpochLimit"));
10709 }
10710 committed_epoch_limit__ =
10711 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10712 ;
10713 }
10714 }
10715 }
10716 Ok(ListVersionDeltasRequest {
10717 start_id: start_id__.unwrap_or_default(),
10718 num_limit: num_limit__.unwrap_or_default(),
10719 committed_epoch_limit: committed_epoch_limit__.unwrap_or_default(),
10720 })
10721 }
10722 }
10723 deserializer.deserialize_struct("hummock.ListVersionDeltasRequest", FIELDS, GeneratedVisitor)
10724 }
10725}
10726impl serde::Serialize for ListVersionDeltasResponse {
10727 #[allow(deprecated)]
10728 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10729 where
10730 S: serde::Serializer,
10731 {
10732 use serde::ser::SerializeStruct;
10733 let mut len = 0;
10734 if self.version_deltas.is_some() {
10735 len += 1;
10736 }
10737 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasResponse", len)?;
10738 if let Some(v) = self.version_deltas.as_ref() {
10739 struct_ser.serialize_field("versionDeltas", v)?;
10740 }
10741 struct_ser.end()
10742 }
10743}
10744impl<'de> serde::Deserialize<'de> for ListVersionDeltasResponse {
10745 #[allow(deprecated)]
10746 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10747 where
10748 D: serde::Deserializer<'de>,
10749 {
10750 const FIELDS: &[&str] = &[
10751 "version_deltas",
10752 "versionDeltas",
10753 ];
10754
10755 #[allow(clippy::enum_variant_names)]
10756 enum GeneratedField {
10757 VersionDeltas,
10758 }
10759 impl<'de> serde::Deserialize<'de> for GeneratedField {
10760 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10761 where
10762 D: serde::Deserializer<'de>,
10763 {
10764 struct GeneratedVisitor;
10765
10766 impl serde::de::Visitor<'_> for GeneratedVisitor {
10767 type Value = GeneratedField;
10768
10769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10770 write!(formatter, "expected one of: {:?}", &FIELDS)
10771 }
10772
10773 #[allow(unused_variables)]
10774 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10775 where
10776 E: serde::de::Error,
10777 {
10778 match value {
10779 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
10780 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10781 }
10782 }
10783 }
10784 deserializer.deserialize_identifier(GeneratedVisitor)
10785 }
10786 }
10787 struct GeneratedVisitor;
10788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10789 type Value = ListVersionDeltasResponse;
10790
10791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10792 formatter.write_str("struct hummock.ListVersionDeltasResponse")
10793 }
10794
10795 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasResponse, V::Error>
10796 where
10797 V: serde::de::MapAccess<'de>,
10798 {
10799 let mut version_deltas__ = None;
10800 while let Some(k) = map_.next_key()? {
10801 match k {
10802 GeneratedField::VersionDeltas => {
10803 if version_deltas__.is_some() {
10804 return Err(serde::de::Error::duplicate_field("versionDeltas"));
10805 }
10806 version_deltas__ = map_.next_value()?;
10807 }
10808 }
10809 }
10810 Ok(ListVersionDeltasResponse {
10811 version_deltas: version_deltas__,
10812 })
10813 }
10814 }
10815 deserializer.deserialize_struct("hummock.ListVersionDeltasResponse", FIELDS, GeneratedVisitor)
10816 }
10817}
10818impl serde::Serialize for MergeCompactionGroupRequest {
10819 #[allow(deprecated)]
10820 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10821 where
10822 S: serde::Serializer,
10823 {
10824 use serde::ser::SerializeStruct;
10825 let mut len = 0;
10826 if self.left_group_id != 0 {
10827 len += 1;
10828 }
10829 if self.right_group_id != 0 {
10830 len += 1;
10831 }
10832 let mut struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupRequest", len)?;
10833 if self.left_group_id != 0 {
10834 #[allow(clippy::needless_borrow)]
10835 #[allow(clippy::needless_borrows_for_generic_args)]
10836 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
10837 }
10838 if self.right_group_id != 0 {
10839 #[allow(clippy::needless_borrow)]
10840 #[allow(clippy::needless_borrows_for_generic_args)]
10841 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
10842 }
10843 struct_ser.end()
10844 }
10845}
10846impl<'de> serde::Deserialize<'de> for MergeCompactionGroupRequest {
10847 #[allow(deprecated)]
10848 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10849 where
10850 D: serde::Deserializer<'de>,
10851 {
10852 const FIELDS: &[&str] = &[
10853 "left_group_id",
10854 "leftGroupId",
10855 "right_group_id",
10856 "rightGroupId",
10857 ];
10858
10859 #[allow(clippy::enum_variant_names)]
10860 enum GeneratedField {
10861 LeftGroupId,
10862 RightGroupId,
10863 }
10864 impl<'de> serde::Deserialize<'de> for GeneratedField {
10865 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10866 where
10867 D: serde::Deserializer<'de>,
10868 {
10869 struct GeneratedVisitor;
10870
10871 impl serde::de::Visitor<'_> for GeneratedVisitor {
10872 type Value = GeneratedField;
10873
10874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10875 write!(formatter, "expected one of: {:?}", &FIELDS)
10876 }
10877
10878 #[allow(unused_variables)]
10879 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10880 where
10881 E: serde::de::Error,
10882 {
10883 match value {
10884 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
10885 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
10886 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10887 }
10888 }
10889 }
10890 deserializer.deserialize_identifier(GeneratedVisitor)
10891 }
10892 }
10893 struct GeneratedVisitor;
10894 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10895 type Value = MergeCompactionGroupRequest;
10896
10897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10898 formatter.write_str("struct hummock.MergeCompactionGroupRequest")
10899 }
10900
10901 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupRequest, V::Error>
10902 where
10903 V: serde::de::MapAccess<'de>,
10904 {
10905 let mut left_group_id__ = None;
10906 let mut right_group_id__ = None;
10907 while let Some(k) = map_.next_key()? {
10908 match k {
10909 GeneratedField::LeftGroupId => {
10910 if left_group_id__.is_some() {
10911 return Err(serde::de::Error::duplicate_field("leftGroupId"));
10912 }
10913 left_group_id__ =
10914 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10915 ;
10916 }
10917 GeneratedField::RightGroupId => {
10918 if right_group_id__.is_some() {
10919 return Err(serde::de::Error::duplicate_field("rightGroupId"));
10920 }
10921 right_group_id__ =
10922 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10923 ;
10924 }
10925 }
10926 }
10927 Ok(MergeCompactionGroupRequest {
10928 left_group_id: left_group_id__.unwrap_or_default(),
10929 right_group_id: right_group_id__.unwrap_or_default(),
10930 })
10931 }
10932 }
10933 deserializer.deserialize_struct("hummock.MergeCompactionGroupRequest", FIELDS, GeneratedVisitor)
10934 }
10935}
10936impl serde::Serialize for MergeCompactionGroupResponse {
10937 #[allow(deprecated)]
10938 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10939 where
10940 S: serde::Serializer,
10941 {
10942 use serde::ser::SerializeStruct;
10943 let len = 0;
10944 let struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupResponse", len)?;
10945 struct_ser.end()
10946 }
10947}
10948impl<'de> serde::Deserialize<'de> for MergeCompactionGroupResponse {
10949 #[allow(deprecated)]
10950 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10951 where
10952 D: serde::Deserializer<'de>,
10953 {
10954 const FIELDS: &[&str] = &[
10955 ];
10956
10957 #[allow(clippy::enum_variant_names)]
10958 enum GeneratedField {
10959 }
10960 impl<'de> serde::Deserialize<'de> for GeneratedField {
10961 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10962 where
10963 D: serde::Deserializer<'de>,
10964 {
10965 struct GeneratedVisitor;
10966
10967 impl serde::de::Visitor<'_> for GeneratedVisitor {
10968 type Value = GeneratedField;
10969
10970 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10971 write!(formatter, "expected one of: {:?}", &FIELDS)
10972 }
10973
10974 #[allow(unused_variables)]
10975 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10976 where
10977 E: serde::de::Error,
10978 {
10979 Err(serde::de::Error::unknown_field(value, FIELDS))
10980 }
10981 }
10982 deserializer.deserialize_identifier(GeneratedVisitor)
10983 }
10984 }
10985 struct GeneratedVisitor;
10986 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10987 type Value = MergeCompactionGroupResponse;
10988
10989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10990 formatter.write_str("struct hummock.MergeCompactionGroupResponse")
10991 }
10992
10993 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupResponse, V::Error>
10994 where
10995 V: serde::de::MapAccess<'de>,
10996 {
10997 while map_.next_key::<GeneratedField>()?.is_some() {
10998 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10999 }
11000 Ok(MergeCompactionGroupResponse {
11001 })
11002 }
11003 }
11004 deserializer.deserialize_struct("hummock.MergeCompactionGroupResponse", FIELDS, GeneratedVisitor)
11005 }
11006}
11007impl serde::Serialize for NewL0SubLevel {
11008 #[allow(deprecated)]
11009 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11010 where
11011 S: serde::Serializer,
11012 {
11013 use serde::ser::SerializeStruct;
11014 let mut len = 0;
11015 if !self.inserted_table_infos.is_empty() {
11016 len += 1;
11017 }
11018 let mut struct_ser = serializer.serialize_struct("hummock.NewL0SubLevel", len)?;
11019 if !self.inserted_table_infos.is_empty() {
11020 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
11021 }
11022 struct_ser.end()
11023 }
11024}
11025impl<'de> serde::Deserialize<'de> for NewL0SubLevel {
11026 #[allow(deprecated)]
11027 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11028 where
11029 D: serde::Deserializer<'de>,
11030 {
11031 const FIELDS: &[&str] = &[
11032 "inserted_table_infos",
11033 "insertedTableInfos",
11034 ];
11035
11036 #[allow(clippy::enum_variant_names)]
11037 enum GeneratedField {
11038 InsertedTableInfos,
11039 }
11040 impl<'de> serde::Deserialize<'de> for GeneratedField {
11041 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11042 where
11043 D: serde::Deserializer<'de>,
11044 {
11045 struct GeneratedVisitor;
11046
11047 impl serde::de::Visitor<'_> for GeneratedVisitor {
11048 type Value = GeneratedField;
11049
11050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11051 write!(formatter, "expected one of: {:?}", &FIELDS)
11052 }
11053
11054 #[allow(unused_variables)]
11055 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11056 where
11057 E: serde::de::Error,
11058 {
11059 match value {
11060 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
11061 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11062 }
11063 }
11064 }
11065 deserializer.deserialize_identifier(GeneratedVisitor)
11066 }
11067 }
11068 struct GeneratedVisitor;
11069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11070 type Value = NewL0SubLevel;
11071
11072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11073 formatter.write_str("struct hummock.NewL0SubLevel")
11074 }
11075
11076 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NewL0SubLevel, V::Error>
11077 where
11078 V: serde::de::MapAccess<'de>,
11079 {
11080 let mut inserted_table_infos__ = None;
11081 while let Some(k) = map_.next_key()? {
11082 match k {
11083 GeneratedField::InsertedTableInfos => {
11084 if inserted_table_infos__.is_some() {
11085 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
11086 }
11087 inserted_table_infos__ = Some(map_.next_value()?);
11088 }
11089 }
11090 }
11091 Ok(NewL0SubLevel {
11092 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
11093 })
11094 }
11095 }
11096 deserializer.deserialize_struct("hummock.NewL0SubLevel", FIELDS, GeneratedVisitor)
11097 }
11098}
11099impl serde::Serialize for OverlappingLevel {
11100 #[allow(deprecated)]
11101 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11102 where
11103 S: serde::Serializer,
11104 {
11105 use serde::ser::SerializeStruct;
11106 let mut len = 0;
11107 if !self.sub_levels.is_empty() {
11108 len += 1;
11109 }
11110 if self.total_file_size != 0 {
11111 len += 1;
11112 }
11113 if self.uncompressed_file_size != 0 {
11114 len += 1;
11115 }
11116 let mut struct_ser = serializer.serialize_struct("hummock.OverlappingLevel", len)?;
11117 if !self.sub_levels.is_empty() {
11118 struct_ser.serialize_field("subLevels", &self.sub_levels)?;
11119 }
11120 if self.total_file_size != 0 {
11121 #[allow(clippy::needless_borrow)]
11122 #[allow(clippy::needless_borrows_for_generic_args)]
11123 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
11124 }
11125 if self.uncompressed_file_size != 0 {
11126 #[allow(clippy::needless_borrow)]
11127 #[allow(clippy::needless_borrows_for_generic_args)]
11128 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
11129 }
11130 struct_ser.end()
11131 }
11132}
11133impl<'de> serde::Deserialize<'de> for OverlappingLevel {
11134 #[allow(deprecated)]
11135 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11136 where
11137 D: serde::Deserializer<'de>,
11138 {
11139 const FIELDS: &[&str] = &[
11140 "sub_levels",
11141 "subLevels",
11142 "total_file_size",
11143 "totalFileSize",
11144 "uncompressed_file_size",
11145 "uncompressedFileSize",
11146 ];
11147
11148 #[allow(clippy::enum_variant_names)]
11149 enum GeneratedField {
11150 SubLevels,
11151 TotalFileSize,
11152 UncompressedFileSize,
11153 }
11154 impl<'de> serde::Deserialize<'de> for GeneratedField {
11155 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11156 where
11157 D: serde::Deserializer<'de>,
11158 {
11159 struct GeneratedVisitor;
11160
11161 impl serde::de::Visitor<'_> for GeneratedVisitor {
11162 type Value = GeneratedField;
11163
11164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11165 write!(formatter, "expected one of: {:?}", &FIELDS)
11166 }
11167
11168 #[allow(unused_variables)]
11169 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11170 where
11171 E: serde::de::Error,
11172 {
11173 match value {
11174 "subLevels" | "sub_levels" => Ok(GeneratedField::SubLevels),
11175 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
11176 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
11177 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11178 }
11179 }
11180 }
11181 deserializer.deserialize_identifier(GeneratedVisitor)
11182 }
11183 }
11184 struct GeneratedVisitor;
11185 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11186 type Value = OverlappingLevel;
11187
11188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11189 formatter.write_str("struct hummock.OverlappingLevel")
11190 }
11191
11192 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverlappingLevel, V::Error>
11193 where
11194 V: serde::de::MapAccess<'de>,
11195 {
11196 let mut sub_levels__ = None;
11197 let mut total_file_size__ = None;
11198 let mut uncompressed_file_size__ = None;
11199 while let Some(k) = map_.next_key()? {
11200 match k {
11201 GeneratedField::SubLevels => {
11202 if sub_levels__.is_some() {
11203 return Err(serde::de::Error::duplicate_field("subLevels"));
11204 }
11205 sub_levels__ = Some(map_.next_value()?);
11206 }
11207 GeneratedField::TotalFileSize => {
11208 if total_file_size__.is_some() {
11209 return Err(serde::de::Error::duplicate_field("totalFileSize"));
11210 }
11211 total_file_size__ =
11212 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11213 ;
11214 }
11215 GeneratedField::UncompressedFileSize => {
11216 if uncompressed_file_size__.is_some() {
11217 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
11218 }
11219 uncompressed_file_size__ =
11220 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11221 ;
11222 }
11223 }
11224 }
11225 Ok(OverlappingLevel {
11226 sub_levels: sub_levels__.unwrap_or_default(),
11227 total_file_size: total_file_size__.unwrap_or_default(),
11228 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
11229 })
11230 }
11231 }
11232 deserializer.deserialize_struct("hummock.OverlappingLevel", FIELDS, GeneratedVisitor)
11233 }
11234}
11235impl serde::Serialize for PinVersionRequest {
11236 #[allow(deprecated)]
11237 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11238 where
11239 S: serde::Serializer,
11240 {
11241 use serde::ser::SerializeStruct;
11242 let mut len = 0;
11243 if self.context_id != 0 {
11244 len += 1;
11245 }
11246 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionRequest", len)?;
11247 if self.context_id != 0 {
11248 struct_ser.serialize_field("contextId", &self.context_id)?;
11249 }
11250 struct_ser.end()
11251 }
11252}
11253impl<'de> serde::Deserialize<'de> for PinVersionRequest {
11254 #[allow(deprecated)]
11255 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11256 where
11257 D: serde::Deserializer<'de>,
11258 {
11259 const FIELDS: &[&str] = &[
11260 "context_id",
11261 "contextId",
11262 ];
11263
11264 #[allow(clippy::enum_variant_names)]
11265 enum GeneratedField {
11266 ContextId,
11267 }
11268 impl<'de> serde::Deserialize<'de> for GeneratedField {
11269 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11270 where
11271 D: serde::Deserializer<'de>,
11272 {
11273 struct GeneratedVisitor;
11274
11275 impl serde::de::Visitor<'_> for GeneratedVisitor {
11276 type Value = GeneratedField;
11277
11278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11279 write!(formatter, "expected one of: {:?}", &FIELDS)
11280 }
11281
11282 #[allow(unused_variables)]
11283 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11284 where
11285 E: serde::de::Error,
11286 {
11287 match value {
11288 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
11289 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11290 }
11291 }
11292 }
11293 deserializer.deserialize_identifier(GeneratedVisitor)
11294 }
11295 }
11296 struct GeneratedVisitor;
11297 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11298 type Value = PinVersionRequest;
11299
11300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11301 formatter.write_str("struct hummock.PinVersionRequest")
11302 }
11303
11304 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionRequest, V::Error>
11305 where
11306 V: serde::de::MapAccess<'de>,
11307 {
11308 let mut context_id__ = None;
11309 while let Some(k) = map_.next_key()? {
11310 match k {
11311 GeneratedField::ContextId => {
11312 if context_id__.is_some() {
11313 return Err(serde::de::Error::duplicate_field("contextId"));
11314 }
11315 context_id__ =
11316 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11317 ;
11318 }
11319 }
11320 }
11321 Ok(PinVersionRequest {
11322 context_id: context_id__.unwrap_or_default(),
11323 })
11324 }
11325 }
11326 deserializer.deserialize_struct("hummock.PinVersionRequest", FIELDS, GeneratedVisitor)
11327 }
11328}
11329impl serde::Serialize for PinVersionResponse {
11330 #[allow(deprecated)]
11331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11332 where
11333 S: serde::Serializer,
11334 {
11335 use serde::ser::SerializeStruct;
11336 let mut len = 0;
11337 if self.pinned_version.is_some() {
11338 len += 1;
11339 }
11340 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionResponse", len)?;
11341 if let Some(v) = self.pinned_version.as_ref() {
11342 struct_ser.serialize_field("pinnedVersion", v)?;
11343 }
11344 struct_ser.end()
11345 }
11346}
11347impl<'de> serde::Deserialize<'de> for PinVersionResponse {
11348 #[allow(deprecated)]
11349 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11350 where
11351 D: serde::Deserializer<'de>,
11352 {
11353 const FIELDS: &[&str] = &[
11354 "pinned_version",
11355 "pinnedVersion",
11356 ];
11357
11358 #[allow(clippy::enum_variant_names)]
11359 enum GeneratedField {
11360 PinnedVersion,
11361 }
11362 impl<'de> serde::Deserialize<'de> for GeneratedField {
11363 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11364 where
11365 D: serde::Deserializer<'de>,
11366 {
11367 struct GeneratedVisitor;
11368
11369 impl serde::de::Visitor<'_> for GeneratedVisitor {
11370 type Value = GeneratedField;
11371
11372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11373 write!(formatter, "expected one of: {:?}", &FIELDS)
11374 }
11375
11376 #[allow(unused_variables)]
11377 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11378 where
11379 E: serde::de::Error,
11380 {
11381 match value {
11382 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
11383 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11384 }
11385 }
11386 }
11387 deserializer.deserialize_identifier(GeneratedVisitor)
11388 }
11389 }
11390 struct GeneratedVisitor;
11391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11392 type Value = PinVersionResponse;
11393
11394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11395 formatter.write_str("struct hummock.PinVersionResponse")
11396 }
11397
11398 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionResponse, V::Error>
11399 where
11400 V: serde::de::MapAccess<'de>,
11401 {
11402 let mut pinned_version__ = None;
11403 while let Some(k) = map_.next_key()? {
11404 match k {
11405 GeneratedField::PinnedVersion => {
11406 if pinned_version__.is_some() {
11407 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
11408 }
11409 pinned_version__ = map_.next_value()?;
11410 }
11411 }
11412 }
11413 Ok(PinVersionResponse {
11414 pinned_version: pinned_version__,
11415 })
11416 }
11417 }
11418 deserializer.deserialize_struct("hummock.PinVersionResponse", FIELDS, GeneratedVisitor)
11419 }
11420}
11421impl serde::Serialize for PinnedVersionsSummary {
11422 #[allow(deprecated)]
11423 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11424 where
11425 S: serde::Serializer,
11426 {
11427 use serde::ser::SerializeStruct;
11428 let mut len = 0;
11429 if !self.pinned_versions.is_empty() {
11430 len += 1;
11431 }
11432 if !self.workers.is_empty() {
11433 len += 1;
11434 }
11435 let mut struct_ser = serializer.serialize_struct("hummock.PinnedVersionsSummary", len)?;
11436 if !self.pinned_versions.is_empty() {
11437 struct_ser.serialize_field("pinnedVersions", &self.pinned_versions)?;
11438 }
11439 if !self.workers.is_empty() {
11440 struct_ser.serialize_field("workers", &self.workers)?;
11441 }
11442 struct_ser.end()
11443 }
11444}
11445impl<'de> serde::Deserialize<'de> for PinnedVersionsSummary {
11446 #[allow(deprecated)]
11447 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11448 where
11449 D: serde::Deserializer<'de>,
11450 {
11451 const FIELDS: &[&str] = &[
11452 "pinned_versions",
11453 "pinnedVersions",
11454 "workers",
11455 ];
11456
11457 #[allow(clippy::enum_variant_names)]
11458 enum GeneratedField {
11459 PinnedVersions,
11460 Workers,
11461 }
11462 impl<'de> serde::Deserialize<'de> for GeneratedField {
11463 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11464 where
11465 D: serde::Deserializer<'de>,
11466 {
11467 struct GeneratedVisitor;
11468
11469 impl serde::de::Visitor<'_> for GeneratedVisitor {
11470 type Value = GeneratedField;
11471
11472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11473 write!(formatter, "expected one of: {:?}", &FIELDS)
11474 }
11475
11476 #[allow(unused_variables)]
11477 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11478 where
11479 E: serde::de::Error,
11480 {
11481 match value {
11482 "pinnedVersions" | "pinned_versions" => Ok(GeneratedField::PinnedVersions),
11483 "workers" => Ok(GeneratedField::Workers),
11484 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11485 }
11486 }
11487 }
11488 deserializer.deserialize_identifier(GeneratedVisitor)
11489 }
11490 }
11491 struct GeneratedVisitor;
11492 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11493 type Value = PinnedVersionsSummary;
11494
11495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11496 formatter.write_str("struct hummock.PinnedVersionsSummary")
11497 }
11498
11499 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinnedVersionsSummary, V::Error>
11500 where
11501 V: serde::de::MapAccess<'de>,
11502 {
11503 let mut pinned_versions__ = None;
11504 let mut workers__ = None;
11505 while let Some(k) = map_.next_key()? {
11506 match k {
11507 GeneratedField::PinnedVersions => {
11508 if pinned_versions__.is_some() {
11509 return Err(serde::de::Error::duplicate_field("pinnedVersions"));
11510 }
11511 pinned_versions__ = Some(map_.next_value()?);
11512 }
11513 GeneratedField::Workers => {
11514 if workers__.is_some() {
11515 return Err(serde::de::Error::duplicate_field("workers"));
11516 }
11517 workers__ = Some(
11518 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11519 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11520 );
11521 }
11522 }
11523 }
11524 Ok(PinnedVersionsSummary {
11525 pinned_versions: pinned_versions__.unwrap_or_default(),
11526 workers: workers__.unwrap_or_default(),
11527 })
11528 }
11529 }
11530 deserializer.deserialize_struct("hummock.PinnedVersionsSummary", FIELDS, GeneratedVisitor)
11531 }
11532}
11533impl serde::Serialize for ReplayVersionDeltaRequest {
11534 #[allow(deprecated)]
11535 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11536 where
11537 S: serde::Serializer,
11538 {
11539 use serde::ser::SerializeStruct;
11540 let mut len = 0;
11541 if self.version_delta.is_some() {
11542 len += 1;
11543 }
11544 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaRequest", len)?;
11545 if let Some(v) = self.version_delta.as_ref() {
11546 struct_ser.serialize_field("versionDelta", v)?;
11547 }
11548 struct_ser.end()
11549 }
11550}
11551impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaRequest {
11552 #[allow(deprecated)]
11553 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11554 where
11555 D: serde::Deserializer<'de>,
11556 {
11557 const FIELDS: &[&str] = &[
11558 "version_delta",
11559 "versionDelta",
11560 ];
11561
11562 #[allow(clippy::enum_variant_names)]
11563 enum GeneratedField {
11564 VersionDelta,
11565 }
11566 impl<'de> serde::Deserialize<'de> for GeneratedField {
11567 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11568 where
11569 D: serde::Deserializer<'de>,
11570 {
11571 struct GeneratedVisitor;
11572
11573 impl serde::de::Visitor<'_> for GeneratedVisitor {
11574 type Value = GeneratedField;
11575
11576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11577 write!(formatter, "expected one of: {:?}", &FIELDS)
11578 }
11579
11580 #[allow(unused_variables)]
11581 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11582 where
11583 E: serde::de::Error,
11584 {
11585 match value {
11586 "versionDelta" | "version_delta" => Ok(GeneratedField::VersionDelta),
11587 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11588 }
11589 }
11590 }
11591 deserializer.deserialize_identifier(GeneratedVisitor)
11592 }
11593 }
11594 struct GeneratedVisitor;
11595 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11596 type Value = ReplayVersionDeltaRequest;
11597
11598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11599 formatter.write_str("struct hummock.ReplayVersionDeltaRequest")
11600 }
11601
11602 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaRequest, V::Error>
11603 where
11604 V: serde::de::MapAccess<'de>,
11605 {
11606 let mut version_delta__ = None;
11607 while let Some(k) = map_.next_key()? {
11608 match k {
11609 GeneratedField::VersionDelta => {
11610 if version_delta__.is_some() {
11611 return Err(serde::de::Error::duplicate_field("versionDelta"));
11612 }
11613 version_delta__ = map_.next_value()?;
11614 }
11615 }
11616 }
11617 Ok(ReplayVersionDeltaRequest {
11618 version_delta: version_delta__,
11619 })
11620 }
11621 }
11622 deserializer.deserialize_struct("hummock.ReplayVersionDeltaRequest", FIELDS, GeneratedVisitor)
11623 }
11624}
11625impl serde::Serialize for ReplayVersionDeltaResponse {
11626 #[allow(deprecated)]
11627 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11628 where
11629 S: serde::Serializer,
11630 {
11631 use serde::ser::SerializeStruct;
11632 let mut len = 0;
11633 if self.version.is_some() {
11634 len += 1;
11635 }
11636 if !self.modified_compaction_groups.is_empty() {
11637 len += 1;
11638 }
11639 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaResponse", len)?;
11640 if let Some(v) = self.version.as_ref() {
11641 struct_ser.serialize_field("version", v)?;
11642 }
11643 if !self.modified_compaction_groups.is_empty() {
11644 struct_ser.serialize_field("modifiedCompactionGroups", &self.modified_compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
11645 }
11646 struct_ser.end()
11647 }
11648}
11649impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaResponse {
11650 #[allow(deprecated)]
11651 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11652 where
11653 D: serde::Deserializer<'de>,
11654 {
11655 const FIELDS: &[&str] = &[
11656 "version",
11657 "modified_compaction_groups",
11658 "modifiedCompactionGroups",
11659 ];
11660
11661 #[allow(clippy::enum_variant_names)]
11662 enum GeneratedField {
11663 Version,
11664 ModifiedCompactionGroups,
11665 }
11666 impl<'de> serde::Deserialize<'de> for GeneratedField {
11667 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11668 where
11669 D: serde::Deserializer<'de>,
11670 {
11671 struct GeneratedVisitor;
11672
11673 impl serde::de::Visitor<'_> for GeneratedVisitor {
11674 type Value = GeneratedField;
11675
11676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11677 write!(formatter, "expected one of: {:?}", &FIELDS)
11678 }
11679
11680 #[allow(unused_variables)]
11681 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11682 where
11683 E: serde::de::Error,
11684 {
11685 match value {
11686 "version" => Ok(GeneratedField::Version),
11687 "modifiedCompactionGroups" | "modified_compaction_groups" => Ok(GeneratedField::ModifiedCompactionGroups),
11688 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11689 }
11690 }
11691 }
11692 deserializer.deserialize_identifier(GeneratedVisitor)
11693 }
11694 }
11695 struct GeneratedVisitor;
11696 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11697 type Value = ReplayVersionDeltaResponse;
11698
11699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11700 formatter.write_str("struct hummock.ReplayVersionDeltaResponse")
11701 }
11702
11703 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaResponse, V::Error>
11704 where
11705 V: serde::de::MapAccess<'de>,
11706 {
11707 let mut version__ = None;
11708 let mut modified_compaction_groups__ = None;
11709 while let Some(k) = map_.next_key()? {
11710 match k {
11711 GeneratedField::Version => {
11712 if version__.is_some() {
11713 return Err(serde::de::Error::duplicate_field("version"));
11714 }
11715 version__ = map_.next_value()?;
11716 }
11717 GeneratedField::ModifiedCompactionGroups => {
11718 if modified_compaction_groups__.is_some() {
11719 return Err(serde::de::Error::duplicate_field("modifiedCompactionGroups"));
11720 }
11721 modified_compaction_groups__ =
11722 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11723 .into_iter().map(|x| x.0).collect())
11724 ;
11725 }
11726 }
11727 }
11728 Ok(ReplayVersionDeltaResponse {
11729 version: version__,
11730 modified_compaction_groups: modified_compaction_groups__.unwrap_or_default(),
11731 })
11732 }
11733 }
11734 deserializer.deserialize_struct("hummock.ReplayVersionDeltaResponse", FIELDS, GeneratedVisitor)
11735 }
11736}
11737impl serde::Serialize for ReportCompactionTaskRequest {
11738 #[allow(deprecated)]
11739 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11740 where
11741 S: serde::Serializer,
11742 {
11743 use serde::ser::SerializeStruct;
11744 let mut len = 0;
11745 if self.event.is_some() {
11746 len += 1;
11747 }
11748 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest", len)?;
11749 if let Some(v) = self.event.as_ref() {
11750 match v {
11751 report_compaction_task_request::Event::ReportTask(v) => {
11752 struct_ser.serialize_field("reportTask", v)?;
11753 }
11754 report_compaction_task_request::Event::HeartBeat(v) => {
11755 struct_ser.serialize_field("heartBeat", v)?;
11756 }
11757 }
11758 }
11759 struct_ser.end()
11760 }
11761}
11762impl<'de> serde::Deserialize<'de> for ReportCompactionTaskRequest {
11763 #[allow(deprecated)]
11764 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11765 where
11766 D: serde::Deserializer<'de>,
11767 {
11768 const FIELDS: &[&str] = &[
11769 "report_task",
11770 "reportTask",
11771 "heart_beat",
11772 "heartBeat",
11773 ];
11774
11775 #[allow(clippy::enum_variant_names)]
11776 enum GeneratedField {
11777 ReportTask,
11778 HeartBeat,
11779 }
11780 impl<'de> serde::Deserialize<'de> for GeneratedField {
11781 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11782 where
11783 D: serde::Deserializer<'de>,
11784 {
11785 struct GeneratedVisitor;
11786
11787 impl serde::de::Visitor<'_> for GeneratedVisitor {
11788 type Value = GeneratedField;
11789
11790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11791 write!(formatter, "expected one of: {:?}", &FIELDS)
11792 }
11793
11794 #[allow(unused_variables)]
11795 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11796 where
11797 E: serde::de::Error,
11798 {
11799 match value {
11800 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
11801 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
11802 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11803 }
11804 }
11805 }
11806 deserializer.deserialize_identifier(GeneratedVisitor)
11807 }
11808 }
11809 struct GeneratedVisitor;
11810 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11811 type Value = ReportCompactionTaskRequest;
11812
11813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11814 formatter.write_str("struct hummock.ReportCompactionTaskRequest")
11815 }
11816
11817 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskRequest, V::Error>
11818 where
11819 V: serde::de::MapAccess<'de>,
11820 {
11821 let mut event__ = None;
11822 while let Some(k) = map_.next_key()? {
11823 match k {
11824 GeneratedField::ReportTask => {
11825 if event__.is_some() {
11826 return Err(serde::de::Error::duplicate_field("reportTask"));
11827 }
11828 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::ReportTask)
11829;
11830 }
11831 GeneratedField::HeartBeat => {
11832 if event__.is_some() {
11833 return Err(serde::de::Error::duplicate_field("heartBeat"));
11834 }
11835 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::HeartBeat)
11836;
11837 }
11838 }
11839 }
11840 Ok(ReportCompactionTaskRequest {
11841 event: event__,
11842 })
11843 }
11844 }
11845 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest", FIELDS, GeneratedVisitor)
11846 }
11847}
11848impl serde::Serialize for report_compaction_task_request::HeartBeat {
11849 #[allow(deprecated)]
11850 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11851 where
11852 S: serde::Serializer,
11853 {
11854 use serde::ser::SerializeStruct;
11855 let mut len = 0;
11856 if !self.progress.is_empty() {
11857 len += 1;
11858 }
11859 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", len)?;
11860 if !self.progress.is_empty() {
11861 struct_ser.serialize_field("progress", &self.progress)?;
11862 }
11863 struct_ser.end()
11864 }
11865}
11866impl<'de> serde::Deserialize<'de> for report_compaction_task_request::HeartBeat {
11867 #[allow(deprecated)]
11868 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11869 where
11870 D: serde::Deserializer<'de>,
11871 {
11872 const FIELDS: &[&str] = &[
11873 "progress",
11874 ];
11875
11876 #[allow(clippy::enum_variant_names)]
11877 enum GeneratedField {
11878 Progress,
11879 }
11880 impl<'de> serde::Deserialize<'de> for GeneratedField {
11881 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11882 where
11883 D: serde::Deserializer<'de>,
11884 {
11885 struct GeneratedVisitor;
11886
11887 impl serde::de::Visitor<'_> for GeneratedVisitor {
11888 type Value = GeneratedField;
11889
11890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11891 write!(formatter, "expected one of: {:?}", &FIELDS)
11892 }
11893
11894 #[allow(unused_variables)]
11895 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11896 where
11897 E: serde::de::Error,
11898 {
11899 match value {
11900 "progress" => Ok(GeneratedField::Progress),
11901 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11902 }
11903 }
11904 }
11905 deserializer.deserialize_identifier(GeneratedVisitor)
11906 }
11907 }
11908 struct GeneratedVisitor;
11909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11910 type Value = report_compaction_task_request::HeartBeat;
11911
11912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11913 formatter.write_str("struct hummock.ReportCompactionTaskRequest.HeartBeat")
11914 }
11915
11916 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::HeartBeat, V::Error>
11917 where
11918 V: serde::de::MapAccess<'de>,
11919 {
11920 let mut progress__ = None;
11921 while let Some(k) = map_.next_key()? {
11922 match k {
11923 GeneratedField::Progress => {
11924 if progress__.is_some() {
11925 return Err(serde::de::Error::duplicate_field("progress"));
11926 }
11927 progress__ = Some(map_.next_value()?);
11928 }
11929 }
11930 }
11931 Ok(report_compaction_task_request::HeartBeat {
11932 progress: progress__.unwrap_or_default(),
11933 })
11934 }
11935 }
11936 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", FIELDS, GeneratedVisitor)
11937 }
11938}
11939impl serde::Serialize for report_compaction_task_request::ReportTask {
11940 #[allow(deprecated)]
11941 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11942 where
11943 S: serde::Serializer,
11944 {
11945 use serde::ser::SerializeStruct;
11946 let mut len = 0;
11947 if self.compact_task.is_some() {
11948 len += 1;
11949 }
11950 if !self.table_stats_change.is_empty() {
11951 len += 1;
11952 }
11953 if !self.object_timestamps.is_empty() {
11954 len += 1;
11955 }
11956 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", len)?;
11957 if let Some(v) = self.compact_task.as_ref() {
11958 struct_ser.serialize_field("compactTask", v)?;
11959 }
11960 if !self.table_stats_change.is_empty() {
11961 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
11962 }
11963 if !self.object_timestamps.is_empty() {
11964 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
11965 .map(|(k, v)| (k, v.to_string())).collect();
11966 struct_ser.serialize_field("objectTimestamps", &v)?;
11967 }
11968 struct_ser.end()
11969 }
11970}
11971impl<'de> serde::Deserialize<'de> for report_compaction_task_request::ReportTask {
11972 #[allow(deprecated)]
11973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11974 where
11975 D: serde::Deserializer<'de>,
11976 {
11977 const FIELDS: &[&str] = &[
11978 "compact_task",
11979 "compactTask",
11980 "table_stats_change",
11981 "tableStatsChange",
11982 "object_timestamps",
11983 "objectTimestamps",
11984 ];
11985
11986 #[allow(clippy::enum_variant_names)]
11987 enum GeneratedField {
11988 CompactTask,
11989 TableStatsChange,
11990 ObjectTimestamps,
11991 }
11992 impl<'de> serde::Deserialize<'de> for GeneratedField {
11993 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11994 where
11995 D: serde::Deserializer<'de>,
11996 {
11997 struct GeneratedVisitor;
11998
11999 impl serde::de::Visitor<'_> for GeneratedVisitor {
12000 type Value = GeneratedField;
12001
12002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12003 write!(formatter, "expected one of: {:?}", &FIELDS)
12004 }
12005
12006 #[allow(unused_variables)]
12007 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12008 where
12009 E: serde::de::Error,
12010 {
12011 match value {
12012 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
12013 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
12014 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
12015 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12016 }
12017 }
12018 }
12019 deserializer.deserialize_identifier(GeneratedVisitor)
12020 }
12021 }
12022 struct GeneratedVisitor;
12023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12024 type Value = report_compaction_task_request::ReportTask;
12025
12026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12027 formatter.write_str("struct hummock.ReportCompactionTaskRequest.ReportTask")
12028 }
12029
12030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::ReportTask, V::Error>
12031 where
12032 V: serde::de::MapAccess<'de>,
12033 {
12034 let mut compact_task__ = None;
12035 let mut table_stats_change__ = None;
12036 let mut object_timestamps__ = None;
12037 while let Some(k) = map_.next_key()? {
12038 match k {
12039 GeneratedField::CompactTask => {
12040 if compact_task__.is_some() {
12041 return Err(serde::de::Error::duplicate_field("compactTask"));
12042 }
12043 compact_task__ = map_.next_value()?;
12044 }
12045 GeneratedField::TableStatsChange => {
12046 if table_stats_change__.is_some() {
12047 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
12048 }
12049 table_stats_change__ = Some(
12050 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12051 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12052 );
12053 }
12054 GeneratedField::ObjectTimestamps => {
12055 if object_timestamps__.is_some() {
12056 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
12057 }
12058 object_timestamps__ = Some(
12059 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
12060 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
12061 );
12062 }
12063 }
12064 }
12065 Ok(report_compaction_task_request::ReportTask {
12066 compact_task: compact_task__,
12067 table_stats_change: table_stats_change__.unwrap_or_default(),
12068 object_timestamps: object_timestamps__.unwrap_or_default(),
12069 })
12070 }
12071 }
12072 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", FIELDS, GeneratedVisitor)
12073 }
12074}
12075impl serde::Serialize for ReportCompactionTaskResponse {
12076 #[allow(deprecated)]
12077 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12078 where
12079 S: serde::Serializer,
12080 {
12081 use serde::ser::SerializeStruct;
12082 let mut len = 0;
12083 if self.status.is_some() {
12084 len += 1;
12085 }
12086 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskResponse", len)?;
12087 if let Some(v) = self.status.as_ref() {
12088 struct_ser.serialize_field("status", v)?;
12089 }
12090 struct_ser.end()
12091 }
12092}
12093impl<'de> serde::Deserialize<'de> for ReportCompactionTaskResponse {
12094 #[allow(deprecated)]
12095 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12096 where
12097 D: serde::Deserializer<'de>,
12098 {
12099 const FIELDS: &[&str] = &[
12100 "status",
12101 ];
12102
12103 #[allow(clippy::enum_variant_names)]
12104 enum GeneratedField {
12105 Status,
12106 }
12107 impl<'de> serde::Deserialize<'de> for GeneratedField {
12108 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12109 where
12110 D: serde::Deserializer<'de>,
12111 {
12112 struct GeneratedVisitor;
12113
12114 impl serde::de::Visitor<'_> for GeneratedVisitor {
12115 type Value = GeneratedField;
12116
12117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12118 write!(formatter, "expected one of: {:?}", &FIELDS)
12119 }
12120
12121 #[allow(unused_variables)]
12122 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12123 where
12124 E: serde::de::Error,
12125 {
12126 match value {
12127 "status" => Ok(GeneratedField::Status),
12128 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12129 }
12130 }
12131 }
12132 deserializer.deserialize_identifier(GeneratedVisitor)
12133 }
12134 }
12135 struct GeneratedVisitor;
12136 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12137 type Value = ReportCompactionTaskResponse;
12138
12139 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12140 formatter.write_str("struct hummock.ReportCompactionTaskResponse")
12141 }
12142
12143 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskResponse, V::Error>
12144 where
12145 V: serde::de::MapAccess<'de>,
12146 {
12147 let mut status__ = None;
12148 while let Some(k) = map_.next_key()? {
12149 match k {
12150 GeneratedField::Status => {
12151 if status__.is_some() {
12152 return Err(serde::de::Error::duplicate_field("status"));
12153 }
12154 status__ = map_.next_value()?;
12155 }
12156 }
12157 }
12158 Ok(ReportCompactionTaskResponse {
12159 status: status__,
12160 })
12161 }
12162 }
12163 deserializer.deserialize_struct("hummock.ReportCompactionTaskResponse", FIELDS, GeneratedVisitor)
12164 }
12165}
12166impl serde::Serialize for RiseCtlGetCheckpointVersionRequest {
12167 #[allow(deprecated)]
12168 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12169 where
12170 S: serde::Serializer,
12171 {
12172 use serde::ser::SerializeStruct;
12173 let len = 0;
12174 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", len)?;
12175 struct_ser.end()
12176 }
12177}
12178impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionRequest {
12179 #[allow(deprecated)]
12180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12181 where
12182 D: serde::Deserializer<'de>,
12183 {
12184 const FIELDS: &[&str] = &[
12185 ];
12186
12187 #[allow(clippy::enum_variant_names)]
12188 enum GeneratedField {
12189 }
12190 impl<'de> serde::Deserialize<'de> for GeneratedField {
12191 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12192 where
12193 D: serde::Deserializer<'de>,
12194 {
12195 struct GeneratedVisitor;
12196
12197 impl serde::de::Visitor<'_> for GeneratedVisitor {
12198 type Value = GeneratedField;
12199
12200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12201 write!(formatter, "expected one of: {:?}", &FIELDS)
12202 }
12203
12204 #[allow(unused_variables)]
12205 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12206 where
12207 E: serde::de::Error,
12208 {
12209 Err(serde::de::Error::unknown_field(value, FIELDS))
12210 }
12211 }
12212 deserializer.deserialize_identifier(GeneratedVisitor)
12213 }
12214 }
12215 struct GeneratedVisitor;
12216 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12217 type Value = RiseCtlGetCheckpointVersionRequest;
12218
12219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12220 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionRequest")
12221 }
12222
12223 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionRequest, V::Error>
12224 where
12225 V: serde::de::MapAccess<'de>,
12226 {
12227 while map_.next_key::<GeneratedField>()?.is_some() {
12228 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12229 }
12230 Ok(RiseCtlGetCheckpointVersionRequest {
12231 })
12232 }
12233 }
12234 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", FIELDS, GeneratedVisitor)
12235 }
12236}
12237impl serde::Serialize for RiseCtlGetCheckpointVersionResponse {
12238 #[allow(deprecated)]
12239 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12240 where
12241 S: serde::Serializer,
12242 {
12243 use serde::ser::SerializeStruct;
12244 let mut len = 0;
12245 if self.checkpoint_version.is_some() {
12246 len += 1;
12247 }
12248 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", len)?;
12249 if let Some(v) = self.checkpoint_version.as_ref() {
12250 struct_ser.serialize_field("checkpointVersion", v)?;
12251 }
12252 struct_ser.end()
12253 }
12254}
12255impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionResponse {
12256 #[allow(deprecated)]
12257 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12258 where
12259 D: serde::Deserializer<'de>,
12260 {
12261 const FIELDS: &[&str] = &[
12262 "checkpoint_version",
12263 "checkpointVersion",
12264 ];
12265
12266 #[allow(clippy::enum_variant_names)]
12267 enum GeneratedField {
12268 CheckpointVersion,
12269 }
12270 impl<'de> serde::Deserialize<'de> for GeneratedField {
12271 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12272 where
12273 D: serde::Deserializer<'de>,
12274 {
12275 struct GeneratedVisitor;
12276
12277 impl serde::de::Visitor<'_> for GeneratedVisitor {
12278 type Value = GeneratedField;
12279
12280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12281 write!(formatter, "expected one of: {:?}", &FIELDS)
12282 }
12283
12284 #[allow(unused_variables)]
12285 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12286 where
12287 E: serde::de::Error,
12288 {
12289 match value {
12290 "checkpointVersion" | "checkpoint_version" => Ok(GeneratedField::CheckpointVersion),
12291 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12292 }
12293 }
12294 }
12295 deserializer.deserialize_identifier(GeneratedVisitor)
12296 }
12297 }
12298 struct GeneratedVisitor;
12299 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12300 type Value = RiseCtlGetCheckpointVersionResponse;
12301
12302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12303 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionResponse")
12304 }
12305
12306 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionResponse, V::Error>
12307 where
12308 V: serde::de::MapAccess<'de>,
12309 {
12310 let mut checkpoint_version__ = None;
12311 while let Some(k) = map_.next_key()? {
12312 match k {
12313 GeneratedField::CheckpointVersion => {
12314 if checkpoint_version__.is_some() {
12315 return Err(serde::de::Error::duplicate_field("checkpointVersion"));
12316 }
12317 checkpoint_version__ = map_.next_value()?;
12318 }
12319 }
12320 }
12321 Ok(RiseCtlGetCheckpointVersionResponse {
12322 checkpoint_version: checkpoint_version__,
12323 })
12324 }
12325 }
12326 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", FIELDS, GeneratedVisitor)
12327 }
12328}
12329impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryRequest {
12330 #[allow(deprecated)]
12331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12332 where
12333 S: serde::Serializer,
12334 {
12335 use serde::ser::SerializeStruct;
12336 let len = 0;
12337 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", len)?;
12338 struct_ser.end()
12339 }
12340}
12341impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryRequest {
12342 #[allow(deprecated)]
12343 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12344 where
12345 D: serde::Deserializer<'de>,
12346 {
12347 const FIELDS: &[&str] = &[
12348 ];
12349
12350 #[allow(clippy::enum_variant_names)]
12351 enum GeneratedField {
12352 }
12353 impl<'de> serde::Deserialize<'de> for GeneratedField {
12354 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12355 where
12356 D: serde::Deserializer<'de>,
12357 {
12358 struct GeneratedVisitor;
12359
12360 impl serde::de::Visitor<'_> for GeneratedVisitor {
12361 type Value = GeneratedField;
12362
12363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12364 write!(formatter, "expected one of: {:?}", &FIELDS)
12365 }
12366
12367 #[allow(unused_variables)]
12368 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12369 where
12370 E: serde::de::Error,
12371 {
12372 Err(serde::de::Error::unknown_field(value, FIELDS))
12373 }
12374 }
12375 deserializer.deserialize_identifier(GeneratedVisitor)
12376 }
12377 }
12378 struct GeneratedVisitor;
12379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12380 type Value = RiseCtlGetPinnedVersionsSummaryRequest;
12381
12382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12383 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryRequest")
12384 }
12385
12386 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryRequest, V::Error>
12387 where
12388 V: serde::de::MapAccess<'de>,
12389 {
12390 while map_.next_key::<GeneratedField>()?.is_some() {
12391 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12392 }
12393 Ok(RiseCtlGetPinnedVersionsSummaryRequest {
12394 })
12395 }
12396 }
12397 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", FIELDS, GeneratedVisitor)
12398 }
12399}
12400impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryResponse {
12401 #[allow(deprecated)]
12402 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12403 where
12404 S: serde::Serializer,
12405 {
12406 use serde::ser::SerializeStruct;
12407 let mut len = 0;
12408 if self.summary.is_some() {
12409 len += 1;
12410 }
12411 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", len)?;
12412 if let Some(v) = self.summary.as_ref() {
12413 struct_ser.serialize_field("summary", v)?;
12414 }
12415 struct_ser.end()
12416 }
12417}
12418impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryResponse {
12419 #[allow(deprecated)]
12420 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12421 where
12422 D: serde::Deserializer<'de>,
12423 {
12424 const FIELDS: &[&str] = &[
12425 "summary",
12426 ];
12427
12428 #[allow(clippy::enum_variant_names)]
12429 enum GeneratedField {
12430 Summary,
12431 }
12432 impl<'de> serde::Deserialize<'de> for GeneratedField {
12433 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12434 where
12435 D: serde::Deserializer<'de>,
12436 {
12437 struct GeneratedVisitor;
12438
12439 impl serde::de::Visitor<'_> for GeneratedVisitor {
12440 type Value = GeneratedField;
12441
12442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12443 write!(formatter, "expected one of: {:?}", &FIELDS)
12444 }
12445
12446 #[allow(unused_variables)]
12447 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12448 where
12449 E: serde::de::Error,
12450 {
12451 match value {
12452 "summary" => Ok(GeneratedField::Summary),
12453 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12454 }
12455 }
12456 }
12457 deserializer.deserialize_identifier(GeneratedVisitor)
12458 }
12459 }
12460 struct GeneratedVisitor;
12461 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12462 type Value = RiseCtlGetPinnedVersionsSummaryResponse;
12463
12464 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12465 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryResponse")
12466 }
12467
12468 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryResponse, V::Error>
12469 where
12470 V: serde::de::MapAccess<'de>,
12471 {
12472 let mut summary__ = None;
12473 while let Some(k) = map_.next_key()? {
12474 match k {
12475 GeneratedField::Summary => {
12476 if summary__.is_some() {
12477 return Err(serde::de::Error::duplicate_field("summary"));
12478 }
12479 summary__ = map_.next_value()?;
12480 }
12481 }
12482 }
12483 Ok(RiseCtlGetPinnedVersionsSummaryResponse {
12484 summary: summary__,
12485 })
12486 }
12487 }
12488 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", FIELDS, GeneratedVisitor)
12489 }
12490}
12491impl serde::Serialize for RiseCtlListCompactionGroupRequest {
12492 #[allow(deprecated)]
12493 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12494 where
12495 S: serde::Serializer,
12496 {
12497 use serde::ser::SerializeStruct;
12498 let len = 0;
12499 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupRequest", len)?;
12500 struct_ser.end()
12501 }
12502}
12503impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupRequest {
12504 #[allow(deprecated)]
12505 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12506 where
12507 D: serde::Deserializer<'de>,
12508 {
12509 const FIELDS: &[&str] = &[
12510 ];
12511
12512 #[allow(clippy::enum_variant_names)]
12513 enum GeneratedField {
12514 }
12515 impl<'de> serde::Deserialize<'de> for GeneratedField {
12516 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12517 where
12518 D: serde::Deserializer<'de>,
12519 {
12520 struct GeneratedVisitor;
12521
12522 impl serde::de::Visitor<'_> for GeneratedVisitor {
12523 type Value = GeneratedField;
12524
12525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12526 write!(formatter, "expected one of: {:?}", &FIELDS)
12527 }
12528
12529 #[allow(unused_variables)]
12530 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12531 where
12532 E: serde::de::Error,
12533 {
12534 Err(serde::de::Error::unknown_field(value, FIELDS))
12535 }
12536 }
12537 deserializer.deserialize_identifier(GeneratedVisitor)
12538 }
12539 }
12540 struct GeneratedVisitor;
12541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12542 type Value = RiseCtlListCompactionGroupRequest;
12543
12544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12545 formatter.write_str("struct hummock.RiseCtlListCompactionGroupRequest")
12546 }
12547
12548 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupRequest, V::Error>
12549 where
12550 V: serde::de::MapAccess<'de>,
12551 {
12552 while map_.next_key::<GeneratedField>()?.is_some() {
12553 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12554 }
12555 Ok(RiseCtlListCompactionGroupRequest {
12556 })
12557 }
12558 }
12559 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupRequest", FIELDS, GeneratedVisitor)
12560 }
12561}
12562impl serde::Serialize for RiseCtlListCompactionGroupResponse {
12563 #[allow(deprecated)]
12564 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12565 where
12566 S: serde::Serializer,
12567 {
12568 use serde::ser::SerializeStruct;
12569 let mut len = 0;
12570 if self.status.is_some() {
12571 len += 1;
12572 }
12573 if !self.compaction_groups.is_empty() {
12574 len += 1;
12575 }
12576 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupResponse", len)?;
12577 if let Some(v) = self.status.as_ref() {
12578 struct_ser.serialize_field("status", v)?;
12579 }
12580 if !self.compaction_groups.is_empty() {
12581 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
12582 }
12583 struct_ser.end()
12584 }
12585}
12586impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupResponse {
12587 #[allow(deprecated)]
12588 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12589 where
12590 D: serde::Deserializer<'de>,
12591 {
12592 const FIELDS: &[&str] = &[
12593 "status",
12594 "compaction_groups",
12595 "compactionGroups",
12596 ];
12597
12598 #[allow(clippy::enum_variant_names)]
12599 enum GeneratedField {
12600 Status,
12601 CompactionGroups,
12602 }
12603 impl<'de> serde::Deserialize<'de> for GeneratedField {
12604 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12605 where
12606 D: serde::Deserializer<'de>,
12607 {
12608 struct GeneratedVisitor;
12609
12610 impl serde::de::Visitor<'_> for GeneratedVisitor {
12611 type Value = GeneratedField;
12612
12613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12614 write!(formatter, "expected one of: {:?}", &FIELDS)
12615 }
12616
12617 #[allow(unused_variables)]
12618 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12619 where
12620 E: serde::de::Error,
12621 {
12622 match value {
12623 "status" => Ok(GeneratedField::Status),
12624 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
12625 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12626 }
12627 }
12628 }
12629 deserializer.deserialize_identifier(GeneratedVisitor)
12630 }
12631 }
12632 struct GeneratedVisitor;
12633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12634 type Value = RiseCtlListCompactionGroupResponse;
12635
12636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12637 formatter.write_str("struct hummock.RiseCtlListCompactionGroupResponse")
12638 }
12639
12640 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupResponse, V::Error>
12641 where
12642 V: serde::de::MapAccess<'de>,
12643 {
12644 let mut status__ = None;
12645 let mut compaction_groups__ = None;
12646 while let Some(k) = map_.next_key()? {
12647 match k {
12648 GeneratedField::Status => {
12649 if status__.is_some() {
12650 return Err(serde::de::Error::duplicate_field("status"));
12651 }
12652 status__ = map_.next_value()?;
12653 }
12654 GeneratedField::CompactionGroups => {
12655 if compaction_groups__.is_some() {
12656 return Err(serde::de::Error::duplicate_field("compactionGroups"));
12657 }
12658 compaction_groups__ = Some(map_.next_value()?);
12659 }
12660 }
12661 }
12662 Ok(RiseCtlListCompactionGroupResponse {
12663 status: status__,
12664 compaction_groups: compaction_groups__.unwrap_or_default(),
12665 })
12666 }
12667 }
12668 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupResponse", FIELDS, GeneratedVisitor)
12669 }
12670}
12671impl serde::Serialize for RiseCtlListCompactionStatusRequest {
12672 #[allow(deprecated)]
12673 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12674 where
12675 S: serde::Serializer,
12676 {
12677 use serde::ser::SerializeStruct;
12678 let len = 0;
12679 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusRequest", len)?;
12680 struct_ser.end()
12681 }
12682}
12683impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusRequest {
12684 #[allow(deprecated)]
12685 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12686 where
12687 D: serde::Deserializer<'de>,
12688 {
12689 const FIELDS: &[&str] = &[
12690 ];
12691
12692 #[allow(clippy::enum_variant_names)]
12693 enum GeneratedField {
12694 }
12695 impl<'de> serde::Deserialize<'de> for GeneratedField {
12696 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12697 where
12698 D: serde::Deserializer<'de>,
12699 {
12700 struct GeneratedVisitor;
12701
12702 impl serde::de::Visitor<'_> for GeneratedVisitor {
12703 type Value = GeneratedField;
12704
12705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12706 write!(formatter, "expected one of: {:?}", &FIELDS)
12707 }
12708
12709 #[allow(unused_variables)]
12710 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12711 where
12712 E: serde::de::Error,
12713 {
12714 Err(serde::de::Error::unknown_field(value, FIELDS))
12715 }
12716 }
12717 deserializer.deserialize_identifier(GeneratedVisitor)
12718 }
12719 }
12720 struct GeneratedVisitor;
12721 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12722 type Value = RiseCtlListCompactionStatusRequest;
12723
12724 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12725 formatter.write_str("struct hummock.RiseCtlListCompactionStatusRequest")
12726 }
12727
12728 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusRequest, V::Error>
12729 where
12730 V: serde::de::MapAccess<'de>,
12731 {
12732 while map_.next_key::<GeneratedField>()?.is_some() {
12733 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12734 }
12735 Ok(RiseCtlListCompactionStatusRequest {
12736 })
12737 }
12738 }
12739 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusRequest", FIELDS, GeneratedVisitor)
12740 }
12741}
12742impl serde::Serialize for RiseCtlListCompactionStatusResponse {
12743 #[allow(deprecated)]
12744 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12745 where
12746 S: serde::Serializer,
12747 {
12748 use serde::ser::SerializeStruct;
12749 let mut len = 0;
12750 if !self.compaction_statuses.is_empty() {
12751 len += 1;
12752 }
12753 if !self.task_assignment.is_empty() {
12754 len += 1;
12755 }
12756 if !self.task_progress.is_empty() {
12757 len += 1;
12758 }
12759 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusResponse", len)?;
12760 if !self.compaction_statuses.is_empty() {
12761 struct_ser.serialize_field("compactionStatuses", &self.compaction_statuses)?;
12762 }
12763 if !self.task_assignment.is_empty() {
12764 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
12765 }
12766 if !self.task_progress.is_empty() {
12767 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
12768 }
12769 struct_ser.end()
12770 }
12771}
12772impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusResponse {
12773 #[allow(deprecated)]
12774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12775 where
12776 D: serde::Deserializer<'de>,
12777 {
12778 const FIELDS: &[&str] = &[
12779 "compaction_statuses",
12780 "compactionStatuses",
12781 "task_assignment",
12782 "taskAssignment",
12783 "task_progress",
12784 "taskProgress",
12785 ];
12786
12787 #[allow(clippy::enum_variant_names)]
12788 enum GeneratedField {
12789 CompactionStatuses,
12790 TaskAssignment,
12791 TaskProgress,
12792 }
12793 impl<'de> serde::Deserialize<'de> for GeneratedField {
12794 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12795 where
12796 D: serde::Deserializer<'de>,
12797 {
12798 struct GeneratedVisitor;
12799
12800 impl serde::de::Visitor<'_> for GeneratedVisitor {
12801 type Value = GeneratedField;
12802
12803 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12804 write!(formatter, "expected one of: {:?}", &FIELDS)
12805 }
12806
12807 #[allow(unused_variables)]
12808 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12809 where
12810 E: serde::de::Error,
12811 {
12812 match value {
12813 "compactionStatuses" | "compaction_statuses" => Ok(GeneratedField::CompactionStatuses),
12814 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
12815 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
12816 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12817 }
12818 }
12819 }
12820 deserializer.deserialize_identifier(GeneratedVisitor)
12821 }
12822 }
12823 struct GeneratedVisitor;
12824 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12825 type Value = RiseCtlListCompactionStatusResponse;
12826
12827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12828 formatter.write_str("struct hummock.RiseCtlListCompactionStatusResponse")
12829 }
12830
12831 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusResponse, V::Error>
12832 where
12833 V: serde::de::MapAccess<'de>,
12834 {
12835 let mut compaction_statuses__ = None;
12836 let mut task_assignment__ = None;
12837 let mut task_progress__ = None;
12838 while let Some(k) = map_.next_key()? {
12839 match k {
12840 GeneratedField::CompactionStatuses => {
12841 if compaction_statuses__.is_some() {
12842 return Err(serde::de::Error::duplicate_field("compactionStatuses"));
12843 }
12844 compaction_statuses__ = Some(map_.next_value()?);
12845 }
12846 GeneratedField::TaskAssignment => {
12847 if task_assignment__.is_some() {
12848 return Err(serde::de::Error::duplicate_field("taskAssignment"));
12849 }
12850 task_assignment__ = Some(map_.next_value()?);
12851 }
12852 GeneratedField::TaskProgress => {
12853 if task_progress__.is_some() {
12854 return Err(serde::de::Error::duplicate_field("taskProgress"));
12855 }
12856 task_progress__ = Some(map_.next_value()?);
12857 }
12858 }
12859 }
12860 Ok(RiseCtlListCompactionStatusResponse {
12861 compaction_statuses: compaction_statuses__.unwrap_or_default(),
12862 task_assignment: task_assignment__.unwrap_or_default(),
12863 task_progress: task_progress__.unwrap_or_default(),
12864 })
12865 }
12866 }
12867 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusResponse", FIELDS, GeneratedVisitor)
12868 }
12869}
12870impl serde::Serialize for RiseCtlPauseVersionCheckpointRequest {
12871 #[allow(deprecated)]
12872 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12873 where
12874 S: serde::Serializer,
12875 {
12876 use serde::ser::SerializeStruct;
12877 let len = 0;
12878 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", len)?;
12879 struct_ser.end()
12880 }
12881}
12882impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointRequest {
12883 #[allow(deprecated)]
12884 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12885 where
12886 D: serde::Deserializer<'de>,
12887 {
12888 const FIELDS: &[&str] = &[
12889 ];
12890
12891 #[allow(clippy::enum_variant_names)]
12892 enum GeneratedField {
12893 }
12894 impl<'de> serde::Deserialize<'de> for GeneratedField {
12895 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12896 where
12897 D: serde::Deserializer<'de>,
12898 {
12899 struct GeneratedVisitor;
12900
12901 impl serde::de::Visitor<'_> for GeneratedVisitor {
12902 type Value = GeneratedField;
12903
12904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12905 write!(formatter, "expected one of: {:?}", &FIELDS)
12906 }
12907
12908 #[allow(unused_variables)]
12909 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12910 where
12911 E: serde::de::Error,
12912 {
12913 Err(serde::de::Error::unknown_field(value, FIELDS))
12914 }
12915 }
12916 deserializer.deserialize_identifier(GeneratedVisitor)
12917 }
12918 }
12919 struct GeneratedVisitor;
12920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12921 type Value = RiseCtlPauseVersionCheckpointRequest;
12922
12923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12924 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointRequest")
12925 }
12926
12927 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointRequest, V::Error>
12928 where
12929 V: serde::de::MapAccess<'de>,
12930 {
12931 while map_.next_key::<GeneratedField>()?.is_some() {
12932 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12933 }
12934 Ok(RiseCtlPauseVersionCheckpointRequest {
12935 })
12936 }
12937 }
12938 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", FIELDS, GeneratedVisitor)
12939 }
12940}
12941impl serde::Serialize for RiseCtlPauseVersionCheckpointResponse {
12942 #[allow(deprecated)]
12943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12944 where
12945 S: serde::Serializer,
12946 {
12947 use serde::ser::SerializeStruct;
12948 let len = 0;
12949 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", len)?;
12950 struct_ser.end()
12951 }
12952}
12953impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointResponse {
12954 #[allow(deprecated)]
12955 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12956 where
12957 D: serde::Deserializer<'de>,
12958 {
12959 const FIELDS: &[&str] = &[
12960 ];
12961
12962 #[allow(clippy::enum_variant_names)]
12963 enum GeneratedField {
12964 }
12965 impl<'de> serde::Deserialize<'de> for GeneratedField {
12966 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12967 where
12968 D: serde::Deserializer<'de>,
12969 {
12970 struct GeneratedVisitor;
12971
12972 impl serde::de::Visitor<'_> for GeneratedVisitor {
12973 type Value = GeneratedField;
12974
12975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12976 write!(formatter, "expected one of: {:?}", &FIELDS)
12977 }
12978
12979 #[allow(unused_variables)]
12980 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12981 where
12982 E: serde::de::Error,
12983 {
12984 Err(serde::de::Error::unknown_field(value, FIELDS))
12985 }
12986 }
12987 deserializer.deserialize_identifier(GeneratedVisitor)
12988 }
12989 }
12990 struct GeneratedVisitor;
12991 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12992 type Value = RiseCtlPauseVersionCheckpointResponse;
12993
12994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12995 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointResponse")
12996 }
12997
12998 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointResponse, V::Error>
12999 where
13000 V: serde::de::MapAccess<'de>,
13001 {
13002 while map_.next_key::<GeneratedField>()?.is_some() {
13003 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13004 }
13005 Ok(RiseCtlPauseVersionCheckpointResponse {
13006 })
13007 }
13008 }
13009 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", FIELDS, GeneratedVisitor)
13010 }
13011}
13012impl serde::Serialize for RiseCtlRebuildTableStatsRequest {
13013 #[allow(deprecated)]
13014 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13015 where
13016 S: serde::Serializer,
13017 {
13018 use serde::ser::SerializeStruct;
13019 let len = 0;
13020 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsRequest", len)?;
13021 struct_ser.end()
13022 }
13023}
13024impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsRequest {
13025 #[allow(deprecated)]
13026 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13027 where
13028 D: serde::Deserializer<'de>,
13029 {
13030 const FIELDS: &[&str] = &[
13031 ];
13032
13033 #[allow(clippy::enum_variant_names)]
13034 enum GeneratedField {
13035 }
13036 impl<'de> serde::Deserialize<'de> for GeneratedField {
13037 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13038 where
13039 D: serde::Deserializer<'de>,
13040 {
13041 struct GeneratedVisitor;
13042
13043 impl serde::de::Visitor<'_> for GeneratedVisitor {
13044 type Value = GeneratedField;
13045
13046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13047 write!(formatter, "expected one of: {:?}", &FIELDS)
13048 }
13049
13050 #[allow(unused_variables)]
13051 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13052 where
13053 E: serde::de::Error,
13054 {
13055 Err(serde::de::Error::unknown_field(value, FIELDS))
13056 }
13057 }
13058 deserializer.deserialize_identifier(GeneratedVisitor)
13059 }
13060 }
13061 struct GeneratedVisitor;
13062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13063 type Value = RiseCtlRebuildTableStatsRequest;
13064
13065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13066 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsRequest")
13067 }
13068
13069 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsRequest, V::Error>
13070 where
13071 V: serde::de::MapAccess<'de>,
13072 {
13073 while map_.next_key::<GeneratedField>()?.is_some() {
13074 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13075 }
13076 Ok(RiseCtlRebuildTableStatsRequest {
13077 })
13078 }
13079 }
13080 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsRequest", FIELDS, GeneratedVisitor)
13081 }
13082}
13083impl serde::Serialize for RiseCtlRebuildTableStatsResponse {
13084 #[allow(deprecated)]
13085 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13086 where
13087 S: serde::Serializer,
13088 {
13089 use serde::ser::SerializeStruct;
13090 let len = 0;
13091 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsResponse", len)?;
13092 struct_ser.end()
13093 }
13094}
13095impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsResponse {
13096 #[allow(deprecated)]
13097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13098 where
13099 D: serde::Deserializer<'de>,
13100 {
13101 const FIELDS: &[&str] = &[
13102 ];
13103
13104 #[allow(clippy::enum_variant_names)]
13105 enum GeneratedField {
13106 }
13107 impl<'de> serde::Deserialize<'de> for GeneratedField {
13108 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13109 where
13110 D: serde::Deserializer<'de>,
13111 {
13112 struct GeneratedVisitor;
13113
13114 impl serde::de::Visitor<'_> for GeneratedVisitor {
13115 type Value = GeneratedField;
13116
13117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13118 write!(formatter, "expected one of: {:?}", &FIELDS)
13119 }
13120
13121 #[allow(unused_variables)]
13122 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13123 where
13124 E: serde::de::Error,
13125 {
13126 Err(serde::de::Error::unknown_field(value, FIELDS))
13127 }
13128 }
13129 deserializer.deserialize_identifier(GeneratedVisitor)
13130 }
13131 }
13132 struct GeneratedVisitor;
13133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13134 type Value = RiseCtlRebuildTableStatsResponse;
13135
13136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13137 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsResponse")
13138 }
13139
13140 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsResponse, V::Error>
13141 where
13142 V: serde::de::MapAccess<'de>,
13143 {
13144 while map_.next_key::<GeneratedField>()?.is_some() {
13145 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13146 }
13147 Ok(RiseCtlRebuildTableStatsResponse {
13148 })
13149 }
13150 }
13151 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsResponse", FIELDS, GeneratedVisitor)
13152 }
13153}
13154impl serde::Serialize for RiseCtlResumeVersionCheckpointRequest {
13155 #[allow(deprecated)]
13156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13157 where
13158 S: serde::Serializer,
13159 {
13160 use serde::ser::SerializeStruct;
13161 let len = 0;
13162 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", len)?;
13163 struct_ser.end()
13164 }
13165}
13166impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointRequest {
13167 #[allow(deprecated)]
13168 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13169 where
13170 D: serde::Deserializer<'de>,
13171 {
13172 const FIELDS: &[&str] = &[
13173 ];
13174
13175 #[allow(clippy::enum_variant_names)]
13176 enum GeneratedField {
13177 }
13178 impl<'de> serde::Deserialize<'de> for GeneratedField {
13179 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13180 where
13181 D: serde::Deserializer<'de>,
13182 {
13183 struct GeneratedVisitor;
13184
13185 impl serde::de::Visitor<'_> for GeneratedVisitor {
13186 type Value = GeneratedField;
13187
13188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13189 write!(formatter, "expected one of: {:?}", &FIELDS)
13190 }
13191
13192 #[allow(unused_variables)]
13193 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13194 where
13195 E: serde::de::Error,
13196 {
13197 Err(serde::de::Error::unknown_field(value, FIELDS))
13198 }
13199 }
13200 deserializer.deserialize_identifier(GeneratedVisitor)
13201 }
13202 }
13203 struct GeneratedVisitor;
13204 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13205 type Value = RiseCtlResumeVersionCheckpointRequest;
13206
13207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13208 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointRequest")
13209 }
13210
13211 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointRequest, V::Error>
13212 where
13213 V: serde::de::MapAccess<'de>,
13214 {
13215 while map_.next_key::<GeneratedField>()?.is_some() {
13216 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13217 }
13218 Ok(RiseCtlResumeVersionCheckpointRequest {
13219 })
13220 }
13221 }
13222 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", FIELDS, GeneratedVisitor)
13223 }
13224}
13225impl serde::Serialize for RiseCtlResumeVersionCheckpointResponse {
13226 #[allow(deprecated)]
13227 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13228 where
13229 S: serde::Serializer,
13230 {
13231 use serde::ser::SerializeStruct;
13232 let len = 0;
13233 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", len)?;
13234 struct_ser.end()
13235 }
13236}
13237impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointResponse {
13238 #[allow(deprecated)]
13239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13240 where
13241 D: serde::Deserializer<'de>,
13242 {
13243 const FIELDS: &[&str] = &[
13244 ];
13245
13246 #[allow(clippy::enum_variant_names)]
13247 enum GeneratedField {
13248 }
13249 impl<'de> serde::Deserialize<'de> for GeneratedField {
13250 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13251 where
13252 D: serde::Deserializer<'de>,
13253 {
13254 struct GeneratedVisitor;
13255
13256 impl serde::de::Visitor<'_> for GeneratedVisitor {
13257 type Value = GeneratedField;
13258
13259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13260 write!(formatter, "expected one of: {:?}", &FIELDS)
13261 }
13262
13263 #[allow(unused_variables)]
13264 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13265 where
13266 E: serde::de::Error,
13267 {
13268 Err(serde::de::Error::unknown_field(value, FIELDS))
13269 }
13270 }
13271 deserializer.deserialize_identifier(GeneratedVisitor)
13272 }
13273 }
13274 struct GeneratedVisitor;
13275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13276 type Value = RiseCtlResumeVersionCheckpointResponse;
13277
13278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13279 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointResponse")
13280 }
13281
13282 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointResponse, V::Error>
13283 where
13284 V: serde::de::MapAccess<'de>,
13285 {
13286 while map_.next_key::<GeneratedField>()?.is_some() {
13287 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13288 }
13289 Ok(RiseCtlResumeVersionCheckpointResponse {
13290 })
13291 }
13292 }
13293 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", FIELDS, GeneratedVisitor)
13294 }
13295}
13296impl serde::Serialize for RiseCtlUpdateCompactionConfigRequest {
13297 #[allow(deprecated)]
13298 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13299 where
13300 S: serde::Serializer,
13301 {
13302 use serde::ser::SerializeStruct;
13303 let mut len = 0;
13304 if !self.compaction_group_ids.is_empty() {
13305 len += 1;
13306 }
13307 if !self.configs.is_empty() {
13308 len += 1;
13309 }
13310 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", len)?;
13311 if !self.compaction_group_ids.is_empty() {
13312 struct_ser.serialize_field("compactionGroupIds", &self.compaction_group_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
13313 }
13314 if !self.configs.is_empty() {
13315 struct_ser.serialize_field("configs", &self.configs)?;
13316 }
13317 struct_ser.end()
13318 }
13319}
13320impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigRequest {
13321 #[allow(deprecated)]
13322 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13323 where
13324 D: serde::Deserializer<'de>,
13325 {
13326 const FIELDS: &[&str] = &[
13327 "compaction_group_ids",
13328 "compactionGroupIds",
13329 "configs",
13330 ];
13331
13332 #[allow(clippy::enum_variant_names)]
13333 enum GeneratedField {
13334 CompactionGroupIds,
13335 Configs,
13336 }
13337 impl<'de> serde::Deserialize<'de> for GeneratedField {
13338 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13339 where
13340 D: serde::Deserializer<'de>,
13341 {
13342 struct GeneratedVisitor;
13343
13344 impl serde::de::Visitor<'_> for GeneratedVisitor {
13345 type Value = GeneratedField;
13346
13347 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13348 write!(formatter, "expected one of: {:?}", &FIELDS)
13349 }
13350
13351 #[allow(unused_variables)]
13352 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13353 where
13354 E: serde::de::Error,
13355 {
13356 match value {
13357 "compactionGroupIds" | "compaction_group_ids" => Ok(GeneratedField::CompactionGroupIds),
13358 "configs" => Ok(GeneratedField::Configs),
13359 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13360 }
13361 }
13362 }
13363 deserializer.deserialize_identifier(GeneratedVisitor)
13364 }
13365 }
13366 struct GeneratedVisitor;
13367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13368 type Value = RiseCtlUpdateCompactionConfigRequest;
13369
13370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13371 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest")
13372 }
13373
13374 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigRequest, V::Error>
13375 where
13376 V: serde::de::MapAccess<'de>,
13377 {
13378 let mut compaction_group_ids__ = None;
13379 let mut configs__ = None;
13380 while let Some(k) = map_.next_key()? {
13381 match k {
13382 GeneratedField::CompactionGroupIds => {
13383 if compaction_group_ids__.is_some() {
13384 return Err(serde::de::Error::duplicate_field("compactionGroupIds"));
13385 }
13386 compaction_group_ids__ =
13387 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13388 .into_iter().map(|x| x.0).collect())
13389 ;
13390 }
13391 GeneratedField::Configs => {
13392 if configs__.is_some() {
13393 return Err(serde::de::Error::duplicate_field("configs"));
13394 }
13395 configs__ = Some(map_.next_value()?);
13396 }
13397 }
13398 }
13399 Ok(RiseCtlUpdateCompactionConfigRequest {
13400 compaction_group_ids: compaction_group_ids__.unwrap_or_default(),
13401 configs: configs__.unwrap_or_default(),
13402 })
13403 }
13404 }
13405 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", FIELDS, GeneratedVisitor)
13406 }
13407}
13408impl serde::Serialize for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
13409 #[allow(deprecated)]
13410 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13411 where
13412 S: serde::Serializer,
13413 {
13414 use serde::ser::SerializeStruct;
13415 let mut len = 0;
13416 if self.level != 0 {
13417 len += 1;
13418 }
13419 if !self.compression_algorithm.is_empty() {
13420 len += 1;
13421 }
13422 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", len)?;
13423 if self.level != 0 {
13424 struct_ser.serialize_field("level", &self.level)?;
13425 }
13426 if !self.compression_algorithm.is_empty() {
13427 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
13428 }
13429 struct_ser.end()
13430 }
13431}
13432impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
13433 #[allow(deprecated)]
13434 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13435 where
13436 D: serde::Deserializer<'de>,
13437 {
13438 const FIELDS: &[&str] = &[
13439 "level",
13440 "compression_algorithm",
13441 "compressionAlgorithm",
13442 ];
13443
13444 #[allow(clippy::enum_variant_names)]
13445 enum GeneratedField {
13446 Level,
13447 CompressionAlgorithm,
13448 }
13449 impl<'de> serde::Deserialize<'de> for GeneratedField {
13450 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13451 where
13452 D: serde::Deserializer<'de>,
13453 {
13454 struct GeneratedVisitor;
13455
13456 impl serde::de::Visitor<'_> for GeneratedVisitor {
13457 type Value = GeneratedField;
13458
13459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13460 write!(formatter, "expected one of: {:?}", &FIELDS)
13461 }
13462
13463 #[allow(unused_variables)]
13464 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13465 where
13466 E: serde::de::Error,
13467 {
13468 match value {
13469 "level" => Ok(GeneratedField::Level),
13470 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
13471 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13472 }
13473 }
13474 }
13475 deserializer.deserialize_identifier(GeneratedVisitor)
13476 }
13477 }
13478 struct GeneratedVisitor;
13479 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13480 type Value = rise_ctl_update_compaction_config_request::CompressionAlgorithm;
13481
13482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13483 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm")
13484 }
13485
13486 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::CompressionAlgorithm, V::Error>
13487 where
13488 V: serde::de::MapAccess<'de>,
13489 {
13490 let mut level__ = None;
13491 let mut compression_algorithm__ = None;
13492 while let Some(k) = map_.next_key()? {
13493 match k {
13494 GeneratedField::Level => {
13495 if level__.is_some() {
13496 return Err(serde::de::Error::duplicate_field("level"));
13497 }
13498 level__ =
13499 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13500 ;
13501 }
13502 GeneratedField::CompressionAlgorithm => {
13503 if compression_algorithm__.is_some() {
13504 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
13505 }
13506 compression_algorithm__ = Some(map_.next_value()?);
13507 }
13508 }
13509 }
13510 Ok(rise_ctl_update_compaction_config_request::CompressionAlgorithm {
13511 level: level__.unwrap_or_default(),
13512 compression_algorithm: compression_algorithm__.unwrap_or_default(),
13513 })
13514 }
13515 }
13516 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", FIELDS, GeneratedVisitor)
13517 }
13518}
13519impl serde::Serialize for rise_ctl_update_compaction_config_request::MutableConfig {
13520 #[allow(deprecated)]
13521 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13522 where
13523 S: serde::Serializer,
13524 {
13525 use serde::ser::SerializeStruct;
13526 let mut len = 0;
13527 if self.mutable_config.is_some() {
13528 len += 1;
13529 }
13530 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", len)?;
13531 if let Some(v) = self.mutable_config.as_ref() {
13532 match v {
13533 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(v) => {
13534 #[allow(clippy::needless_borrow)]
13535 #[allow(clippy::needless_borrows_for_generic_args)]
13536 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&v).as_str())?;
13537 }
13538 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(v) => {
13539 #[allow(clippy::needless_borrow)]
13540 #[allow(clippy::needless_borrows_for_generic_args)]
13541 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&v).as_str())?;
13542 }
13543 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(v) => {
13544 #[allow(clippy::needless_borrow)]
13545 #[allow(clippy::needless_borrows_for_generic_args)]
13546 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&v).as_str())?;
13547 }
13548 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(v) => {
13549 #[allow(clippy::needless_borrow)]
13550 #[allow(clippy::needless_borrows_for_generic_args)]
13551 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&v).as_str())?;
13552 }
13553 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(v) => {
13554 #[allow(clippy::needless_borrow)]
13555 #[allow(clippy::needless_borrows_for_generic_args)]
13556 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&v).as_str())?;
13557 }
13558 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(v) => {
13559 #[allow(clippy::needless_borrow)]
13560 #[allow(clippy::needless_borrows_for_generic_args)]
13561 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&v).as_str())?;
13562 }
13563 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(v) => {
13564 struct_ser.serialize_field("compactionFilterMask", v)?;
13565 }
13566 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(v) => {
13567 struct_ser.serialize_field("maxSubCompaction", v)?;
13568 }
13569 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(v) => {
13570 #[allow(clippy::needless_borrow)]
13571 #[allow(clippy::needless_borrows_for_generic_args)]
13572 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&v).as_str())?;
13573 }
13574 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(v) => {
13575 struct_ser.serialize_field("level0SubLevelCompactLevelCount", v)?;
13576 }
13577 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(v) => {
13578 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", v)?;
13579 }
13580 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(v) => {
13581 #[allow(clippy::needless_borrow)]
13582 #[allow(clippy::needless_borrows_for_generic_args)]
13583 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&v).as_str())?;
13584 }
13585 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(v) => {
13586 #[allow(clippy::needless_borrow)]
13587 #[allow(clippy::needless_borrows_for_generic_args)]
13588 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&v).as_str())?;
13589 }
13590 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker(v) => {
13591 struct_ser.serialize_field("enableEmergencyPicker", v)?;
13592 }
13593 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(v) => {
13594 struct_ser.serialize_field("tombstoneReclaimRatio", v)?;
13595 }
13596 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm(v) => {
13597 struct_ser.serialize_field("compressionAlgorithm", v)?;
13598 }
13599 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(v) => {
13600 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
13601 }
13602 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(v) => {
13603 #[allow(clippy::needless_borrow)]
13604 #[allow(clippy::needless_borrows_for_generic_args)]
13605 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
13606 }
13607 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(v) => {
13608 struct_ser.serialize_field("splitWeightByVnode", v)?;
13609 }
13610 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling(v) => {
13611 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
13612 }
13613 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(v) => {
13614 #[allow(clippy::needless_borrow)]
13615 #[allow(clippy::needless_borrows_for_generic_args)]
13616 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
13617 }
13618 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(v) => {
13619 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
13620 }
13621 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(v) => {
13622 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
13623 }
13624 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(v) => {
13625 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
13626 }
13627 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(v) => {
13628 #[allow(clippy::needless_borrow)]
13629 #[allow(clippy::needless_borrows_for_generic_args)]
13630 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
13631 }
13632 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(v) => {
13633 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
13634 }
13635 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection(v) => {
13636 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
13637 }
13638 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::VnodeAlignedLevelSizeThreshold(v) => {
13639 #[allow(clippy::needless_borrow)]
13640 #[allow(clippy::needless_borrows_for_generic_args)]
13641 struct_ser.serialize_field("vnodeAlignedLevelSizeThreshold", ToString::to_string(&v).as_str())?;
13642 }
13643 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxKvCountForXor16(v) => {
13644 #[allow(clippy::needless_borrow)]
13645 #[allow(clippy::needless_borrows_for_generic_args)]
13646 struct_ser.serialize_field("maxKvCountForXor16", ToString::to_string(&v).as_str())?;
13647 }
13648 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxVnodeKeyRangeBytes(v) => {
13649 #[allow(clippy::needless_borrow)]
13650 #[allow(clippy::needless_borrows_for_generic_args)]
13651 struct_ser.serialize_field("maxVnodeKeyRangeBytes", ToString::to_string(&v).as_str())?;
13652 }
13653 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::ResetCompressionAlgorithm(v) => {
13654 struct_ser.serialize_field("resetCompressionAlgorithm", v)?;
13655 }
13656 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstableFilterType(v) => {
13657 struct_ser.serialize_field("sstableFilterType", v)?;
13658 }
13659 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstableFilterLayout(v) => {
13660 struct_ser.serialize_field("sstableFilterLayout", v)?;
13661 }
13662 }
13663 }
13664 struct_ser.end()
13665 }
13666}
13667impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::MutableConfig {
13668 #[allow(deprecated)]
13669 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13670 where
13671 D: serde::Deserializer<'de>,
13672 {
13673 const FIELDS: &[&str] = &[
13674 "max_bytes_for_level_base",
13675 "maxBytesForLevelBase",
13676 "max_bytes_for_level_multiplier",
13677 "maxBytesForLevelMultiplier",
13678 "max_compaction_bytes",
13679 "maxCompactionBytes",
13680 "sub_level_max_compaction_bytes",
13681 "subLevelMaxCompactionBytes",
13682 "level0_tier_compact_file_number",
13683 "level0TierCompactFileNumber",
13684 "target_file_size_base",
13685 "targetFileSizeBase",
13686 "compaction_filter_mask",
13687 "compactionFilterMask",
13688 "max_sub_compaction",
13689 "maxSubCompaction",
13690 "level0_stop_write_threshold_sub_level_number",
13691 "level0StopWriteThresholdSubLevelNumber",
13692 "level0_sub_level_compact_level_count",
13693 "level0SubLevelCompactLevelCount",
13694 "level0_overlapping_sub_level_compact_level_count",
13695 "level0OverlappingSubLevelCompactLevelCount",
13696 "max_space_reclaim_bytes",
13697 "maxSpaceReclaimBytes",
13698 "level0_max_compact_file_number",
13699 "level0MaxCompactFileNumber",
13700 "enable_emergency_picker",
13701 "enableEmergencyPicker",
13702 "tombstone_reclaim_ratio",
13703 "tombstoneReclaimRatio",
13704 "compression_algorithm",
13705 "compressionAlgorithm",
13706 "max_l0_compact_level_count",
13707 "maxL0CompactLevelCount",
13708 "sst_allowed_trivial_move_min_size",
13709 "sstAllowedTrivialMoveMinSize",
13710 "split_weight_by_vnode",
13711 "splitWeightByVnode",
13712 "disable_auto_group_scheduling",
13713 "disableAutoGroupScheduling",
13714 "max_overlapping_level_size",
13715 "maxOverlappingLevelSize",
13716 "emergency_level0_sst_file_count",
13717 "emergencyLevel0SstFileCount",
13718 "emergency_level0_sub_level_partition",
13719 "emergencyLevel0SubLevelPartition",
13720 "level0_stop_write_threshold_max_sst_count",
13721 "level0StopWriteThresholdMaxSstCount",
13722 "level0_stop_write_threshold_max_size",
13723 "level0StopWriteThresholdMaxSize",
13724 "sst_allowed_trivial_move_max_count",
13725 "sstAllowedTrivialMoveMaxCount",
13726 "enable_optimize_l0_interval_selection",
13727 "enableOptimizeL0IntervalSelection",
13728 "vnode_aligned_level_size_threshold",
13729 "vnodeAlignedLevelSizeThreshold",
13730 "max_kv_count_for_xor16",
13731 "maxKvCountForXor16",
13732 "max_vnode_key_range_bytes",
13733 "maxVnodeKeyRangeBytes",
13734 "reset_compression_algorithm",
13735 "resetCompressionAlgorithm",
13736 "sstable_filter_type",
13737 "sstableFilterType",
13738 "sstable_filter_layout",
13739 "sstableFilterLayout",
13740 ];
13741
13742 #[allow(clippy::enum_variant_names)]
13743 enum GeneratedField {
13744 MaxBytesForLevelBase,
13745 MaxBytesForLevelMultiplier,
13746 MaxCompactionBytes,
13747 SubLevelMaxCompactionBytes,
13748 Level0TierCompactFileNumber,
13749 TargetFileSizeBase,
13750 CompactionFilterMask,
13751 MaxSubCompaction,
13752 Level0StopWriteThresholdSubLevelNumber,
13753 Level0SubLevelCompactLevelCount,
13754 Level0OverlappingSubLevelCompactLevelCount,
13755 MaxSpaceReclaimBytes,
13756 Level0MaxCompactFileNumber,
13757 EnableEmergencyPicker,
13758 TombstoneReclaimRatio,
13759 CompressionAlgorithm,
13760 MaxL0CompactLevelCount,
13761 SstAllowedTrivialMoveMinSize,
13762 SplitWeightByVnode,
13763 DisableAutoGroupScheduling,
13764 MaxOverlappingLevelSize,
13765 EmergencyLevel0SstFileCount,
13766 EmergencyLevel0SubLevelPartition,
13767 Level0StopWriteThresholdMaxSstCount,
13768 Level0StopWriteThresholdMaxSize,
13769 SstAllowedTrivialMoveMaxCount,
13770 EnableOptimizeL0IntervalSelection,
13771 VnodeAlignedLevelSizeThreshold,
13772 MaxKvCountForXor16,
13773 MaxVnodeKeyRangeBytes,
13774 ResetCompressionAlgorithm,
13775 SstableFilterType,
13776 SstableFilterLayout,
13777 }
13778 impl<'de> serde::Deserialize<'de> for GeneratedField {
13779 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13780 where
13781 D: serde::Deserializer<'de>,
13782 {
13783 struct GeneratedVisitor;
13784
13785 impl serde::de::Visitor<'_> for GeneratedVisitor {
13786 type Value = GeneratedField;
13787
13788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13789 write!(formatter, "expected one of: {:?}", &FIELDS)
13790 }
13791
13792 #[allow(unused_variables)]
13793 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13794 where
13795 E: serde::de::Error,
13796 {
13797 match value {
13798 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
13799 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
13800 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
13801 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
13802 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
13803 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
13804 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
13805 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
13806 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
13807 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
13808 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
13809 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
13810 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
13811 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
13812 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
13813 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
13814 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
13815 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
13816 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
13817 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
13818 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
13819 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
13820 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
13821 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
13822 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
13823 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
13824 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
13825 "vnodeAlignedLevelSizeThreshold" | "vnode_aligned_level_size_threshold" => Ok(GeneratedField::VnodeAlignedLevelSizeThreshold),
13826 "maxKvCountForXor16" | "max_kv_count_for_xor16" => Ok(GeneratedField::MaxKvCountForXor16),
13827 "maxVnodeKeyRangeBytes" | "max_vnode_key_range_bytes" => Ok(GeneratedField::MaxVnodeKeyRangeBytes),
13828 "resetCompressionAlgorithm" | "reset_compression_algorithm" => Ok(GeneratedField::ResetCompressionAlgorithm),
13829 "sstableFilterType" | "sstable_filter_type" => Ok(GeneratedField::SstableFilterType),
13830 "sstableFilterLayout" | "sstable_filter_layout" => Ok(GeneratedField::SstableFilterLayout),
13831 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13832 }
13833 }
13834 }
13835 deserializer.deserialize_identifier(GeneratedVisitor)
13836 }
13837 }
13838 struct GeneratedVisitor;
13839 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13840 type Value = rise_ctl_update_compaction_config_request::MutableConfig;
13841
13842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13843 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig")
13844 }
13845
13846 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::MutableConfig, V::Error>
13847 where
13848 V: serde::de::MapAccess<'de>,
13849 {
13850 let mut mutable_config__ = None;
13851 while let Some(k) = map_.next_key()? {
13852 match k {
13853 GeneratedField::MaxBytesForLevelBase => {
13854 if mutable_config__.is_some() {
13855 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
13856 }
13857 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));
13858 }
13859 GeneratedField::MaxBytesForLevelMultiplier => {
13860 if mutable_config__.is_some() {
13861 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
13862 }
13863 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));
13864 }
13865 GeneratedField::MaxCompactionBytes => {
13866 if mutable_config__.is_some() {
13867 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
13868 }
13869 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));
13870 }
13871 GeneratedField::SubLevelMaxCompactionBytes => {
13872 if mutable_config__.is_some() {
13873 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
13874 }
13875 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));
13876 }
13877 GeneratedField::Level0TierCompactFileNumber => {
13878 if mutable_config__.is_some() {
13879 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
13880 }
13881 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));
13882 }
13883 GeneratedField::TargetFileSizeBase => {
13884 if mutable_config__.is_some() {
13885 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
13886 }
13887 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));
13888 }
13889 GeneratedField::CompactionFilterMask => {
13890 if mutable_config__.is_some() {
13891 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
13892 }
13893 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));
13894 }
13895 GeneratedField::MaxSubCompaction => {
13896 if mutable_config__.is_some() {
13897 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
13898 }
13899 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));
13900 }
13901 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
13902 if mutable_config__.is_some() {
13903 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
13904 }
13905 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));
13906 }
13907 GeneratedField::Level0SubLevelCompactLevelCount => {
13908 if mutable_config__.is_some() {
13909 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
13910 }
13911 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));
13912 }
13913 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
13914 if mutable_config__.is_some() {
13915 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
13916 }
13917 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));
13918 }
13919 GeneratedField::MaxSpaceReclaimBytes => {
13920 if mutable_config__.is_some() {
13921 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
13922 }
13923 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));
13924 }
13925 GeneratedField::Level0MaxCompactFileNumber => {
13926 if mutable_config__.is_some() {
13927 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
13928 }
13929 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));
13930 }
13931 GeneratedField::EnableEmergencyPicker => {
13932 if mutable_config__.is_some() {
13933 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
13934 }
13935 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker);
13936 }
13937 GeneratedField::TombstoneReclaimRatio => {
13938 if mutable_config__.is_some() {
13939 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
13940 }
13941 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));
13942 }
13943 GeneratedField::CompressionAlgorithm => {
13944 if mutable_config__.is_some() {
13945 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
13946 }
13947 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm)
13948;
13949 }
13950 GeneratedField::MaxL0CompactLevelCount => {
13951 if mutable_config__.is_some() {
13952 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
13953 }
13954 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));
13955 }
13956 GeneratedField::SstAllowedTrivialMoveMinSize => {
13957 if mutable_config__.is_some() {
13958 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
13959 }
13960 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));
13961 }
13962 GeneratedField::SplitWeightByVnode => {
13963 if mutable_config__.is_some() {
13964 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
13965 }
13966 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));
13967 }
13968 GeneratedField::DisableAutoGroupScheduling => {
13969 if mutable_config__.is_some() {
13970 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
13971 }
13972 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling);
13973 }
13974 GeneratedField::MaxOverlappingLevelSize => {
13975 if mutable_config__.is_some() {
13976 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
13977 }
13978 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));
13979 }
13980 GeneratedField::EmergencyLevel0SstFileCount => {
13981 if mutable_config__.is_some() {
13982 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
13983 }
13984 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));
13985 }
13986 GeneratedField::EmergencyLevel0SubLevelPartition => {
13987 if mutable_config__.is_some() {
13988 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
13989 }
13990 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));
13991 }
13992 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
13993 if mutable_config__.is_some() {
13994 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
13995 }
13996 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));
13997 }
13998 GeneratedField::Level0StopWriteThresholdMaxSize => {
13999 if mutable_config__.is_some() {
14000 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
14001 }
14002 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));
14003 }
14004 GeneratedField::SstAllowedTrivialMoveMaxCount => {
14005 if mutable_config__.is_some() {
14006 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
14007 }
14008 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));
14009 }
14010 GeneratedField::EnableOptimizeL0IntervalSelection => {
14011 if mutable_config__.is_some() {
14012 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
14013 }
14014 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection);
14015 }
14016 GeneratedField::VnodeAlignedLevelSizeThreshold => {
14017 if mutable_config__.is_some() {
14018 return Err(serde::de::Error::duplicate_field("vnodeAlignedLevelSizeThreshold"));
14019 }
14020 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::VnodeAlignedLevelSizeThreshold(x.0));
14021 }
14022 GeneratedField::MaxKvCountForXor16 => {
14023 if mutable_config__.is_some() {
14024 return Err(serde::de::Error::duplicate_field("maxKvCountForXor16"));
14025 }
14026 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxKvCountForXor16(x.0));
14027 }
14028 GeneratedField::MaxVnodeKeyRangeBytes => {
14029 if mutable_config__.is_some() {
14030 return Err(serde::de::Error::duplicate_field("maxVnodeKeyRangeBytes"));
14031 }
14032 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxVnodeKeyRangeBytes(x.0));
14033 }
14034 GeneratedField::ResetCompressionAlgorithm => {
14035 if mutable_config__.is_some() {
14036 return Err(serde::de::Error::duplicate_field("resetCompressionAlgorithm"));
14037 }
14038 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::ResetCompressionAlgorithm);
14039 }
14040 GeneratedField::SstableFilterType => {
14041 if mutable_config__.is_some() {
14042 return Err(serde::de::Error::duplicate_field("sstableFilterType"));
14043 }
14044 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstableFilterType)
14045;
14046 }
14047 GeneratedField::SstableFilterLayout => {
14048 if mutable_config__.is_some() {
14049 return Err(serde::de::Error::duplicate_field("sstableFilterLayout"));
14050 }
14051 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstableFilterLayout)
14052;
14053 }
14054 }
14055 }
14056 Ok(rise_ctl_update_compaction_config_request::MutableConfig {
14057 mutable_config: mutable_config__,
14058 })
14059 }
14060 }
14061 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", FIELDS, GeneratedVisitor)
14062 }
14063}
14064impl serde::Serialize for rise_ctl_update_compaction_config_request::SstableFilterLayout {
14065 #[allow(deprecated)]
14066 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14067 where
14068 S: serde::Serializer,
14069 {
14070 use serde::ser::SerializeStruct;
14071 let mut len = 0;
14072 if self.level != 0 {
14073 len += 1;
14074 }
14075 if !self.layout.is_empty() {
14076 len += 1;
14077 }
14078 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.SstableFilterLayout", len)?;
14079 if self.level != 0 {
14080 struct_ser.serialize_field("level", &self.level)?;
14081 }
14082 if !self.layout.is_empty() {
14083 struct_ser.serialize_field("layout", &self.layout)?;
14084 }
14085 struct_ser.end()
14086 }
14087}
14088impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::SstableFilterLayout {
14089 #[allow(deprecated)]
14090 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14091 where
14092 D: serde::Deserializer<'de>,
14093 {
14094 const FIELDS: &[&str] = &[
14095 "level",
14096 "layout",
14097 ];
14098
14099 #[allow(clippy::enum_variant_names)]
14100 enum GeneratedField {
14101 Level,
14102 Layout,
14103 }
14104 impl<'de> serde::Deserialize<'de> for GeneratedField {
14105 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14106 where
14107 D: serde::Deserializer<'de>,
14108 {
14109 struct GeneratedVisitor;
14110
14111 impl serde::de::Visitor<'_> for GeneratedVisitor {
14112 type Value = GeneratedField;
14113
14114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14115 write!(formatter, "expected one of: {:?}", &FIELDS)
14116 }
14117
14118 #[allow(unused_variables)]
14119 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14120 where
14121 E: serde::de::Error,
14122 {
14123 match value {
14124 "level" => Ok(GeneratedField::Level),
14125 "layout" => Ok(GeneratedField::Layout),
14126 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14127 }
14128 }
14129 }
14130 deserializer.deserialize_identifier(GeneratedVisitor)
14131 }
14132 }
14133 struct GeneratedVisitor;
14134 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14135 type Value = rise_ctl_update_compaction_config_request::SstableFilterLayout;
14136
14137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14138 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.SstableFilterLayout")
14139 }
14140
14141 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::SstableFilterLayout, V::Error>
14142 where
14143 V: serde::de::MapAccess<'de>,
14144 {
14145 let mut level__ = None;
14146 let mut layout__ = None;
14147 while let Some(k) = map_.next_key()? {
14148 match k {
14149 GeneratedField::Level => {
14150 if level__.is_some() {
14151 return Err(serde::de::Error::duplicate_field("level"));
14152 }
14153 level__ =
14154 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14155 ;
14156 }
14157 GeneratedField::Layout => {
14158 if layout__.is_some() {
14159 return Err(serde::de::Error::duplicate_field("layout"));
14160 }
14161 layout__ = Some(map_.next_value()?);
14162 }
14163 }
14164 }
14165 Ok(rise_ctl_update_compaction_config_request::SstableFilterLayout {
14166 level: level__.unwrap_or_default(),
14167 layout: layout__.unwrap_or_default(),
14168 })
14169 }
14170 }
14171 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.SstableFilterLayout", FIELDS, GeneratedVisitor)
14172 }
14173}
14174impl serde::Serialize for rise_ctl_update_compaction_config_request::SstableFilterType {
14175 #[allow(deprecated)]
14176 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14177 where
14178 S: serde::Serializer,
14179 {
14180 use serde::ser::SerializeStruct;
14181 let mut len = 0;
14182 if self.level != 0 {
14183 len += 1;
14184 }
14185 if !self.filter_type.is_empty() {
14186 len += 1;
14187 }
14188 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.SstableFilterType", len)?;
14189 if self.level != 0 {
14190 struct_ser.serialize_field("level", &self.level)?;
14191 }
14192 if !self.filter_type.is_empty() {
14193 struct_ser.serialize_field("filterType", &self.filter_type)?;
14194 }
14195 struct_ser.end()
14196 }
14197}
14198impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::SstableFilterType {
14199 #[allow(deprecated)]
14200 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14201 where
14202 D: serde::Deserializer<'de>,
14203 {
14204 const FIELDS: &[&str] = &[
14205 "level",
14206 "filter_type",
14207 "filterType",
14208 ];
14209
14210 #[allow(clippy::enum_variant_names)]
14211 enum GeneratedField {
14212 Level,
14213 FilterType,
14214 }
14215 impl<'de> serde::Deserialize<'de> for GeneratedField {
14216 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14217 where
14218 D: serde::Deserializer<'de>,
14219 {
14220 struct GeneratedVisitor;
14221
14222 impl serde::de::Visitor<'_> for GeneratedVisitor {
14223 type Value = GeneratedField;
14224
14225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14226 write!(formatter, "expected one of: {:?}", &FIELDS)
14227 }
14228
14229 #[allow(unused_variables)]
14230 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14231 where
14232 E: serde::de::Error,
14233 {
14234 match value {
14235 "level" => Ok(GeneratedField::Level),
14236 "filterType" | "filter_type" => Ok(GeneratedField::FilterType),
14237 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14238 }
14239 }
14240 }
14241 deserializer.deserialize_identifier(GeneratedVisitor)
14242 }
14243 }
14244 struct GeneratedVisitor;
14245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14246 type Value = rise_ctl_update_compaction_config_request::SstableFilterType;
14247
14248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14249 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.SstableFilterType")
14250 }
14251
14252 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::SstableFilterType, V::Error>
14253 where
14254 V: serde::de::MapAccess<'de>,
14255 {
14256 let mut level__ = None;
14257 let mut filter_type__ = None;
14258 while let Some(k) = map_.next_key()? {
14259 match k {
14260 GeneratedField::Level => {
14261 if level__.is_some() {
14262 return Err(serde::de::Error::duplicate_field("level"));
14263 }
14264 level__ =
14265 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14266 ;
14267 }
14268 GeneratedField::FilterType => {
14269 if filter_type__.is_some() {
14270 return Err(serde::de::Error::duplicate_field("filterType"));
14271 }
14272 filter_type__ = Some(map_.next_value()?);
14273 }
14274 }
14275 }
14276 Ok(rise_ctl_update_compaction_config_request::SstableFilterType {
14277 level: level__.unwrap_or_default(),
14278 filter_type: filter_type__.unwrap_or_default(),
14279 })
14280 }
14281 }
14282 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.SstableFilterType", FIELDS, GeneratedVisitor)
14283 }
14284}
14285impl serde::Serialize for RiseCtlUpdateCompactionConfigResponse {
14286 #[allow(deprecated)]
14287 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14288 where
14289 S: serde::Serializer,
14290 {
14291 use serde::ser::SerializeStruct;
14292 let mut len = 0;
14293 if self.status.is_some() {
14294 len += 1;
14295 }
14296 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", len)?;
14297 if let Some(v) = self.status.as_ref() {
14298 struct_ser.serialize_field("status", v)?;
14299 }
14300 struct_ser.end()
14301 }
14302}
14303impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigResponse {
14304 #[allow(deprecated)]
14305 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14306 where
14307 D: serde::Deserializer<'de>,
14308 {
14309 const FIELDS: &[&str] = &[
14310 "status",
14311 ];
14312
14313 #[allow(clippy::enum_variant_names)]
14314 enum GeneratedField {
14315 Status,
14316 }
14317 impl<'de> serde::Deserialize<'de> for GeneratedField {
14318 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14319 where
14320 D: serde::Deserializer<'de>,
14321 {
14322 struct GeneratedVisitor;
14323
14324 impl serde::de::Visitor<'_> for GeneratedVisitor {
14325 type Value = GeneratedField;
14326
14327 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14328 write!(formatter, "expected one of: {:?}", &FIELDS)
14329 }
14330
14331 #[allow(unused_variables)]
14332 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14333 where
14334 E: serde::de::Error,
14335 {
14336 match value {
14337 "status" => Ok(GeneratedField::Status),
14338 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14339 }
14340 }
14341 }
14342 deserializer.deserialize_identifier(GeneratedVisitor)
14343 }
14344 }
14345 struct GeneratedVisitor;
14346 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14347 type Value = RiseCtlUpdateCompactionConfigResponse;
14348
14349 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14350 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigResponse")
14351 }
14352
14353 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigResponse, V::Error>
14354 where
14355 V: serde::de::MapAccess<'de>,
14356 {
14357 let mut status__ = None;
14358 while let Some(k) = map_.next_key()? {
14359 match k {
14360 GeneratedField::Status => {
14361 if status__.is_some() {
14362 return Err(serde::de::Error::duplicate_field("status"));
14363 }
14364 status__ = map_.next_value()?;
14365 }
14366 }
14367 }
14368 Ok(RiseCtlUpdateCompactionConfigResponse {
14369 status: status__,
14370 })
14371 }
14372 }
14373 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", FIELDS, GeneratedVisitor)
14374 }
14375}
14376impl serde::Serialize for SplitCompactionGroupRequest {
14377 #[allow(deprecated)]
14378 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14379 where
14380 S: serde::Serializer,
14381 {
14382 use serde::ser::SerializeStruct;
14383 let mut len = 0;
14384 if self.group_id != 0 {
14385 len += 1;
14386 }
14387 if !self.table_ids.is_empty() {
14388 len += 1;
14389 }
14390 if self.partition_vnode_count != 0 {
14391 len += 1;
14392 }
14393 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupRequest", len)?;
14394 if self.group_id != 0 {
14395 #[allow(clippy::needless_borrow)]
14396 #[allow(clippy::needless_borrows_for_generic_args)]
14397 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
14398 }
14399 if !self.table_ids.is_empty() {
14400 struct_ser.serialize_field("tableIds", &self.table_ids)?;
14401 }
14402 if self.partition_vnode_count != 0 {
14403 struct_ser.serialize_field("partitionVnodeCount", &self.partition_vnode_count)?;
14404 }
14405 struct_ser.end()
14406 }
14407}
14408impl<'de> serde::Deserialize<'de> for SplitCompactionGroupRequest {
14409 #[allow(deprecated)]
14410 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14411 where
14412 D: serde::Deserializer<'de>,
14413 {
14414 const FIELDS: &[&str] = &[
14415 "group_id",
14416 "groupId",
14417 "table_ids",
14418 "tableIds",
14419 "partition_vnode_count",
14420 "partitionVnodeCount",
14421 ];
14422
14423 #[allow(clippy::enum_variant_names)]
14424 enum GeneratedField {
14425 GroupId,
14426 TableIds,
14427 PartitionVnodeCount,
14428 }
14429 impl<'de> serde::Deserialize<'de> for GeneratedField {
14430 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14431 where
14432 D: serde::Deserializer<'de>,
14433 {
14434 struct GeneratedVisitor;
14435
14436 impl serde::de::Visitor<'_> for GeneratedVisitor {
14437 type Value = GeneratedField;
14438
14439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14440 write!(formatter, "expected one of: {:?}", &FIELDS)
14441 }
14442
14443 #[allow(unused_variables)]
14444 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14445 where
14446 E: serde::de::Error,
14447 {
14448 match value {
14449 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
14450 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
14451 "partitionVnodeCount" | "partition_vnode_count" => Ok(GeneratedField::PartitionVnodeCount),
14452 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14453 }
14454 }
14455 }
14456 deserializer.deserialize_identifier(GeneratedVisitor)
14457 }
14458 }
14459 struct GeneratedVisitor;
14460 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14461 type Value = SplitCompactionGroupRequest;
14462
14463 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14464 formatter.write_str("struct hummock.SplitCompactionGroupRequest")
14465 }
14466
14467 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupRequest, V::Error>
14468 where
14469 V: serde::de::MapAccess<'de>,
14470 {
14471 let mut group_id__ = None;
14472 let mut table_ids__ = None;
14473 let mut partition_vnode_count__ = None;
14474 while let Some(k) = map_.next_key()? {
14475 match k {
14476 GeneratedField::GroupId => {
14477 if group_id__.is_some() {
14478 return Err(serde::de::Error::duplicate_field("groupId"));
14479 }
14480 group_id__ =
14481 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14482 ;
14483 }
14484 GeneratedField::TableIds => {
14485 if table_ids__.is_some() {
14486 return Err(serde::de::Error::duplicate_field("tableIds"));
14487 }
14488 table_ids__ =
14489 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14490 .into_iter().map(|x| x.0).collect())
14491 ;
14492 }
14493 GeneratedField::PartitionVnodeCount => {
14494 if partition_vnode_count__.is_some() {
14495 return Err(serde::de::Error::duplicate_field("partitionVnodeCount"));
14496 }
14497 partition_vnode_count__ =
14498 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14499 ;
14500 }
14501 }
14502 }
14503 Ok(SplitCompactionGroupRequest {
14504 group_id: group_id__.unwrap_or_default(),
14505 table_ids: table_ids__.unwrap_or_default(),
14506 partition_vnode_count: partition_vnode_count__.unwrap_or_default(),
14507 })
14508 }
14509 }
14510 deserializer.deserialize_struct("hummock.SplitCompactionGroupRequest", FIELDS, GeneratedVisitor)
14511 }
14512}
14513impl serde::Serialize for SplitCompactionGroupResponse {
14514 #[allow(deprecated)]
14515 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14516 where
14517 S: serde::Serializer,
14518 {
14519 use serde::ser::SerializeStruct;
14520 let mut len = 0;
14521 if self.new_group_id != 0 {
14522 len += 1;
14523 }
14524 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupResponse", len)?;
14525 if self.new_group_id != 0 {
14526 #[allow(clippy::needless_borrow)]
14527 #[allow(clippy::needless_borrows_for_generic_args)]
14528 struct_ser.serialize_field("newGroupId", ToString::to_string(&self.new_group_id).as_str())?;
14529 }
14530 struct_ser.end()
14531 }
14532}
14533impl<'de> serde::Deserialize<'de> for SplitCompactionGroupResponse {
14534 #[allow(deprecated)]
14535 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14536 where
14537 D: serde::Deserializer<'de>,
14538 {
14539 const FIELDS: &[&str] = &[
14540 "new_group_id",
14541 "newGroupId",
14542 ];
14543
14544 #[allow(clippy::enum_variant_names)]
14545 enum GeneratedField {
14546 NewGroupId,
14547 }
14548 impl<'de> serde::Deserialize<'de> for GeneratedField {
14549 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14550 where
14551 D: serde::Deserializer<'de>,
14552 {
14553 struct GeneratedVisitor;
14554
14555 impl serde::de::Visitor<'_> for GeneratedVisitor {
14556 type Value = GeneratedField;
14557
14558 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14559 write!(formatter, "expected one of: {:?}", &FIELDS)
14560 }
14561
14562 #[allow(unused_variables)]
14563 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14564 where
14565 E: serde::de::Error,
14566 {
14567 match value {
14568 "newGroupId" | "new_group_id" => Ok(GeneratedField::NewGroupId),
14569 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14570 }
14571 }
14572 }
14573 deserializer.deserialize_identifier(GeneratedVisitor)
14574 }
14575 }
14576 struct GeneratedVisitor;
14577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14578 type Value = SplitCompactionGroupResponse;
14579
14580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14581 formatter.write_str("struct hummock.SplitCompactionGroupResponse")
14582 }
14583
14584 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupResponse, V::Error>
14585 where
14586 V: serde::de::MapAccess<'de>,
14587 {
14588 let mut new_group_id__ = None;
14589 while let Some(k) = map_.next_key()? {
14590 match k {
14591 GeneratedField::NewGroupId => {
14592 if new_group_id__.is_some() {
14593 return Err(serde::de::Error::duplicate_field("newGroupId"));
14594 }
14595 new_group_id__ =
14596 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14597 ;
14598 }
14599 }
14600 }
14601 Ok(SplitCompactionGroupResponse {
14602 new_group_id: new_group_id__.unwrap_or_default(),
14603 })
14604 }
14605 }
14606 deserializer.deserialize_struct("hummock.SplitCompactionGroupResponse", FIELDS, GeneratedVisitor)
14607 }
14608}
14609impl serde::Serialize for SstableFilterLayout {
14610 #[allow(deprecated)]
14611 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14612 where
14613 S: serde::Serializer,
14614 {
14615 let variant = match self {
14616 Self::Unspecified => "SSTABLE_FILTER_LAYOUT_UNSPECIFIED",
14617 Self::Auto => "SSTABLE_FILTER_LAYOUT_AUTO",
14618 Self::Plain => "SSTABLE_FILTER_LAYOUT_PLAIN",
14619 Self::Blocked => "SSTABLE_FILTER_LAYOUT_BLOCKED",
14620 };
14621 serializer.serialize_str(variant)
14622 }
14623}
14624impl<'de> serde::Deserialize<'de> for SstableFilterLayout {
14625 #[allow(deprecated)]
14626 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14627 where
14628 D: serde::Deserializer<'de>,
14629 {
14630 const FIELDS: &[&str] = &[
14631 "SSTABLE_FILTER_LAYOUT_UNSPECIFIED",
14632 "SSTABLE_FILTER_LAYOUT_AUTO",
14633 "SSTABLE_FILTER_LAYOUT_PLAIN",
14634 "SSTABLE_FILTER_LAYOUT_BLOCKED",
14635 ];
14636
14637 struct GeneratedVisitor;
14638
14639 impl serde::de::Visitor<'_> for GeneratedVisitor {
14640 type Value = SstableFilterLayout;
14641
14642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14643 write!(formatter, "expected one of: {:?}", &FIELDS)
14644 }
14645
14646 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14647 where
14648 E: serde::de::Error,
14649 {
14650 i32::try_from(v)
14651 .ok()
14652 .and_then(|x| x.try_into().ok())
14653 .ok_or_else(|| {
14654 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14655 })
14656 }
14657
14658 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14659 where
14660 E: serde::de::Error,
14661 {
14662 i32::try_from(v)
14663 .ok()
14664 .and_then(|x| x.try_into().ok())
14665 .ok_or_else(|| {
14666 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14667 })
14668 }
14669
14670 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14671 where
14672 E: serde::de::Error,
14673 {
14674 match value {
14675 "SSTABLE_FILTER_LAYOUT_UNSPECIFIED" => Ok(SstableFilterLayout::Unspecified),
14676 "SSTABLE_FILTER_LAYOUT_AUTO" => Ok(SstableFilterLayout::Auto),
14677 "SSTABLE_FILTER_LAYOUT_PLAIN" => Ok(SstableFilterLayout::Plain),
14678 "SSTABLE_FILTER_LAYOUT_BLOCKED" => Ok(SstableFilterLayout::Blocked),
14679 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14680 }
14681 }
14682 }
14683 deserializer.deserialize_any(GeneratedVisitor)
14684 }
14685}
14686impl serde::Serialize for SstableFilterType {
14687 #[allow(deprecated)]
14688 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14689 where
14690 S: serde::Serializer,
14691 {
14692 let variant = match self {
14693 Self::SstableFilterUnspecified => "SSTABLE_FILTER_UNSPECIFIED",
14694 Self::SstableFilterNone => "SSTABLE_FILTER_NONE",
14695 Self::SstableFilterXor8 => "SSTABLE_FILTER_XOR8",
14696 Self::SstableFilterXor16 => "SSTABLE_FILTER_XOR16",
14697 };
14698 serializer.serialize_str(variant)
14699 }
14700}
14701impl<'de> serde::Deserialize<'de> for SstableFilterType {
14702 #[allow(deprecated)]
14703 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14704 where
14705 D: serde::Deserializer<'de>,
14706 {
14707 const FIELDS: &[&str] = &[
14708 "SSTABLE_FILTER_UNSPECIFIED",
14709 "SSTABLE_FILTER_NONE",
14710 "SSTABLE_FILTER_XOR8",
14711 "SSTABLE_FILTER_XOR16",
14712 ];
14713
14714 struct GeneratedVisitor;
14715
14716 impl serde::de::Visitor<'_> for GeneratedVisitor {
14717 type Value = SstableFilterType;
14718
14719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14720 write!(formatter, "expected one of: {:?}", &FIELDS)
14721 }
14722
14723 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14724 where
14725 E: serde::de::Error,
14726 {
14727 i32::try_from(v)
14728 .ok()
14729 .and_then(|x| x.try_into().ok())
14730 .ok_or_else(|| {
14731 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14732 })
14733 }
14734
14735 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14736 where
14737 E: serde::de::Error,
14738 {
14739 i32::try_from(v)
14740 .ok()
14741 .and_then(|x| x.try_into().ok())
14742 .ok_or_else(|| {
14743 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14744 })
14745 }
14746
14747 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14748 where
14749 E: serde::de::Error,
14750 {
14751 match value {
14752 "SSTABLE_FILTER_UNSPECIFIED" => Ok(SstableFilterType::SstableFilterUnspecified),
14753 "SSTABLE_FILTER_NONE" => Ok(SstableFilterType::SstableFilterNone),
14754 "SSTABLE_FILTER_XOR8" => Ok(SstableFilterType::SstableFilterXor8),
14755 "SSTABLE_FILTER_XOR16" => Ok(SstableFilterType::SstableFilterXor16),
14756 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14757 }
14758 }
14759 }
14760 deserializer.deserialize_any(GeneratedVisitor)
14761 }
14762}
14763impl serde::Serialize for SstableInfo {
14764 #[allow(deprecated)]
14765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14766 where
14767 S: serde::Serializer,
14768 {
14769 use serde::ser::SerializeStruct;
14770 let mut len = 0;
14771 if self.object_id != 0 {
14772 len += 1;
14773 }
14774 if self.sst_id != 0 {
14775 len += 1;
14776 }
14777 if self.key_range.is_some() {
14778 len += 1;
14779 }
14780 if self.file_size != 0 {
14781 len += 1;
14782 }
14783 if !self.table_ids.is_empty() {
14784 len += 1;
14785 }
14786 if self.meta_offset != 0 {
14787 len += 1;
14788 }
14789 if self.stale_key_count != 0 {
14790 len += 1;
14791 }
14792 if self.total_key_count != 0 {
14793 len += 1;
14794 }
14795 if self.min_epoch != 0 {
14796 len += 1;
14797 }
14798 if self.max_epoch != 0 {
14799 len += 1;
14800 }
14801 if self.uncompressed_file_size != 0 {
14802 len += 1;
14803 }
14804 if self.range_tombstone_count != 0 {
14805 len += 1;
14806 }
14807 if self.bloom_filter_kind != 0 {
14808 len += 1;
14809 }
14810 if self.sst_size != 0 {
14811 len += 1;
14812 }
14813 if self.vnode_statistics.is_some() {
14814 len += 1;
14815 }
14816 if self.filter_type.is_some() {
14817 len += 1;
14818 }
14819 if self.filter_layout.is_some() {
14820 len += 1;
14821 }
14822 let mut struct_ser = serializer.serialize_struct("hummock.SstableInfo", len)?;
14823 if self.object_id != 0 {
14824 #[allow(clippy::needless_borrow)]
14825 #[allow(clippy::needless_borrows_for_generic_args)]
14826 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
14827 }
14828 if self.sst_id != 0 {
14829 #[allow(clippy::needless_borrow)]
14830 #[allow(clippy::needless_borrows_for_generic_args)]
14831 struct_ser.serialize_field("sstId", ToString::to_string(&self.sst_id).as_str())?;
14832 }
14833 if let Some(v) = self.key_range.as_ref() {
14834 struct_ser.serialize_field("keyRange", v)?;
14835 }
14836 if self.file_size != 0 {
14837 #[allow(clippy::needless_borrow)]
14838 #[allow(clippy::needless_borrows_for_generic_args)]
14839 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
14840 }
14841 if !self.table_ids.is_empty() {
14842 struct_ser.serialize_field("tableIds", &self.table_ids)?;
14843 }
14844 if self.meta_offset != 0 {
14845 #[allow(clippy::needless_borrow)]
14846 #[allow(clippy::needless_borrows_for_generic_args)]
14847 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
14848 }
14849 if self.stale_key_count != 0 {
14850 #[allow(clippy::needless_borrow)]
14851 #[allow(clippy::needless_borrows_for_generic_args)]
14852 struct_ser.serialize_field("staleKeyCount", ToString::to_string(&self.stale_key_count).as_str())?;
14853 }
14854 if self.total_key_count != 0 {
14855 #[allow(clippy::needless_borrow)]
14856 #[allow(clippy::needless_borrows_for_generic_args)]
14857 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
14858 }
14859 if self.min_epoch != 0 {
14860 #[allow(clippy::needless_borrow)]
14861 #[allow(clippy::needless_borrows_for_generic_args)]
14862 struct_ser.serialize_field("minEpoch", ToString::to_string(&self.min_epoch).as_str())?;
14863 }
14864 if self.max_epoch != 0 {
14865 #[allow(clippy::needless_borrow)]
14866 #[allow(clippy::needless_borrows_for_generic_args)]
14867 struct_ser.serialize_field("maxEpoch", ToString::to_string(&self.max_epoch).as_str())?;
14868 }
14869 if self.uncompressed_file_size != 0 {
14870 #[allow(clippy::needless_borrow)]
14871 #[allow(clippy::needless_borrows_for_generic_args)]
14872 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
14873 }
14874 if self.range_tombstone_count != 0 {
14875 #[allow(clippy::needless_borrow)]
14876 #[allow(clippy::needless_borrows_for_generic_args)]
14877 struct_ser.serialize_field("rangeTombstoneCount", ToString::to_string(&self.range_tombstone_count).as_str())?;
14878 }
14879 if self.bloom_filter_kind != 0 {
14880 let v = BloomFilterType::try_from(self.bloom_filter_kind)
14881 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.bloom_filter_kind)))?;
14882 struct_ser.serialize_field("bloomFilterKind", &v)?;
14883 }
14884 if self.sst_size != 0 {
14885 #[allow(clippy::needless_borrow)]
14886 #[allow(clippy::needless_borrows_for_generic_args)]
14887 struct_ser.serialize_field("sstSize", ToString::to_string(&self.sst_size).as_str())?;
14888 }
14889 if let Some(v) = self.vnode_statistics.as_ref() {
14890 struct_ser.serialize_field("vnodeStatistics", v)?;
14891 }
14892 if let Some(v) = self.filter_type.as_ref() {
14893 let v = SstableFilterType::try_from(*v)
14894 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
14895 struct_ser.serialize_field("filterType", &v)?;
14896 }
14897 if let Some(v) = self.filter_layout.as_ref() {
14898 let v = SstableFilterLayout::try_from(*v)
14899 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
14900 struct_ser.serialize_field("filterLayout", &v)?;
14901 }
14902 struct_ser.end()
14903 }
14904}
14905impl<'de> serde::Deserialize<'de> for SstableInfo {
14906 #[allow(deprecated)]
14907 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14908 where
14909 D: serde::Deserializer<'de>,
14910 {
14911 const FIELDS: &[&str] = &[
14912 "object_id",
14913 "objectId",
14914 "sst_id",
14915 "sstId",
14916 "key_range",
14917 "keyRange",
14918 "file_size",
14919 "fileSize",
14920 "table_ids",
14921 "tableIds",
14922 "meta_offset",
14923 "metaOffset",
14924 "stale_key_count",
14925 "staleKeyCount",
14926 "total_key_count",
14927 "totalKeyCount",
14928 "min_epoch",
14929 "minEpoch",
14930 "max_epoch",
14931 "maxEpoch",
14932 "uncompressed_file_size",
14933 "uncompressedFileSize",
14934 "range_tombstone_count",
14935 "rangeTombstoneCount",
14936 "bloom_filter_kind",
14937 "bloomFilterKind",
14938 "sst_size",
14939 "sstSize",
14940 "vnode_statistics",
14941 "vnodeStatistics",
14942 "filter_type",
14943 "filterType",
14944 "filter_layout",
14945 "filterLayout",
14946 ];
14947
14948 #[allow(clippy::enum_variant_names)]
14949 enum GeneratedField {
14950 ObjectId,
14951 SstId,
14952 KeyRange,
14953 FileSize,
14954 TableIds,
14955 MetaOffset,
14956 StaleKeyCount,
14957 TotalKeyCount,
14958 MinEpoch,
14959 MaxEpoch,
14960 UncompressedFileSize,
14961 RangeTombstoneCount,
14962 BloomFilterKind,
14963 SstSize,
14964 VnodeStatistics,
14965 FilterType,
14966 FilterLayout,
14967 }
14968 impl<'de> serde::Deserialize<'de> for GeneratedField {
14969 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14970 where
14971 D: serde::Deserializer<'de>,
14972 {
14973 struct GeneratedVisitor;
14974
14975 impl serde::de::Visitor<'_> for GeneratedVisitor {
14976 type Value = GeneratedField;
14977
14978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14979 write!(formatter, "expected one of: {:?}", &FIELDS)
14980 }
14981
14982 #[allow(unused_variables)]
14983 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14984 where
14985 E: serde::de::Error,
14986 {
14987 match value {
14988 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
14989 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
14990 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
14991 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
14992 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
14993 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
14994 "staleKeyCount" | "stale_key_count" => Ok(GeneratedField::StaleKeyCount),
14995 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
14996 "minEpoch" | "min_epoch" => Ok(GeneratedField::MinEpoch),
14997 "maxEpoch" | "max_epoch" => Ok(GeneratedField::MaxEpoch),
14998 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
14999 "rangeTombstoneCount" | "range_tombstone_count" => Ok(GeneratedField::RangeTombstoneCount),
15000 "bloomFilterKind" | "bloom_filter_kind" => Ok(GeneratedField::BloomFilterKind),
15001 "sstSize" | "sst_size" => Ok(GeneratedField::SstSize),
15002 "vnodeStatistics" | "vnode_statistics" => Ok(GeneratedField::VnodeStatistics),
15003 "filterType" | "filter_type" => Ok(GeneratedField::FilterType),
15004 "filterLayout" | "filter_layout" => Ok(GeneratedField::FilterLayout),
15005 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15006 }
15007 }
15008 }
15009 deserializer.deserialize_identifier(GeneratedVisitor)
15010 }
15011 }
15012 struct GeneratedVisitor;
15013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15014 type Value = SstableInfo;
15015
15016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15017 formatter.write_str("struct hummock.SstableInfo")
15018 }
15019
15020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SstableInfo, V::Error>
15021 where
15022 V: serde::de::MapAccess<'de>,
15023 {
15024 let mut object_id__ = None;
15025 let mut sst_id__ = None;
15026 let mut key_range__ = None;
15027 let mut file_size__ = None;
15028 let mut table_ids__ = None;
15029 let mut meta_offset__ = None;
15030 let mut stale_key_count__ = None;
15031 let mut total_key_count__ = None;
15032 let mut min_epoch__ = None;
15033 let mut max_epoch__ = None;
15034 let mut uncompressed_file_size__ = None;
15035 let mut range_tombstone_count__ = None;
15036 let mut bloom_filter_kind__ = None;
15037 let mut sst_size__ = None;
15038 let mut vnode_statistics__ = None;
15039 let mut filter_type__ = None;
15040 let mut filter_layout__ = None;
15041 while let Some(k) = map_.next_key()? {
15042 match k {
15043 GeneratedField::ObjectId => {
15044 if object_id__.is_some() {
15045 return Err(serde::de::Error::duplicate_field("objectId"));
15046 }
15047 object_id__ =
15048 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15049 ;
15050 }
15051 GeneratedField::SstId => {
15052 if sst_id__.is_some() {
15053 return Err(serde::de::Error::duplicate_field("sstId"));
15054 }
15055 sst_id__ =
15056 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15057 ;
15058 }
15059 GeneratedField::KeyRange => {
15060 if key_range__.is_some() {
15061 return Err(serde::de::Error::duplicate_field("keyRange"));
15062 }
15063 key_range__ = map_.next_value()?;
15064 }
15065 GeneratedField::FileSize => {
15066 if file_size__.is_some() {
15067 return Err(serde::de::Error::duplicate_field("fileSize"));
15068 }
15069 file_size__ =
15070 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15071 ;
15072 }
15073 GeneratedField::TableIds => {
15074 if table_ids__.is_some() {
15075 return Err(serde::de::Error::duplicate_field("tableIds"));
15076 }
15077 table_ids__ =
15078 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15079 .into_iter().map(|x| x.0).collect())
15080 ;
15081 }
15082 GeneratedField::MetaOffset => {
15083 if meta_offset__.is_some() {
15084 return Err(serde::de::Error::duplicate_field("metaOffset"));
15085 }
15086 meta_offset__ =
15087 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15088 ;
15089 }
15090 GeneratedField::StaleKeyCount => {
15091 if stale_key_count__.is_some() {
15092 return Err(serde::de::Error::duplicate_field("staleKeyCount"));
15093 }
15094 stale_key_count__ =
15095 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15096 ;
15097 }
15098 GeneratedField::TotalKeyCount => {
15099 if total_key_count__.is_some() {
15100 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
15101 }
15102 total_key_count__ =
15103 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15104 ;
15105 }
15106 GeneratedField::MinEpoch => {
15107 if min_epoch__.is_some() {
15108 return Err(serde::de::Error::duplicate_field("minEpoch"));
15109 }
15110 min_epoch__ =
15111 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15112 ;
15113 }
15114 GeneratedField::MaxEpoch => {
15115 if max_epoch__.is_some() {
15116 return Err(serde::de::Error::duplicate_field("maxEpoch"));
15117 }
15118 max_epoch__ =
15119 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15120 ;
15121 }
15122 GeneratedField::UncompressedFileSize => {
15123 if uncompressed_file_size__.is_some() {
15124 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
15125 }
15126 uncompressed_file_size__ =
15127 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15128 ;
15129 }
15130 GeneratedField::RangeTombstoneCount => {
15131 if range_tombstone_count__.is_some() {
15132 return Err(serde::de::Error::duplicate_field("rangeTombstoneCount"));
15133 }
15134 range_tombstone_count__ =
15135 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15136 ;
15137 }
15138 GeneratedField::BloomFilterKind => {
15139 if bloom_filter_kind__.is_some() {
15140 return Err(serde::de::Error::duplicate_field("bloomFilterKind"));
15141 }
15142 bloom_filter_kind__ = Some(map_.next_value::<BloomFilterType>()? as i32);
15143 }
15144 GeneratedField::SstSize => {
15145 if sst_size__.is_some() {
15146 return Err(serde::de::Error::duplicate_field("sstSize"));
15147 }
15148 sst_size__ =
15149 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15150 ;
15151 }
15152 GeneratedField::VnodeStatistics => {
15153 if vnode_statistics__.is_some() {
15154 return Err(serde::de::Error::duplicate_field("vnodeStatistics"));
15155 }
15156 vnode_statistics__ = map_.next_value()?;
15157 }
15158 GeneratedField::FilterType => {
15159 if filter_type__.is_some() {
15160 return Err(serde::de::Error::duplicate_field("filterType"));
15161 }
15162 filter_type__ = map_.next_value::<::std::option::Option<SstableFilterType>>()?.map(|x| x as i32);
15163 }
15164 GeneratedField::FilterLayout => {
15165 if filter_layout__.is_some() {
15166 return Err(serde::de::Error::duplicate_field("filterLayout"));
15167 }
15168 filter_layout__ = map_.next_value::<::std::option::Option<SstableFilterLayout>>()?.map(|x| x as i32);
15169 }
15170 }
15171 }
15172 Ok(SstableInfo {
15173 object_id: object_id__.unwrap_or_default(),
15174 sst_id: sst_id__.unwrap_or_default(),
15175 key_range: key_range__,
15176 file_size: file_size__.unwrap_or_default(),
15177 table_ids: table_ids__.unwrap_or_default(),
15178 meta_offset: meta_offset__.unwrap_or_default(),
15179 stale_key_count: stale_key_count__.unwrap_or_default(),
15180 total_key_count: total_key_count__.unwrap_or_default(),
15181 min_epoch: min_epoch__.unwrap_or_default(),
15182 max_epoch: max_epoch__.unwrap_or_default(),
15183 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
15184 range_tombstone_count: range_tombstone_count__.unwrap_or_default(),
15185 bloom_filter_kind: bloom_filter_kind__.unwrap_or_default(),
15186 sst_size: sst_size__.unwrap_or_default(),
15187 vnode_statistics: vnode_statistics__,
15188 filter_type: filter_type__,
15189 filter_layout: filter_layout__,
15190 })
15191 }
15192 }
15193 deserializer.deserialize_struct("hummock.SstableInfo", FIELDS, GeneratedVisitor)
15194 }
15195}
15196impl serde::Serialize for StateTableInfo {
15197 #[allow(deprecated)]
15198 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15199 where
15200 S: serde::Serializer,
15201 {
15202 use serde::ser::SerializeStruct;
15203 let mut len = 0;
15204 if self.committed_epoch != 0 {
15205 len += 1;
15206 }
15207 if self.compaction_group_id != 0 {
15208 len += 1;
15209 }
15210 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfo", len)?;
15211 if self.committed_epoch != 0 {
15212 #[allow(clippy::needless_borrow)]
15213 #[allow(clippy::needless_borrows_for_generic_args)]
15214 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
15215 }
15216 if self.compaction_group_id != 0 {
15217 #[allow(clippy::needless_borrow)]
15218 #[allow(clippy::needless_borrows_for_generic_args)]
15219 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
15220 }
15221 struct_ser.end()
15222 }
15223}
15224impl<'de> serde::Deserialize<'de> for StateTableInfo {
15225 #[allow(deprecated)]
15226 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15227 where
15228 D: serde::Deserializer<'de>,
15229 {
15230 const FIELDS: &[&str] = &[
15231 "committed_epoch",
15232 "committedEpoch",
15233 "compaction_group_id",
15234 "compactionGroupId",
15235 ];
15236
15237 #[allow(clippy::enum_variant_names)]
15238 enum GeneratedField {
15239 CommittedEpoch,
15240 CompactionGroupId,
15241 }
15242 impl<'de> serde::Deserialize<'de> for GeneratedField {
15243 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15244 where
15245 D: serde::Deserializer<'de>,
15246 {
15247 struct GeneratedVisitor;
15248
15249 impl serde::de::Visitor<'_> for GeneratedVisitor {
15250 type Value = GeneratedField;
15251
15252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15253 write!(formatter, "expected one of: {:?}", &FIELDS)
15254 }
15255
15256 #[allow(unused_variables)]
15257 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15258 where
15259 E: serde::de::Error,
15260 {
15261 match value {
15262 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
15263 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
15264 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15265 }
15266 }
15267 }
15268 deserializer.deserialize_identifier(GeneratedVisitor)
15269 }
15270 }
15271 struct GeneratedVisitor;
15272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15273 type Value = StateTableInfo;
15274
15275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15276 formatter.write_str("struct hummock.StateTableInfo")
15277 }
15278
15279 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfo, V::Error>
15280 where
15281 V: serde::de::MapAccess<'de>,
15282 {
15283 let mut committed_epoch__ = None;
15284 let mut compaction_group_id__ = None;
15285 while let Some(k) = map_.next_key()? {
15286 match k {
15287 GeneratedField::CommittedEpoch => {
15288 if committed_epoch__.is_some() {
15289 return Err(serde::de::Error::duplicate_field("committedEpoch"));
15290 }
15291 committed_epoch__ =
15292 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15293 ;
15294 }
15295 GeneratedField::CompactionGroupId => {
15296 if compaction_group_id__.is_some() {
15297 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
15298 }
15299 compaction_group_id__ =
15300 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15301 ;
15302 }
15303 }
15304 }
15305 Ok(StateTableInfo {
15306 committed_epoch: committed_epoch__.unwrap_or_default(),
15307 compaction_group_id: compaction_group_id__.unwrap_or_default(),
15308 })
15309 }
15310 }
15311 deserializer.deserialize_struct("hummock.StateTableInfo", FIELDS, GeneratedVisitor)
15312 }
15313}
15314impl serde::Serialize for StateTableInfoDelta {
15315 #[allow(deprecated)]
15316 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15317 where
15318 S: serde::Serializer,
15319 {
15320 use serde::ser::SerializeStruct;
15321 let mut len = 0;
15322 if self.committed_epoch != 0 {
15323 len += 1;
15324 }
15325 if self.compaction_group_id != 0 {
15326 len += 1;
15327 }
15328 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfoDelta", len)?;
15329 if self.committed_epoch != 0 {
15330 #[allow(clippy::needless_borrow)]
15331 #[allow(clippy::needless_borrows_for_generic_args)]
15332 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
15333 }
15334 if self.compaction_group_id != 0 {
15335 #[allow(clippy::needless_borrow)]
15336 #[allow(clippy::needless_borrows_for_generic_args)]
15337 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
15338 }
15339 struct_ser.end()
15340 }
15341}
15342impl<'de> serde::Deserialize<'de> for StateTableInfoDelta {
15343 #[allow(deprecated)]
15344 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15345 where
15346 D: serde::Deserializer<'de>,
15347 {
15348 const FIELDS: &[&str] = &[
15349 "committed_epoch",
15350 "committedEpoch",
15351 "compaction_group_id",
15352 "compactionGroupId",
15353 ];
15354
15355 #[allow(clippy::enum_variant_names)]
15356 enum GeneratedField {
15357 CommittedEpoch,
15358 CompactionGroupId,
15359 }
15360 impl<'de> serde::Deserialize<'de> for GeneratedField {
15361 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15362 where
15363 D: serde::Deserializer<'de>,
15364 {
15365 struct GeneratedVisitor;
15366
15367 impl serde::de::Visitor<'_> for GeneratedVisitor {
15368 type Value = GeneratedField;
15369
15370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15371 write!(formatter, "expected one of: {:?}", &FIELDS)
15372 }
15373
15374 #[allow(unused_variables)]
15375 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15376 where
15377 E: serde::de::Error,
15378 {
15379 match value {
15380 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
15381 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
15382 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15383 }
15384 }
15385 }
15386 deserializer.deserialize_identifier(GeneratedVisitor)
15387 }
15388 }
15389 struct GeneratedVisitor;
15390 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15391 type Value = StateTableInfoDelta;
15392
15393 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15394 formatter.write_str("struct hummock.StateTableInfoDelta")
15395 }
15396
15397 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfoDelta, V::Error>
15398 where
15399 V: serde::de::MapAccess<'de>,
15400 {
15401 let mut committed_epoch__ = None;
15402 let mut compaction_group_id__ = None;
15403 while let Some(k) = map_.next_key()? {
15404 match k {
15405 GeneratedField::CommittedEpoch => {
15406 if committed_epoch__.is_some() {
15407 return Err(serde::de::Error::duplicate_field("committedEpoch"));
15408 }
15409 committed_epoch__ =
15410 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15411 ;
15412 }
15413 GeneratedField::CompactionGroupId => {
15414 if compaction_group_id__.is_some() {
15415 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
15416 }
15417 compaction_group_id__ =
15418 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15419 ;
15420 }
15421 }
15422 }
15423 Ok(StateTableInfoDelta {
15424 committed_epoch: committed_epoch__.unwrap_or_default(),
15425 compaction_group_id: compaction_group_id__.unwrap_or_default(),
15426 })
15427 }
15428 }
15429 deserializer.deserialize_struct("hummock.StateTableInfoDelta", FIELDS, GeneratedVisitor)
15430 }
15431}
15432impl serde::Serialize for SubscribeCompactionEventRequest {
15433 #[allow(deprecated)]
15434 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15435 where
15436 S: serde::Serializer,
15437 {
15438 use serde::ser::SerializeStruct;
15439 let mut len = 0;
15440 if self.create_at != 0 {
15441 len += 1;
15442 }
15443 if self.event.is_some() {
15444 len += 1;
15445 }
15446 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest", len)?;
15447 if self.create_at != 0 {
15448 #[allow(clippy::needless_borrow)]
15449 #[allow(clippy::needless_borrows_for_generic_args)]
15450 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
15451 }
15452 if let Some(v) = self.event.as_ref() {
15453 match v {
15454 subscribe_compaction_event_request::Event::Register(v) => {
15455 struct_ser.serialize_field("register", v)?;
15456 }
15457 subscribe_compaction_event_request::Event::PullTask(v) => {
15458 struct_ser.serialize_field("pullTask", v)?;
15459 }
15460 subscribe_compaction_event_request::Event::ReportTask(v) => {
15461 struct_ser.serialize_field("reportTask", v)?;
15462 }
15463 subscribe_compaction_event_request::Event::HeartBeat(v) => {
15464 struct_ser.serialize_field("heartBeat", v)?;
15465 }
15466 }
15467 }
15468 struct_ser.end()
15469 }
15470}
15471impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventRequest {
15472 #[allow(deprecated)]
15473 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15474 where
15475 D: serde::Deserializer<'de>,
15476 {
15477 const FIELDS: &[&str] = &[
15478 "create_at",
15479 "createAt",
15480 "register",
15481 "pull_task",
15482 "pullTask",
15483 "report_task",
15484 "reportTask",
15485 "heart_beat",
15486 "heartBeat",
15487 ];
15488
15489 #[allow(clippy::enum_variant_names)]
15490 enum GeneratedField {
15491 CreateAt,
15492 Register,
15493 PullTask,
15494 ReportTask,
15495 HeartBeat,
15496 }
15497 impl<'de> serde::Deserialize<'de> for GeneratedField {
15498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15499 where
15500 D: serde::Deserializer<'de>,
15501 {
15502 struct GeneratedVisitor;
15503
15504 impl serde::de::Visitor<'_> for GeneratedVisitor {
15505 type Value = GeneratedField;
15506
15507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15508 write!(formatter, "expected one of: {:?}", &FIELDS)
15509 }
15510
15511 #[allow(unused_variables)]
15512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15513 where
15514 E: serde::de::Error,
15515 {
15516 match value {
15517 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
15518 "register" => Ok(GeneratedField::Register),
15519 "pullTask" | "pull_task" => Ok(GeneratedField::PullTask),
15520 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
15521 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
15522 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15523 }
15524 }
15525 }
15526 deserializer.deserialize_identifier(GeneratedVisitor)
15527 }
15528 }
15529 struct GeneratedVisitor;
15530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15531 type Value = SubscribeCompactionEventRequest;
15532
15533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15534 formatter.write_str("struct hummock.SubscribeCompactionEventRequest")
15535 }
15536
15537 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventRequest, V::Error>
15538 where
15539 V: serde::de::MapAccess<'de>,
15540 {
15541 let mut create_at__ = None;
15542 let mut event__ = None;
15543 while let Some(k) = map_.next_key()? {
15544 match k {
15545 GeneratedField::CreateAt => {
15546 if create_at__.is_some() {
15547 return Err(serde::de::Error::duplicate_field("createAt"));
15548 }
15549 create_at__ =
15550 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15551 ;
15552 }
15553 GeneratedField::Register => {
15554 if event__.is_some() {
15555 return Err(serde::de::Error::duplicate_field("register"));
15556 }
15557 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::Register)
15558;
15559 }
15560 GeneratedField::PullTask => {
15561 if event__.is_some() {
15562 return Err(serde::de::Error::duplicate_field("pullTask"));
15563 }
15564 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::PullTask)
15565;
15566 }
15567 GeneratedField::ReportTask => {
15568 if event__.is_some() {
15569 return Err(serde::de::Error::duplicate_field("reportTask"));
15570 }
15571 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::ReportTask)
15572;
15573 }
15574 GeneratedField::HeartBeat => {
15575 if event__.is_some() {
15576 return Err(serde::de::Error::duplicate_field("heartBeat"));
15577 }
15578 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::HeartBeat)
15579;
15580 }
15581 }
15582 }
15583 Ok(SubscribeCompactionEventRequest {
15584 create_at: create_at__.unwrap_or_default(),
15585 event: event__,
15586 })
15587 }
15588 }
15589 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest", FIELDS, GeneratedVisitor)
15590 }
15591}
15592impl serde::Serialize for subscribe_compaction_event_request::HeartBeat {
15593 #[allow(deprecated)]
15594 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15595 where
15596 S: serde::Serializer,
15597 {
15598 use serde::ser::SerializeStruct;
15599 let mut len = 0;
15600 if !self.progress.is_empty() {
15601 len += 1;
15602 }
15603 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", len)?;
15604 if !self.progress.is_empty() {
15605 struct_ser.serialize_field("progress", &self.progress)?;
15606 }
15607 struct_ser.end()
15608 }
15609}
15610impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::HeartBeat {
15611 #[allow(deprecated)]
15612 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15613 where
15614 D: serde::Deserializer<'de>,
15615 {
15616 const FIELDS: &[&str] = &[
15617 "progress",
15618 ];
15619
15620 #[allow(clippy::enum_variant_names)]
15621 enum GeneratedField {
15622 Progress,
15623 }
15624 impl<'de> serde::Deserialize<'de> for GeneratedField {
15625 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15626 where
15627 D: serde::Deserializer<'de>,
15628 {
15629 struct GeneratedVisitor;
15630
15631 impl serde::de::Visitor<'_> for GeneratedVisitor {
15632 type Value = GeneratedField;
15633
15634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15635 write!(formatter, "expected one of: {:?}", &FIELDS)
15636 }
15637
15638 #[allow(unused_variables)]
15639 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15640 where
15641 E: serde::de::Error,
15642 {
15643 match value {
15644 "progress" => Ok(GeneratedField::Progress),
15645 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15646 }
15647 }
15648 }
15649 deserializer.deserialize_identifier(GeneratedVisitor)
15650 }
15651 }
15652 struct GeneratedVisitor;
15653 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15654 type Value = subscribe_compaction_event_request::HeartBeat;
15655
15656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15657 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.HeartBeat")
15658 }
15659
15660 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::HeartBeat, V::Error>
15661 where
15662 V: serde::de::MapAccess<'de>,
15663 {
15664 let mut progress__ = None;
15665 while let Some(k) = map_.next_key()? {
15666 match k {
15667 GeneratedField::Progress => {
15668 if progress__.is_some() {
15669 return Err(serde::de::Error::duplicate_field("progress"));
15670 }
15671 progress__ = Some(map_.next_value()?);
15672 }
15673 }
15674 }
15675 Ok(subscribe_compaction_event_request::HeartBeat {
15676 progress: progress__.unwrap_or_default(),
15677 })
15678 }
15679 }
15680 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", FIELDS, GeneratedVisitor)
15681 }
15682}
15683impl serde::Serialize for subscribe_compaction_event_request::PullTask {
15684 #[allow(deprecated)]
15685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15686 where
15687 S: serde::Serializer,
15688 {
15689 use serde::ser::SerializeStruct;
15690 let mut len = 0;
15691 if self.pull_task_count != 0 {
15692 len += 1;
15693 }
15694 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", len)?;
15695 if self.pull_task_count != 0 {
15696 struct_ser.serialize_field("pullTaskCount", &self.pull_task_count)?;
15697 }
15698 struct_ser.end()
15699 }
15700}
15701impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::PullTask {
15702 #[allow(deprecated)]
15703 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15704 where
15705 D: serde::Deserializer<'de>,
15706 {
15707 const FIELDS: &[&str] = &[
15708 "pull_task_count",
15709 "pullTaskCount",
15710 ];
15711
15712 #[allow(clippy::enum_variant_names)]
15713 enum GeneratedField {
15714 PullTaskCount,
15715 }
15716 impl<'de> serde::Deserialize<'de> for GeneratedField {
15717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15718 where
15719 D: serde::Deserializer<'de>,
15720 {
15721 struct GeneratedVisitor;
15722
15723 impl serde::de::Visitor<'_> for GeneratedVisitor {
15724 type Value = GeneratedField;
15725
15726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15727 write!(formatter, "expected one of: {:?}", &FIELDS)
15728 }
15729
15730 #[allow(unused_variables)]
15731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15732 where
15733 E: serde::de::Error,
15734 {
15735 match value {
15736 "pullTaskCount" | "pull_task_count" => Ok(GeneratedField::PullTaskCount),
15737 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15738 }
15739 }
15740 }
15741 deserializer.deserialize_identifier(GeneratedVisitor)
15742 }
15743 }
15744 struct GeneratedVisitor;
15745 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15746 type Value = subscribe_compaction_event_request::PullTask;
15747
15748 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15749 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.PullTask")
15750 }
15751
15752 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::PullTask, V::Error>
15753 where
15754 V: serde::de::MapAccess<'de>,
15755 {
15756 let mut pull_task_count__ = None;
15757 while let Some(k) = map_.next_key()? {
15758 match k {
15759 GeneratedField::PullTaskCount => {
15760 if pull_task_count__.is_some() {
15761 return Err(serde::de::Error::duplicate_field("pullTaskCount"));
15762 }
15763 pull_task_count__ =
15764 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15765 ;
15766 }
15767 }
15768 }
15769 Ok(subscribe_compaction_event_request::PullTask {
15770 pull_task_count: pull_task_count__.unwrap_or_default(),
15771 })
15772 }
15773 }
15774 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", FIELDS, GeneratedVisitor)
15775 }
15776}
15777impl serde::Serialize for subscribe_compaction_event_request::Register {
15778 #[allow(deprecated)]
15779 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15780 where
15781 S: serde::Serializer,
15782 {
15783 use serde::ser::SerializeStruct;
15784 let mut len = 0;
15785 if self.context_id != 0 {
15786 len += 1;
15787 }
15788 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.Register", len)?;
15789 if self.context_id != 0 {
15790 struct_ser.serialize_field("contextId", &self.context_id)?;
15791 }
15792 struct_ser.end()
15793 }
15794}
15795impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::Register {
15796 #[allow(deprecated)]
15797 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15798 where
15799 D: serde::Deserializer<'de>,
15800 {
15801 const FIELDS: &[&str] = &[
15802 "context_id",
15803 "contextId",
15804 ];
15805
15806 #[allow(clippy::enum_variant_names)]
15807 enum GeneratedField {
15808 ContextId,
15809 }
15810 impl<'de> serde::Deserialize<'de> for GeneratedField {
15811 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15812 where
15813 D: serde::Deserializer<'de>,
15814 {
15815 struct GeneratedVisitor;
15816
15817 impl serde::de::Visitor<'_> for GeneratedVisitor {
15818 type Value = GeneratedField;
15819
15820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15821 write!(formatter, "expected one of: {:?}", &FIELDS)
15822 }
15823
15824 #[allow(unused_variables)]
15825 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15826 where
15827 E: serde::de::Error,
15828 {
15829 match value {
15830 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15831 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15832 }
15833 }
15834 }
15835 deserializer.deserialize_identifier(GeneratedVisitor)
15836 }
15837 }
15838 struct GeneratedVisitor;
15839 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15840 type Value = subscribe_compaction_event_request::Register;
15841
15842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15843 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.Register")
15844 }
15845
15846 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::Register, V::Error>
15847 where
15848 V: serde::de::MapAccess<'de>,
15849 {
15850 let mut context_id__ = None;
15851 while let Some(k) = map_.next_key()? {
15852 match k {
15853 GeneratedField::ContextId => {
15854 if context_id__.is_some() {
15855 return Err(serde::de::Error::duplicate_field("contextId"));
15856 }
15857 context_id__ =
15858 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15859 ;
15860 }
15861 }
15862 }
15863 Ok(subscribe_compaction_event_request::Register {
15864 context_id: context_id__.unwrap_or_default(),
15865 })
15866 }
15867 }
15868 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.Register", FIELDS, GeneratedVisitor)
15869 }
15870}
15871impl serde::Serialize for subscribe_compaction_event_request::ReportTask {
15872 #[allow(deprecated)]
15873 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15874 where
15875 S: serde::Serializer,
15876 {
15877 use serde::ser::SerializeStruct;
15878 let mut len = 0;
15879 if !self.table_stats_change.is_empty() {
15880 len += 1;
15881 }
15882 if self.task_id != 0 {
15883 len += 1;
15884 }
15885 if self.task_status != 0 {
15886 len += 1;
15887 }
15888 if !self.sorted_output_ssts.is_empty() {
15889 len += 1;
15890 }
15891 if !self.object_timestamps.is_empty() {
15892 len += 1;
15893 }
15894 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", len)?;
15895 if !self.table_stats_change.is_empty() {
15896 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
15897 }
15898 if self.task_id != 0 {
15899 #[allow(clippy::needless_borrow)]
15900 #[allow(clippy::needless_borrows_for_generic_args)]
15901 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
15902 }
15903 if self.task_status != 0 {
15904 let v = compact_task::TaskStatus::try_from(self.task_status)
15905 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
15906 struct_ser.serialize_field("taskStatus", &v)?;
15907 }
15908 if !self.sorted_output_ssts.is_empty() {
15909 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
15910 }
15911 if !self.object_timestamps.is_empty() {
15912 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
15913 .map(|(k, v)| (k, v.to_string())).collect();
15914 struct_ser.serialize_field("objectTimestamps", &v)?;
15915 }
15916 struct_ser.end()
15917 }
15918}
15919impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::ReportTask {
15920 #[allow(deprecated)]
15921 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15922 where
15923 D: serde::Deserializer<'de>,
15924 {
15925 const FIELDS: &[&str] = &[
15926 "table_stats_change",
15927 "tableStatsChange",
15928 "task_id",
15929 "taskId",
15930 "task_status",
15931 "taskStatus",
15932 "sorted_output_ssts",
15933 "sortedOutputSsts",
15934 "object_timestamps",
15935 "objectTimestamps",
15936 ];
15937
15938 #[allow(clippy::enum_variant_names)]
15939 enum GeneratedField {
15940 TableStatsChange,
15941 TaskId,
15942 TaskStatus,
15943 SortedOutputSsts,
15944 ObjectTimestamps,
15945 }
15946 impl<'de> serde::Deserialize<'de> for GeneratedField {
15947 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15948 where
15949 D: serde::Deserializer<'de>,
15950 {
15951 struct GeneratedVisitor;
15952
15953 impl serde::de::Visitor<'_> for GeneratedVisitor {
15954 type Value = GeneratedField;
15955
15956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15957 write!(formatter, "expected one of: {:?}", &FIELDS)
15958 }
15959
15960 #[allow(unused_variables)]
15961 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15962 where
15963 E: serde::de::Error,
15964 {
15965 match value {
15966 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
15967 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
15968 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
15969 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
15970 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
15971 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15972 }
15973 }
15974 }
15975 deserializer.deserialize_identifier(GeneratedVisitor)
15976 }
15977 }
15978 struct GeneratedVisitor;
15979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15980 type Value = subscribe_compaction_event_request::ReportTask;
15981
15982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15983 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.ReportTask")
15984 }
15985
15986 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::ReportTask, V::Error>
15987 where
15988 V: serde::de::MapAccess<'de>,
15989 {
15990 let mut table_stats_change__ = None;
15991 let mut task_id__ = None;
15992 let mut task_status__ = None;
15993 let mut sorted_output_ssts__ = None;
15994 let mut object_timestamps__ = None;
15995 while let Some(k) = map_.next_key()? {
15996 match k {
15997 GeneratedField::TableStatsChange => {
15998 if table_stats_change__.is_some() {
15999 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
16000 }
16001 table_stats_change__ = Some(
16002 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16003 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16004 );
16005 }
16006 GeneratedField::TaskId => {
16007 if task_id__.is_some() {
16008 return Err(serde::de::Error::duplicate_field("taskId"));
16009 }
16010 task_id__ =
16011 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16012 ;
16013 }
16014 GeneratedField::TaskStatus => {
16015 if task_status__.is_some() {
16016 return Err(serde::de::Error::duplicate_field("taskStatus"));
16017 }
16018 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
16019 }
16020 GeneratedField::SortedOutputSsts => {
16021 if sorted_output_ssts__.is_some() {
16022 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
16023 }
16024 sorted_output_ssts__ = Some(map_.next_value()?);
16025 }
16026 GeneratedField::ObjectTimestamps => {
16027 if object_timestamps__.is_some() {
16028 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
16029 }
16030 object_timestamps__ = Some(
16031 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
16032 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
16033 );
16034 }
16035 }
16036 }
16037 Ok(subscribe_compaction_event_request::ReportTask {
16038 table_stats_change: table_stats_change__.unwrap_or_default(),
16039 task_id: task_id__.unwrap_or_default(),
16040 task_status: task_status__.unwrap_or_default(),
16041 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
16042 object_timestamps: object_timestamps__.unwrap_or_default(),
16043 })
16044 }
16045 }
16046 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", FIELDS, GeneratedVisitor)
16047 }
16048}
16049impl serde::Serialize for SubscribeCompactionEventResponse {
16050 #[allow(deprecated)]
16051 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16052 where
16053 S: serde::Serializer,
16054 {
16055 use serde::ser::SerializeStruct;
16056 let mut len = 0;
16057 if self.create_at != 0 {
16058 len += 1;
16059 }
16060 if self.event.is_some() {
16061 len += 1;
16062 }
16063 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse", len)?;
16064 if self.create_at != 0 {
16065 #[allow(clippy::needless_borrow)]
16066 #[allow(clippy::needless_borrows_for_generic_args)]
16067 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
16068 }
16069 if let Some(v) = self.event.as_ref() {
16070 match v {
16071 subscribe_compaction_event_response::Event::CompactTask(v) => {
16072 struct_ser.serialize_field("compactTask", v)?;
16073 }
16074 subscribe_compaction_event_response::Event::VacuumTask(v) => {
16075 struct_ser.serialize_field("vacuumTask", v)?;
16076 }
16077 subscribe_compaction_event_response::Event::FullScanTask(v) => {
16078 struct_ser.serialize_field("fullScanTask", v)?;
16079 }
16080 subscribe_compaction_event_response::Event::ValidationTask(v) => {
16081 struct_ser.serialize_field("validationTask", v)?;
16082 }
16083 subscribe_compaction_event_response::Event::CancelCompactTask(v) => {
16084 struct_ser.serialize_field("cancelCompactTask", v)?;
16085 }
16086 subscribe_compaction_event_response::Event::PullTaskAck(v) => {
16087 struct_ser.serialize_field("pullTaskAck", v)?;
16088 }
16089 }
16090 }
16091 struct_ser.end()
16092 }
16093}
16094impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventResponse {
16095 #[allow(deprecated)]
16096 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16097 where
16098 D: serde::Deserializer<'de>,
16099 {
16100 const FIELDS: &[&str] = &[
16101 "create_at",
16102 "createAt",
16103 "compact_task",
16104 "compactTask",
16105 "vacuum_task",
16106 "vacuumTask",
16107 "full_scan_task",
16108 "fullScanTask",
16109 "validation_task",
16110 "validationTask",
16111 "cancel_compact_task",
16112 "cancelCompactTask",
16113 "pull_task_ack",
16114 "pullTaskAck",
16115 ];
16116
16117 #[allow(clippy::enum_variant_names)]
16118 enum GeneratedField {
16119 CreateAt,
16120 CompactTask,
16121 VacuumTask,
16122 FullScanTask,
16123 ValidationTask,
16124 CancelCompactTask,
16125 PullTaskAck,
16126 }
16127 impl<'de> serde::Deserialize<'de> for GeneratedField {
16128 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16129 where
16130 D: serde::Deserializer<'de>,
16131 {
16132 struct GeneratedVisitor;
16133
16134 impl serde::de::Visitor<'_> for GeneratedVisitor {
16135 type Value = GeneratedField;
16136
16137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16138 write!(formatter, "expected one of: {:?}", &FIELDS)
16139 }
16140
16141 #[allow(unused_variables)]
16142 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16143 where
16144 E: serde::de::Error,
16145 {
16146 match value {
16147 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
16148 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
16149 "vacuumTask" | "vacuum_task" => Ok(GeneratedField::VacuumTask),
16150 "fullScanTask" | "full_scan_task" => Ok(GeneratedField::FullScanTask),
16151 "validationTask" | "validation_task" => Ok(GeneratedField::ValidationTask),
16152 "cancelCompactTask" | "cancel_compact_task" => Ok(GeneratedField::CancelCompactTask),
16153 "pullTaskAck" | "pull_task_ack" => Ok(GeneratedField::PullTaskAck),
16154 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16155 }
16156 }
16157 }
16158 deserializer.deserialize_identifier(GeneratedVisitor)
16159 }
16160 }
16161 struct GeneratedVisitor;
16162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16163 type Value = SubscribeCompactionEventResponse;
16164
16165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16166 formatter.write_str("struct hummock.SubscribeCompactionEventResponse")
16167 }
16168
16169 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventResponse, V::Error>
16170 where
16171 V: serde::de::MapAccess<'de>,
16172 {
16173 let mut create_at__ = None;
16174 let mut event__ = None;
16175 while let Some(k) = map_.next_key()? {
16176 match k {
16177 GeneratedField::CreateAt => {
16178 if create_at__.is_some() {
16179 return Err(serde::de::Error::duplicate_field("createAt"));
16180 }
16181 create_at__ =
16182 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16183 ;
16184 }
16185 GeneratedField::CompactTask => {
16186 if event__.is_some() {
16187 return Err(serde::de::Error::duplicate_field("compactTask"));
16188 }
16189 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CompactTask)
16190;
16191 }
16192 GeneratedField::VacuumTask => {
16193 if event__.is_some() {
16194 return Err(serde::de::Error::duplicate_field("vacuumTask"));
16195 }
16196 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::VacuumTask)
16197;
16198 }
16199 GeneratedField::FullScanTask => {
16200 if event__.is_some() {
16201 return Err(serde::de::Error::duplicate_field("fullScanTask"));
16202 }
16203 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::FullScanTask)
16204;
16205 }
16206 GeneratedField::ValidationTask => {
16207 if event__.is_some() {
16208 return Err(serde::de::Error::duplicate_field("validationTask"));
16209 }
16210 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::ValidationTask)
16211;
16212 }
16213 GeneratedField::CancelCompactTask => {
16214 if event__.is_some() {
16215 return Err(serde::de::Error::duplicate_field("cancelCompactTask"));
16216 }
16217 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CancelCompactTask)
16218;
16219 }
16220 GeneratedField::PullTaskAck => {
16221 if event__.is_some() {
16222 return Err(serde::de::Error::duplicate_field("pullTaskAck"));
16223 }
16224 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::PullTaskAck)
16225;
16226 }
16227 }
16228 }
16229 Ok(SubscribeCompactionEventResponse {
16230 create_at: create_at__.unwrap_or_default(),
16231 event: event__,
16232 })
16233 }
16234 }
16235 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse", FIELDS, GeneratedVisitor)
16236 }
16237}
16238impl serde::Serialize for subscribe_compaction_event_response::PullTaskAck {
16239 #[allow(deprecated)]
16240 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16241 where
16242 S: serde::Serializer,
16243 {
16244 use serde::ser::SerializeStruct;
16245 let len = 0;
16246 let struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", len)?;
16247 struct_ser.end()
16248 }
16249}
16250impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_response::PullTaskAck {
16251 #[allow(deprecated)]
16252 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16253 where
16254 D: serde::Deserializer<'de>,
16255 {
16256 const FIELDS: &[&str] = &[
16257 ];
16258
16259 #[allow(clippy::enum_variant_names)]
16260 enum GeneratedField {
16261 }
16262 impl<'de> serde::Deserialize<'de> for GeneratedField {
16263 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16264 where
16265 D: serde::Deserializer<'de>,
16266 {
16267 struct GeneratedVisitor;
16268
16269 impl serde::de::Visitor<'_> for GeneratedVisitor {
16270 type Value = GeneratedField;
16271
16272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16273 write!(formatter, "expected one of: {:?}", &FIELDS)
16274 }
16275
16276 #[allow(unused_variables)]
16277 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16278 where
16279 E: serde::de::Error,
16280 {
16281 Err(serde::de::Error::unknown_field(value, FIELDS))
16282 }
16283 }
16284 deserializer.deserialize_identifier(GeneratedVisitor)
16285 }
16286 }
16287 struct GeneratedVisitor;
16288 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16289 type Value = subscribe_compaction_event_response::PullTaskAck;
16290
16291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16292 formatter.write_str("struct hummock.SubscribeCompactionEventResponse.PullTaskAck")
16293 }
16294
16295 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_response::PullTaskAck, V::Error>
16296 where
16297 V: serde::de::MapAccess<'de>,
16298 {
16299 while map_.next_key::<GeneratedField>()?.is_some() {
16300 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16301 }
16302 Ok(subscribe_compaction_event_response::PullTaskAck {
16303 })
16304 }
16305 }
16306 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", FIELDS, GeneratedVisitor)
16307 }
16308}
16309impl serde::Serialize for TableChangeLog {
16310 #[allow(deprecated)]
16311 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16312 where
16313 S: serde::Serializer,
16314 {
16315 use serde::ser::SerializeStruct;
16316 let mut len = 0;
16317 if !self.change_logs.is_empty() {
16318 len += 1;
16319 }
16320 let mut struct_ser = serializer.serialize_struct("hummock.TableChangeLog", len)?;
16321 if !self.change_logs.is_empty() {
16322 struct_ser.serialize_field("changeLogs", &self.change_logs)?;
16323 }
16324 struct_ser.end()
16325 }
16326}
16327impl<'de> serde::Deserialize<'de> for TableChangeLog {
16328 #[allow(deprecated)]
16329 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16330 where
16331 D: serde::Deserializer<'de>,
16332 {
16333 const FIELDS: &[&str] = &[
16334 "change_logs",
16335 "changeLogs",
16336 ];
16337
16338 #[allow(clippy::enum_variant_names)]
16339 enum GeneratedField {
16340 ChangeLogs,
16341 }
16342 impl<'de> serde::Deserialize<'de> for GeneratedField {
16343 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16344 where
16345 D: serde::Deserializer<'de>,
16346 {
16347 struct GeneratedVisitor;
16348
16349 impl serde::de::Visitor<'_> for GeneratedVisitor {
16350 type Value = GeneratedField;
16351
16352 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16353 write!(formatter, "expected one of: {:?}", &FIELDS)
16354 }
16355
16356 #[allow(unused_variables)]
16357 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16358 where
16359 E: serde::de::Error,
16360 {
16361 match value {
16362 "changeLogs" | "change_logs" => Ok(GeneratedField::ChangeLogs),
16363 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16364 }
16365 }
16366 }
16367 deserializer.deserialize_identifier(GeneratedVisitor)
16368 }
16369 }
16370 struct GeneratedVisitor;
16371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16372 type Value = TableChangeLog;
16373
16374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16375 formatter.write_str("struct hummock.TableChangeLog")
16376 }
16377
16378 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableChangeLog, V::Error>
16379 where
16380 V: serde::de::MapAccess<'de>,
16381 {
16382 let mut change_logs__ = None;
16383 while let Some(k) = map_.next_key()? {
16384 match k {
16385 GeneratedField::ChangeLogs => {
16386 if change_logs__.is_some() {
16387 return Err(serde::de::Error::duplicate_field("changeLogs"));
16388 }
16389 change_logs__ = Some(map_.next_value()?);
16390 }
16391 }
16392 }
16393 Ok(TableChangeLog {
16394 change_logs: change_logs__.unwrap_or_default(),
16395 })
16396 }
16397 }
16398 deserializer.deserialize_struct("hummock.TableChangeLog", FIELDS, GeneratedVisitor)
16399 }
16400}
16401impl serde::Serialize for TableOption {
16402 #[allow(deprecated)]
16403 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16404 where
16405 S: serde::Serializer,
16406 {
16407 use serde::ser::SerializeStruct;
16408 let mut len = 0;
16409 if self.retention_seconds.is_some() {
16410 len += 1;
16411 }
16412 let mut struct_ser = serializer.serialize_struct("hummock.TableOption", len)?;
16413 if let Some(v) = self.retention_seconds.as_ref() {
16414 struct_ser.serialize_field("retentionSeconds", v)?;
16415 }
16416 struct_ser.end()
16417 }
16418}
16419impl<'de> serde::Deserialize<'de> for TableOption {
16420 #[allow(deprecated)]
16421 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16422 where
16423 D: serde::Deserializer<'de>,
16424 {
16425 const FIELDS: &[&str] = &[
16426 "retention_seconds",
16427 "retentionSeconds",
16428 ];
16429
16430 #[allow(clippy::enum_variant_names)]
16431 enum GeneratedField {
16432 RetentionSeconds,
16433 }
16434 impl<'de> serde::Deserialize<'de> for GeneratedField {
16435 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16436 where
16437 D: serde::Deserializer<'de>,
16438 {
16439 struct GeneratedVisitor;
16440
16441 impl serde::de::Visitor<'_> for GeneratedVisitor {
16442 type Value = GeneratedField;
16443
16444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16445 write!(formatter, "expected one of: {:?}", &FIELDS)
16446 }
16447
16448 #[allow(unused_variables)]
16449 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16450 where
16451 E: serde::de::Error,
16452 {
16453 match value {
16454 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
16455 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16456 }
16457 }
16458 }
16459 deserializer.deserialize_identifier(GeneratedVisitor)
16460 }
16461 }
16462 struct GeneratedVisitor;
16463 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16464 type Value = TableOption;
16465
16466 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16467 formatter.write_str("struct hummock.TableOption")
16468 }
16469
16470 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableOption, V::Error>
16471 where
16472 V: serde::de::MapAccess<'de>,
16473 {
16474 let mut retention_seconds__ = None;
16475 while let Some(k) = map_.next_key()? {
16476 match k {
16477 GeneratedField::RetentionSeconds => {
16478 if retention_seconds__.is_some() {
16479 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
16480 }
16481 retention_seconds__ =
16482 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16483 ;
16484 }
16485 }
16486 }
16487 Ok(TableOption {
16488 retention_seconds: retention_seconds__,
16489 })
16490 }
16491 }
16492 deserializer.deserialize_struct("hummock.TableOption", FIELDS, GeneratedVisitor)
16493 }
16494}
16495impl serde::Serialize for TableSchema {
16496 #[allow(deprecated)]
16497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16498 where
16499 S: serde::Serializer,
16500 {
16501 use serde::ser::SerializeStruct;
16502 let mut len = 0;
16503 if !self.column_ids.is_empty() {
16504 len += 1;
16505 }
16506 let mut struct_ser = serializer.serialize_struct("hummock.TableSchema", len)?;
16507 if !self.column_ids.is_empty() {
16508 struct_ser.serialize_field("columnIds", &self.column_ids)?;
16509 }
16510 struct_ser.end()
16511 }
16512}
16513impl<'de> serde::Deserialize<'de> for TableSchema {
16514 #[allow(deprecated)]
16515 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16516 where
16517 D: serde::Deserializer<'de>,
16518 {
16519 const FIELDS: &[&str] = &[
16520 "column_ids",
16521 "columnIds",
16522 ];
16523
16524 #[allow(clippy::enum_variant_names)]
16525 enum GeneratedField {
16526 ColumnIds,
16527 }
16528 impl<'de> serde::Deserialize<'de> for GeneratedField {
16529 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16530 where
16531 D: serde::Deserializer<'de>,
16532 {
16533 struct GeneratedVisitor;
16534
16535 impl serde::de::Visitor<'_> for GeneratedVisitor {
16536 type Value = GeneratedField;
16537
16538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16539 write!(formatter, "expected one of: {:?}", &FIELDS)
16540 }
16541
16542 #[allow(unused_variables)]
16543 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16544 where
16545 E: serde::de::Error,
16546 {
16547 match value {
16548 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
16549 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16550 }
16551 }
16552 }
16553 deserializer.deserialize_identifier(GeneratedVisitor)
16554 }
16555 }
16556 struct GeneratedVisitor;
16557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16558 type Value = TableSchema;
16559
16560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16561 formatter.write_str("struct hummock.TableSchema")
16562 }
16563
16564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
16565 where
16566 V: serde::de::MapAccess<'de>,
16567 {
16568 let mut column_ids__ = None;
16569 while let Some(k) = map_.next_key()? {
16570 match k {
16571 GeneratedField::ColumnIds => {
16572 if column_ids__.is_some() {
16573 return Err(serde::de::Error::duplicate_field("columnIds"));
16574 }
16575 column_ids__ =
16576 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16577 .into_iter().map(|x| x.0).collect())
16578 ;
16579 }
16580 }
16581 }
16582 Ok(TableSchema {
16583 column_ids: column_ids__.unwrap_or_default(),
16584 })
16585 }
16586 }
16587 deserializer.deserialize_struct("hummock.TableSchema", FIELDS, GeneratedVisitor)
16588 }
16589}
16590impl serde::Serialize for TableStats {
16591 #[allow(deprecated)]
16592 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16593 where
16594 S: serde::Serializer,
16595 {
16596 use serde::ser::SerializeStruct;
16597 let mut len = 0;
16598 if self.total_key_size != 0 {
16599 len += 1;
16600 }
16601 if self.total_value_size != 0 {
16602 len += 1;
16603 }
16604 if self.total_key_count != 0 {
16605 len += 1;
16606 }
16607 if self.total_compressed_size != 0 {
16608 len += 1;
16609 }
16610 let mut struct_ser = serializer.serialize_struct("hummock.TableStats", len)?;
16611 if self.total_key_size != 0 {
16612 #[allow(clippy::needless_borrow)]
16613 #[allow(clippy::needless_borrows_for_generic_args)]
16614 struct_ser.serialize_field("totalKeySize", ToString::to_string(&self.total_key_size).as_str())?;
16615 }
16616 if self.total_value_size != 0 {
16617 #[allow(clippy::needless_borrow)]
16618 #[allow(clippy::needless_borrows_for_generic_args)]
16619 struct_ser.serialize_field("totalValueSize", ToString::to_string(&self.total_value_size).as_str())?;
16620 }
16621 if self.total_key_count != 0 {
16622 #[allow(clippy::needless_borrow)]
16623 #[allow(clippy::needless_borrows_for_generic_args)]
16624 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
16625 }
16626 if self.total_compressed_size != 0 {
16627 #[allow(clippy::needless_borrow)]
16628 #[allow(clippy::needless_borrows_for_generic_args)]
16629 struct_ser.serialize_field("totalCompressedSize", ToString::to_string(&self.total_compressed_size).as_str())?;
16630 }
16631 struct_ser.end()
16632 }
16633}
16634impl<'de> serde::Deserialize<'de> for TableStats {
16635 #[allow(deprecated)]
16636 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16637 where
16638 D: serde::Deserializer<'de>,
16639 {
16640 const FIELDS: &[&str] = &[
16641 "total_key_size",
16642 "totalKeySize",
16643 "total_value_size",
16644 "totalValueSize",
16645 "total_key_count",
16646 "totalKeyCount",
16647 "total_compressed_size",
16648 "totalCompressedSize",
16649 ];
16650
16651 #[allow(clippy::enum_variant_names)]
16652 enum GeneratedField {
16653 TotalKeySize,
16654 TotalValueSize,
16655 TotalKeyCount,
16656 TotalCompressedSize,
16657 }
16658 impl<'de> serde::Deserialize<'de> for GeneratedField {
16659 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16660 where
16661 D: serde::Deserializer<'de>,
16662 {
16663 struct GeneratedVisitor;
16664
16665 impl serde::de::Visitor<'_> for GeneratedVisitor {
16666 type Value = GeneratedField;
16667
16668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16669 write!(formatter, "expected one of: {:?}", &FIELDS)
16670 }
16671
16672 #[allow(unused_variables)]
16673 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16674 where
16675 E: serde::de::Error,
16676 {
16677 match value {
16678 "totalKeySize" | "total_key_size" => Ok(GeneratedField::TotalKeySize),
16679 "totalValueSize" | "total_value_size" => Ok(GeneratedField::TotalValueSize),
16680 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
16681 "totalCompressedSize" | "total_compressed_size" => Ok(GeneratedField::TotalCompressedSize),
16682 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16683 }
16684 }
16685 }
16686 deserializer.deserialize_identifier(GeneratedVisitor)
16687 }
16688 }
16689 struct GeneratedVisitor;
16690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16691 type Value = TableStats;
16692
16693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16694 formatter.write_str("struct hummock.TableStats")
16695 }
16696
16697 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableStats, V::Error>
16698 where
16699 V: serde::de::MapAccess<'de>,
16700 {
16701 let mut total_key_size__ = None;
16702 let mut total_value_size__ = None;
16703 let mut total_key_count__ = None;
16704 let mut total_compressed_size__ = None;
16705 while let Some(k) = map_.next_key()? {
16706 match k {
16707 GeneratedField::TotalKeySize => {
16708 if total_key_size__.is_some() {
16709 return Err(serde::de::Error::duplicate_field("totalKeySize"));
16710 }
16711 total_key_size__ =
16712 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16713 ;
16714 }
16715 GeneratedField::TotalValueSize => {
16716 if total_value_size__.is_some() {
16717 return Err(serde::de::Error::duplicate_field("totalValueSize"));
16718 }
16719 total_value_size__ =
16720 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16721 ;
16722 }
16723 GeneratedField::TotalKeyCount => {
16724 if total_key_count__.is_some() {
16725 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
16726 }
16727 total_key_count__ =
16728 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16729 ;
16730 }
16731 GeneratedField::TotalCompressedSize => {
16732 if total_compressed_size__.is_some() {
16733 return Err(serde::de::Error::duplicate_field("totalCompressedSize"));
16734 }
16735 total_compressed_size__ =
16736 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16737 ;
16738 }
16739 }
16740 }
16741 Ok(TableStats {
16742 total_key_size: total_key_size__.unwrap_or_default(),
16743 total_value_size: total_value_size__.unwrap_or_default(),
16744 total_key_count: total_key_count__.unwrap_or_default(),
16745 total_compressed_size: total_compressed_size__.unwrap_or_default(),
16746 })
16747 }
16748 }
16749 deserializer.deserialize_struct("hummock.TableStats", FIELDS, GeneratedVisitor)
16750 }
16751}
16752impl serde::Serialize for TableWatermarks {
16753 #[allow(deprecated)]
16754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16755 where
16756 S: serde::Serializer,
16757 {
16758 use serde::ser::SerializeStruct;
16759 let mut len = 0;
16760 if !self.epoch_watermarks.is_empty() {
16761 len += 1;
16762 }
16763 if self.is_ascending {
16764 len += 1;
16765 }
16766 if self.is_non_pk_prefix {
16767 len += 1;
16768 }
16769 if self.raw_watermark_serde_type != 0 {
16770 len += 1;
16771 }
16772 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks", len)?;
16773 if !self.epoch_watermarks.is_empty() {
16774 struct_ser.serialize_field("epochWatermarks", &self.epoch_watermarks)?;
16775 }
16776 if self.is_ascending {
16777 struct_ser.serialize_field("isAscending", &self.is_ascending)?;
16778 }
16779 if self.is_non_pk_prefix {
16780 struct_ser.serialize_field("isNonPkPrefix", &self.is_non_pk_prefix)?;
16781 }
16782 if self.raw_watermark_serde_type != 0 {
16783 let v = WatermarkSerdeType::try_from(self.raw_watermark_serde_type)
16784 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.raw_watermark_serde_type)))?;
16785 struct_ser.serialize_field("rawWatermarkSerdeType", &v)?;
16786 }
16787 struct_ser.end()
16788 }
16789}
16790impl<'de> serde::Deserialize<'de> for TableWatermarks {
16791 #[allow(deprecated)]
16792 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16793 where
16794 D: serde::Deserializer<'de>,
16795 {
16796 const FIELDS: &[&str] = &[
16797 "epoch_watermarks",
16798 "epochWatermarks",
16799 "is_ascending",
16800 "isAscending",
16801 "is_non_pk_prefix",
16802 "isNonPkPrefix",
16803 "raw_watermark_serde_type",
16804 "rawWatermarkSerdeType",
16805 ];
16806
16807 #[allow(clippy::enum_variant_names)]
16808 enum GeneratedField {
16809 EpochWatermarks,
16810 IsAscending,
16811 IsNonPkPrefix,
16812 RawWatermarkSerdeType,
16813 }
16814 impl<'de> serde::Deserialize<'de> for GeneratedField {
16815 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16816 where
16817 D: serde::Deserializer<'de>,
16818 {
16819 struct GeneratedVisitor;
16820
16821 impl serde::de::Visitor<'_> for GeneratedVisitor {
16822 type Value = GeneratedField;
16823
16824 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16825 write!(formatter, "expected one of: {:?}", &FIELDS)
16826 }
16827
16828 #[allow(unused_variables)]
16829 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16830 where
16831 E: serde::de::Error,
16832 {
16833 match value {
16834 "epochWatermarks" | "epoch_watermarks" => Ok(GeneratedField::EpochWatermarks),
16835 "isAscending" | "is_ascending" => Ok(GeneratedField::IsAscending),
16836 "isNonPkPrefix" | "is_non_pk_prefix" => Ok(GeneratedField::IsNonPkPrefix),
16837 "rawWatermarkSerdeType" | "raw_watermark_serde_type" => Ok(GeneratedField::RawWatermarkSerdeType),
16838 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16839 }
16840 }
16841 }
16842 deserializer.deserialize_identifier(GeneratedVisitor)
16843 }
16844 }
16845 struct GeneratedVisitor;
16846 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16847 type Value = TableWatermarks;
16848
16849 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16850 formatter.write_str("struct hummock.TableWatermarks")
16851 }
16852
16853 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableWatermarks, V::Error>
16854 where
16855 V: serde::de::MapAccess<'de>,
16856 {
16857 let mut epoch_watermarks__ = None;
16858 let mut is_ascending__ = None;
16859 let mut is_non_pk_prefix__ = None;
16860 let mut raw_watermark_serde_type__ = None;
16861 while let Some(k) = map_.next_key()? {
16862 match k {
16863 GeneratedField::EpochWatermarks => {
16864 if epoch_watermarks__.is_some() {
16865 return Err(serde::de::Error::duplicate_field("epochWatermarks"));
16866 }
16867 epoch_watermarks__ = Some(map_.next_value()?);
16868 }
16869 GeneratedField::IsAscending => {
16870 if is_ascending__.is_some() {
16871 return Err(serde::de::Error::duplicate_field("isAscending"));
16872 }
16873 is_ascending__ = Some(map_.next_value()?);
16874 }
16875 GeneratedField::IsNonPkPrefix => {
16876 if is_non_pk_prefix__.is_some() {
16877 return Err(serde::de::Error::duplicate_field("isNonPkPrefix"));
16878 }
16879 is_non_pk_prefix__ = Some(map_.next_value()?);
16880 }
16881 GeneratedField::RawWatermarkSerdeType => {
16882 if raw_watermark_serde_type__.is_some() {
16883 return Err(serde::de::Error::duplicate_field("rawWatermarkSerdeType"));
16884 }
16885 raw_watermark_serde_type__ = Some(map_.next_value::<WatermarkSerdeType>()? as i32);
16886 }
16887 }
16888 }
16889 Ok(TableWatermarks {
16890 epoch_watermarks: epoch_watermarks__.unwrap_or_default(),
16891 is_ascending: is_ascending__.unwrap_or_default(),
16892 is_non_pk_prefix: is_non_pk_prefix__.unwrap_or_default(),
16893 raw_watermark_serde_type: raw_watermark_serde_type__.unwrap_or_default(),
16894 })
16895 }
16896 }
16897 deserializer.deserialize_struct("hummock.TableWatermarks", FIELDS, GeneratedVisitor)
16898 }
16899}
16900impl serde::Serialize for table_watermarks::EpochNewWatermarks {
16901 #[allow(deprecated)]
16902 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16903 where
16904 S: serde::Serializer,
16905 {
16906 use serde::ser::SerializeStruct;
16907 let mut len = 0;
16908 if !self.watermarks.is_empty() {
16909 len += 1;
16910 }
16911 if self.epoch != 0 {
16912 len += 1;
16913 }
16914 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks.EpochNewWatermarks", len)?;
16915 if !self.watermarks.is_empty() {
16916 struct_ser.serialize_field("watermarks", &self.watermarks)?;
16917 }
16918 if self.epoch != 0 {
16919 #[allow(clippy::needless_borrow)]
16920 #[allow(clippy::needless_borrows_for_generic_args)]
16921 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
16922 }
16923 struct_ser.end()
16924 }
16925}
16926impl<'de> serde::Deserialize<'de> for table_watermarks::EpochNewWatermarks {
16927 #[allow(deprecated)]
16928 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16929 where
16930 D: serde::Deserializer<'de>,
16931 {
16932 const FIELDS: &[&str] = &[
16933 "watermarks",
16934 "epoch",
16935 ];
16936
16937 #[allow(clippy::enum_variant_names)]
16938 enum GeneratedField {
16939 Watermarks,
16940 Epoch,
16941 }
16942 impl<'de> serde::Deserialize<'de> for GeneratedField {
16943 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16944 where
16945 D: serde::Deserializer<'de>,
16946 {
16947 struct GeneratedVisitor;
16948
16949 impl serde::de::Visitor<'_> for GeneratedVisitor {
16950 type Value = GeneratedField;
16951
16952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16953 write!(formatter, "expected one of: {:?}", &FIELDS)
16954 }
16955
16956 #[allow(unused_variables)]
16957 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16958 where
16959 E: serde::de::Error,
16960 {
16961 match value {
16962 "watermarks" => Ok(GeneratedField::Watermarks),
16963 "epoch" => Ok(GeneratedField::Epoch),
16964 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16965 }
16966 }
16967 }
16968 deserializer.deserialize_identifier(GeneratedVisitor)
16969 }
16970 }
16971 struct GeneratedVisitor;
16972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16973 type Value = table_watermarks::EpochNewWatermarks;
16974
16975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16976 formatter.write_str("struct hummock.TableWatermarks.EpochNewWatermarks")
16977 }
16978
16979 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_watermarks::EpochNewWatermarks, V::Error>
16980 where
16981 V: serde::de::MapAccess<'de>,
16982 {
16983 let mut watermarks__ = None;
16984 let mut epoch__ = None;
16985 while let Some(k) = map_.next_key()? {
16986 match k {
16987 GeneratedField::Watermarks => {
16988 if watermarks__.is_some() {
16989 return Err(serde::de::Error::duplicate_field("watermarks"));
16990 }
16991 watermarks__ = Some(map_.next_value()?);
16992 }
16993 GeneratedField::Epoch => {
16994 if epoch__.is_some() {
16995 return Err(serde::de::Error::duplicate_field("epoch"));
16996 }
16997 epoch__ =
16998 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16999 ;
17000 }
17001 }
17002 }
17003 Ok(table_watermarks::EpochNewWatermarks {
17004 watermarks: watermarks__.unwrap_or_default(),
17005 epoch: epoch__.unwrap_or_default(),
17006 })
17007 }
17008 }
17009 deserializer.deserialize_struct("hummock.TableWatermarks.EpochNewWatermarks", FIELDS, GeneratedVisitor)
17010 }
17011}
17012impl serde::Serialize for TriggerCompactionDeterministicRequest {
17013 #[allow(deprecated)]
17014 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17015 where
17016 S: serde::Serializer,
17017 {
17018 use serde::ser::SerializeStruct;
17019 let mut len = 0;
17020 if self.version_id != 0 {
17021 len += 1;
17022 }
17023 if !self.compaction_groups.is_empty() {
17024 len += 1;
17025 }
17026 let mut struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicRequest", len)?;
17027 if self.version_id != 0 {
17028 #[allow(clippy::needless_borrow)]
17029 #[allow(clippy::needless_borrows_for_generic_args)]
17030 struct_ser.serialize_field("versionId", ToString::to_string(&self.version_id).as_str())?;
17031 }
17032 if !self.compaction_groups.is_empty() {
17033 struct_ser.serialize_field("compactionGroups", &self.compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
17034 }
17035 struct_ser.end()
17036 }
17037}
17038impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicRequest {
17039 #[allow(deprecated)]
17040 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17041 where
17042 D: serde::Deserializer<'de>,
17043 {
17044 const FIELDS: &[&str] = &[
17045 "version_id",
17046 "versionId",
17047 "compaction_groups",
17048 "compactionGroups",
17049 ];
17050
17051 #[allow(clippy::enum_variant_names)]
17052 enum GeneratedField {
17053 VersionId,
17054 CompactionGroups,
17055 }
17056 impl<'de> serde::Deserialize<'de> for GeneratedField {
17057 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17058 where
17059 D: serde::Deserializer<'de>,
17060 {
17061 struct GeneratedVisitor;
17062
17063 impl serde::de::Visitor<'_> for GeneratedVisitor {
17064 type Value = GeneratedField;
17065
17066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17067 write!(formatter, "expected one of: {:?}", &FIELDS)
17068 }
17069
17070 #[allow(unused_variables)]
17071 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17072 where
17073 E: serde::de::Error,
17074 {
17075 match value {
17076 "versionId" | "version_id" => Ok(GeneratedField::VersionId),
17077 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
17078 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17079 }
17080 }
17081 }
17082 deserializer.deserialize_identifier(GeneratedVisitor)
17083 }
17084 }
17085 struct GeneratedVisitor;
17086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17087 type Value = TriggerCompactionDeterministicRequest;
17088
17089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17090 formatter.write_str("struct hummock.TriggerCompactionDeterministicRequest")
17091 }
17092
17093 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicRequest, V::Error>
17094 where
17095 V: serde::de::MapAccess<'de>,
17096 {
17097 let mut version_id__ = None;
17098 let mut compaction_groups__ = None;
17099 while let Some(k) = map_.next_key()? {
17100 match k {
17101 GeneratedField::VersionId => {
17102 if version_id__.is_some() {
17103 return Err(serde::de::Error::duplicate_field("versionId"));
17104 }
17105 version_id__ =
17106 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17107 ;
17108 }
17109 GeneratedField::CompactionGroups => {
17110 if compaction_groups__.is_some() {
17111 return Err(serde::de::Error::duplicate_field("compactionGroups"));
17112 }
17113 compaction_groups__ =
17114 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17115 .into_iter().map(|x| x.0).collect())
17116 ;
17117 }
17118 }
17119 }
17120 Ok(TriggerCompactionDeterministicRequest {
17121 version_id: version_id__.unwrap_or_default(),
17122 compaction_groups: compaction_groups__.unwrap_or_default(),
17123 })
17124 }
17125 }
17126 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicRequest", FIELDS, GeneratedVisitor)
17127 }
17128}
17129impl serde::Serialize for TriggerCompactionDeterministicResponse {
17130 #[allow(deprecated)]
17131 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17132 where
17133 S: serde::Serializer,
17134 {
17135 use serde::ser::SerializeStruct;
17136 let len = 0;
17137 let struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicResponse", len)?;
17138 struct_ser.end()
17139 }
17140}
17141impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicResponse {
17142 #[allow(deprecated)]
17143 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17144 where
17145 D: serde::Deserializer<'de>,
17146 {
17147 const FIELDS: &[&str] = &[
17148 ];
17149
17150 #[allow(clippy::enum_variant_names)]
17151 enum GeneratedField {
17152 }
17153 impl<'de> serde::Deserialize<'de> for GeneratedField {
17154 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17155 where
17156 D: serde::Deserializer<'de>,
17157 {
17158 struct GeneratedVisitor;
17159
17160 impl serde::de::Visitor<'_> for GeneratedVisitor {
17161 type Value = GeneratedField;
17162
17163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17164 write!(formatter, "expected one of: {:?}", &FIELDS)
17165 }
17166
17167 #[allow(unused_variables)]
17168 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17169 where
17170 E: serde::de::Error,
17171 {
17172 Err(serde::de::Error::unknown_field(value, FIELDS))
17173 }
17174 }
17175 deserializer.deserialize_identifier(GeneratedVisitor)
17176 }
17177 }
17178 struct GeneratedVisitor;
17179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17180 type Value = TriggerCompactionDeterministicResponse;
17181
17182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17183 formatter.write_str("struct hummock.TriggerCompactionDeterministicResponse")
17184 }
17185
17186 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicResponse, V::Error>
17187 where
17188 V: serde::de::MapAccess<'de>,
17189 {
17190 while map_.next_key::<GeneratedField>()?.is_some() {
17191 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17192 }
17193 Ok(TriggerCompactionDeterministicResponse {
17194 })
17195 }
17196 }
17197 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicResponse", FIELDS, GeneratedVisitor)
17198 }
17199}
17200impl serde::Serialize for TriggerFullGcRequest {
17201 #[allow(deprecated)]
17202 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17203 where
17204 S: serde::Serializer,
17205 {
17206 use serde::ser::SerializeStruct;
17207 let mut len = 0;
17208 if self.sst_retention_time_sec != 0 {
17209 len += 1;
17210 }
17211 if self.prefix.is_some() {
17212 len += 1;
17213 }
17214 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCRequest", len)?;
17215 if self.sst_retention_time_sec != 0 {
17216 #[allow(clippy::needless_borrow)]
17217 #[allow(clippy::needless_borrows_for_generic_args)]
17218 struct_ser.serialize_field("sstRetentionTimeSec", ToString::to_string(&self.sst_retention_time_sec).as_str())?;
17219 }
17220 if let Some(v) = self.prefix.as_ref() {
17221 struct_ser.serialize_field("prefix", v)?;
17222 }
17223 struct_ser.end()
17224 }
17225}
17226impl<'de> serde::Deserialize<'de> for TriggerFullGcRequest {
17227 #[allow(deprecated)]
17228 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17229 where
17230 D: serde::Deserializer<'de>,
17231 {
17232 const FIELDS: &[&str] = &[
17233 "sst_retention_time_sec",
17234 "sstRetentionTimeSec",
17235 "prefix",
17236 ];
17237
17238 #[allow(clippy::enum_variant_names)]
17239 enum GeneratedField {
17240 SstRetentionTimeSec,
17241 Prefix,
17242 }
17243 impl<'de> serde::Deserialize<'de> for GeneratedField {
17244 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17245 where
17246 D: serde::Deserializer<'de>,
17247 {
17248 struct GeneratedVisitor;
17249
17250 impl serde::de::Visitor<'_> for GeneratedVisitor {
17251 type Value = GeneratedField;
17252
17253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17254 write!(formatter, "expected one of: {:?}", &FIELDS)
17255 }
17256
17257 #[allow(unused_variables)]
17258 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17259 where
17260 E: serde::de::Error,
17261 {
17262 match value {
17263 "sstRetentionTimeSec" | "sst_retention_time_sec" => Ok(GeneratedField::SstRetentionTimeSec),
17264 "prefix" => Ok(GeneratedField::Prefix),
17265 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17266 }
17267 }
17268 }
17269 deserializer.deserialize_identifier(GeneratedVisitor)
17270 }
17271 }
17272 struct GeneratedVisitor;
17273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17274 type Value = TriggerFullGcRequest;
17275
17276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17277 formatter.write_str("struct hummock.TriggerFullGCRequest")
17278 }
17279
17280 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcRequest, V::Error>
17281 where
17282 V: serde::de::MapAccess<'de>,
17283 {
17284 let mut sst_retention_time_sec__ = None;
17285 let mut prefix__ = None;
17286 while let Some(k) = map_.next_key()? {
17287 match k {
17288 GeneratedField::SstRetentionTimeSec => {
17289 if sst_retention_time_sec__.is_some() {
17290 return Err(serde::de::Error::duplicate_field("sstRetentionTimeSec"));
17291 }
17292 sst_retention_time_sec__ =
17293 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17294 ;
17295 }
17296 GeneratedField::Prefix => {
17297 if prefix__.is_some() {
17298 return Err(serde::de::Error::duplicate_field("prefix"));
17299 }
17300 prefix__ = map_.next_value()?;
17301 }
17302 }
17303 }
17304 Ok(TriggerFullGcRequest {
17305 sst_retention_time_sec: sst_retention_time_sec__.unwrap_or_default(),
17306 prefix: prefix__,
17307 })
17308 }
17309 }
17310 deserializer.deserialize_struct("hummock.TriggerFullGCRequest", FIELDS, GeneratedVisitor)
17311 }
17312}
17313impl serde::Serialize for TriggerFullGcResponse {
17314 #[allow(deprecated)]
17315 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17316 where
17317 S: serde::Serializer,
17318 {
17319 use serde::ser::SerializeStruct;
17320 let mut len = 0;
17321 if self.status.is_some() {
17322 len += 1;
17323 }
17324 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCResponse", len)?;
17325 if let Some(v) = self.status.as_ref() {
17326 struct_ser.serialize_field("status", v)?;
17327 }
17328 struct_ser.end()
17329 }
17330}
17331impl<'de> serde::Deserialize<'de> for TriggerFullGcResponse {
17332 #[allow(deprecated)]
17333 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17334 where
17335 D: serde::Deserializer<'de>,
17336 {
17337 const FIELDS: &[&str] = &[
17338 "status",
17339 ];
17340
17341 #[allow(clippy::enum_variant_names)]
17342 enum GeneratedField {
17343 Status,
17344 }
17345 impl<'de> serde::Deserialize<'de> for GeneratedField {
17346 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17347 where
17348 D: serde::Deserializer<'de>,
17349 {
17350 struct GeneratedVisitor;
17351
17352 impl serde::de::Visitor<'_> for GeneratedVisitor {
17353 type Value = GeneratedField;
17354
17355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17356 write!(formatter, "expected one of: {:?}", &FIELDS)
17357 }
17358
17359 #[allow(unused_variables)]
17360 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17361 where
17362 E: serde::de::Error,
17363 {
17364 match value {
17365 "status" => Ok(GeneratedField::Status),
17366 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17367 }
17368 }
17369 }
17370 deserializer.deserialize_identifier(GeneratedVisitor)
17371 }
17372 }
17373 struct GeneratedVisitor;
17374 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17375 type Value = TriggerFullGcResponse;
17376
17377 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17378 formatter.write_str("struct hummock.TriggerFullGCResponse")
17379 }
17380
17381 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcResponse, V::Error>
17382 where
17383 V: serde::de::MapAccess<'de>,
17384 {
17385 let mut status__ = None;
17386 while let Some(k) = map_.next_key()? {
17387 match k {
17388 GeneratedField::Status => {
17389 if status__.is_some() {
17390 return Err(serde::de::Error::duplicate_field("status"));
17391 }
17392 status__ = map_.next_value()?;
17393 }
17394 }
17395 }
17396 Ok(TriggerFullGcResponse {
17397 status: status__,
17398 })
17399 }
17400 }
17401 deserializer.deserialize_struct("hummock.TriggerFullGCResponse", FIELDS, GeneratedVisitor)
17402 }
17403}
17404impl serde::Serialize for TriggerManualCompactionRequest {
17405 #[allow(deprecated)]
17406 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17407 where
17408 S: serde::Serializer,
17409 {
17410 use serde::ser::SerializeStruct;
17411 let mut len = 0;
17412 if self.compaction_group_id != 0 {
17413 len += 1;
17414 }
17415 if self.key_range.is_some() {
17416 len += 1;
17417 }
17418 if self.table_id != 0 {
17419 len += 1;
17420 }
17421 if self.level != 0 {
17422 len += 1;
17423 }
17424 if !self.sst_ids.is_empty() {
17425 len += 1;
17426 }
17427 if self.exclusive.is_some() {
17428 len += 1;
17429 }
17430 if self.target_level.is_some() {
17431 len += 1;
17432 }
17433 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionRequest", len)?;
17434 if self.compaction_group_id != 0 {
17435 #[allow(clippy::needless_borrow)]
17436 #[allow(clippy::needless_borrows_for_generic_args)]
17437 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
17438 }
17439 if let Some(v) = self.key_range.as_ref() {
17440 struct_ser.serialize_field("keyRange", v)?;
17441 }
17442 if self.table_id != 0 {
17443 struct_ser.serialize_field("tableId", &self.table_id)?;
17444 }
17445 if self.level != 0 {
17446 struct_ser.serialize_field("level", &self.level)?;
17447 }
17448 if !self.sst_ids.is_empty() {
17449 struct_ser.serialize_field("sstIds", &self.sst_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
17450 }
17451 if let Some(v) = self.exclusive.as_ref() {
17452 struct_ser.serialize_field("exclusive", v)?;
17453 }
17454 if let Some(v) = self.target_level.as_ref() {
17455 struct_ser.serialize_field("targetLevel", v)?;
17456 }
17457 struct_ser.end()
17458 }
17459}
17460impl<'de> serde::Deserialize<'de> for TriggerManualCompactionRequest {
17461 #[allow(deprecated)]
17462 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17463 where
17464 D: serde::Deserializer<'de>,
17465 {
17466 const FIELDS: &[&str] = &[
17467 "compaction_group_id",
17468 "compactionGroupId",
17469 "key_range",
17470 "keyRange",
17471 "table_id",
17472 "tableId",
17473 "level",
17474 "sst_ids",
17475 "sstIds",
17476 "exclusive",
17477 "target_level",
17478 "targetLevel",
17479 ];
17480
17481 #[allow(clippy::enum_variant_names)]
17482 enum GeneratedField {
17483 CompactionGroupId,
17484 KeyRange,
17485 TableId,
17486 Level,
17487 SstIds,
17488 Exclusive,
17489 TargetLevel,
17490 }
17491 impl<'de> serde::Deserialize<'de> for GeneratedField {
17492 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17493 where
17494 D: serde::Deserializer<'de>,
17495 {
17496 struct GeneratedVisitor;
17497
17498 impl serde::de::Visitor<'_> for GeneratedVisitor {
17499 type Value = GeneratedField;
17500
17501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17502 write!(formatter, "expected one of: {:?}", &FIELDS)
17503 }
17504
17505 #[allow(unused_variables)]
17506 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17507 where
17508 E: serde::de::Error,
17509 {
17510 match value {
17511 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
17512 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
17513 "tableId" | "table_id" => Ok(GeneratedField::TableId),
17514 "level" => Ok(GeneratedField::Level),
17515 "sstIds" | "sst_ids" => Ok(GeneratedField::SstIds),
17516 "exclusive" => Ok(GeneratedField::Exclusive),
17517 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
17518 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17519 }
17520 }
17521 }
17522 deserializer.deserialize_identifier(GeneratedVisitor)
17523 }
17524 }
17525 struct GeneratedVisitor;
17526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17527 type Value = TriggerManualCompactionRequest;
17528
17529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17530 formatter.write_str("struct hummock.TriggerManualCompactionRequest")
17531 }
17532
17533 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionRequest, V::Error>
17534 where
17535 V: serde::de::MapAccess<'de>,
17536 {
17537 let mut compaction_group_id__ = None;
17538 let mut key_range__ = None;
17539 let mut table_id__ = None;
17540 let mut level__ = None;
17541 let mut sst_ids__ = None;
17542 let mut exclusive__ = None;
17543 let mut target_level__ = None;
17544 while let Some(k) = map_.next_key()? {
17545 match k {
17546 GeneratedField::CompactionGroupId => {
17547 if compaction_group_id__.is_some() {
17548 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
17549 }
17550 compaction_group_id__ =
17551 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17552 ;
17553 }
17554 GeneratedField::KeyRange => {
17555 if key_range__.is_some() {
17556 return Err(serde::de::Error::duplicate_field("keyRange"));
17557 }
17558 key_range__ = map_.next_value()?;
17559 }
17560 GeneratedField::TableId => {
17561 if table_id__.is_some() {
17562 return Err(serde::de::Error::duplicate_field("tableId"));
17563 }
17564 table_id__ =
17565 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17566 ;
17567 }
17568 GeneratedField::Level => {
17569 if level__.is_some() {
17570 return Err(serde::de::Error::duplicate_field("level"));
17571 }
17572 level__ =
17573 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17574 ;
17575 }
17576 GeneratedField::SstIds => {
17577 if sst_ids__.is_some() {
17578 return Err(serde::de::Error::duplicate_field("sstIds"));
17579 }
17580 sst_ids__ =
17581 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17582 .into_iter().map(|x| x.0).collect())
17583 ;
17584 }
17585 GeneratedField::Exclusive => {
17586 if exclusive__.is_some() {
17587 return Err(serde::de::Error::duplicate_field("exclusive"));
17588 }
17589 exclusive__ = map_.next_value()?;
17590 }
17591 GeneratedField::TargetLevel => {
17592 if target_level__.is_some() {
17593 return Err(serde::de::Error::duplicate_field("targetLevel"));
17594 }
17595 target_level__ =
17596 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17597 ;
17598 }
17599 }
17600 }
17601 Ok(TriggerManualCompactionRequest {
17602 compaction_group_id: compaction_group_id__.unwrap_or_default(),
17603 key_range: key_range__,
17604 table_id: table_id__.unwrap_or_default(),
17605 level: level__.unwrap_or_default(),
17606 sst_ids: sst_ids__.unwrap_or_default(),
17607 exclusive: exclusive__,
17608 target_level: target_level__,
17609 })
17610 }
17611 }
17612 deserializer.deserialize_struct("hummock.TriggerManualCompactionRequest", FIELDS, GeneratedVisitor)
17613 }
17614}
17615impl serde::Serialize for TriggerManualCompactionResponse {
17616 #[allow(deprecated)]
17617 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17618 where
17619 S: serde::Serializer,
17620 {
17621 use serde::ser::SerializeStruct;
17622 let mut len = 0;
17623 if self.status.is_some() {
17624 len += 1;
17625 }
17626 if self.should_retry.is_some() {
17627 len += 1;
17628 }
17629 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionResponse", len)?;
17630 if let Some(v) = self.status.as_ref() {
17631 struct_ser.serialize_field("status", v)?;
17632 }
17633 if let Some(v) = self.should_retry.as_ref() {
17634 struct_ser.serialize_field("shouldRetry", v)?;
17635 }
17636 struct_ser.end()
17637 }
17638}
17639impl<'de> serde::Deserialize<'de> for TriggerManualCompactionResponse {
17640 #[allow(deprecated)]
17641 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17642 where
17643 D: serde::Deserializer<'de>,
17644 {
17645 const FIELDS: &[&str] = &[
17646 "status",
17647 "should_retry",
17648 "shouldRetry",
17649 ];
17650
17651 #[allow(clippy::enum_variant_names)]
17652 enum GeneratedField {
17653 Status,
17654 ShouldRetry,
17655 }
17656 impl<'de> serde::Deserialize<'de> for GeneratedField {
17657 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17658 where
17659 D: serde::Deserializer<'de>,
17660 {
17661 struct GeneratedVisitor;
17662
17663 impl serde::de::Visitor<'_> for GeneratedVisitor {
17664 type Value = GeneratedField;
17665
17666 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17667 write!(formatter, "expected one of: {:?}", &FIELDS)
17668 }
17669
17670 #[allow(unused_variables)]
17671 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17672 where
17673 E: serde::de::Error,
17674 {
17675 match value {
17676 "status" => Ok(GeneratedField::Status),
17677 "shouldRetry" | "should_retry" => Ok(GeneratedField::ShouldRetry),
17678 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17679 }
17680 }
17681 }
17682 deserializer.deserialize_identifier(GeneratedVisitor)
17683 }
17684 }
17685 struct GeneratedVisitor;
17686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17687 type Value = TriggerManualCompactionResponse;
17688
17689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17690 formatter.write_str("struct hummock.TriggerManualCompactionResponse")
17691 }
17692
17693 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionResponse, V::Error>
17694 where
17695 V: serde::de::MapAccess<'de>,
17696 {
17697 let mut status__ = None;
17698 let mut should_retry__ = None;
17699 while let Some(k) = map_.next_key()? {
17700 match k {
17701 GeneratedField::Status => {
17702 if status__.is_some() {
17703 return Err(serde::de::Error::duplicate_field("status"));
17704 }
17705 status__ = map_.next_value()?;
17706 }
17707 GeneratedField::ShouldRetry => {
17708 if should_retry__.is_some() {
17709 return Err(serde::de::Error::duplicate_field("shouldRetry"));
17710 }
17711 should_retry__ = map_.next_value()?;
17712 }
17713 }
17714 }
17715 Ok(TriggerManualCompactionResponse {
17716 status: status__,
17717 should_retry: should_retry__,
17718 })
17719 }
17720 }
17721 deserializer.deserialize_struct("hummock.TriggerManualCompactionResponse", FIELDS, GeneratedVisitor)
17722 }
17723}
17724impl serde::Serialize for TruncateTables {
17725 #[allow(deprecated)]
17726 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17727 where
17728 S: serde::Serializer,
17729 {
17730 use serde::ser::SerializeStruct;
17731 let mut len = 0;
17732 if !self.table_ids.is_empty() {
17733 len += 1;
17734 }
17735 let mut struct_ser = serializer.serialize_struct("hummock.TruncateTables", len)?;
17736 if !self.table_ids.is_empty() {
17737 struct_ser.serialize_field("tableIds", &self.table_ids)?;
17738 }
17739 struct_ser.end()
17740 }
17741}
17742impl<'de> serde::Deserialize<'de> for TruncateTables {
17743 #[allow(deprecated)]
17744 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17745 where
17746 D: serde::Deserializer<'de>,
17747 {
17748 const FIELDS: &[&str] = &[
17749 "table_ids",
17750 "tableIds",
17751 ];
17752
17753 #[allow(clippy::enum_variant_names)]
17754 enum GeneratedField {
17755 TableIds,
17756 }
17757 impl<'de> serde::Deserialize<'de> for GeneratedField {
17758 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17759 where
17760 D: serde::Deserializer<'de>,
17761 {
17762 struct GeneratedVisitor;
17763
17764 impl serde::de::Visitor<'_> for GeneratedVisitor {
17765 type Value = GeneratedField;
17766
17767 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17768 write!(formatter, "expected one of: {:?}", &FIELDS)
17769 }
17770
17771 #[allow(unused_variables)]
17772 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17773 where
17774 E: serde::de::Error,
17775 {
17776 match value {
17777 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
17778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17779 }
17780 }
17781 }
17782 deserializer.deserialize_identifier(GeneratedVisitor)
17783 }
17784 }
17785 struct GeneratedVisitor;
17786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17787 type Value = TruncateTables;
17788
17789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17790 formatter.write_str("struct hummock.TruncateTables")
17791 }
17792
17793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TruncateTables, V::Error>
17794 where
17795 V: serde::de::MapAccess<'de>,
17796 {
17797 let mut table_ids__ = None;
17798 while let Some(k) = map_.next_key()? {
17799 match k {
17800 GeneratedField::TableIds => {
17801 if table_ids__.is_some() {
17802 return Err(serde::de::Error::duplicate_field("tableIds"));
17803 }
17804 table_ids__ =
17805 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17806 .into_iter().map(|x| x.0).collect())
17807 ;
17808 }
17809 }
17810 }
17811 Ok(TruncateTables {
17812 table_ids: table_ids__.unwrap_or_default(),
17813 })
17814 }
17815 }
17816 deserializer.deserialize_struct("hummock.TruncateTables", FIELDS, GeneratedVisitor)
17817 }
17818}
17819impl serde::Serialize for UnpinVersionBeforeRequest {
17820 #[allow(deprecated)]
17821 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17822 where
17823 S: serde::Serializer,
17824 {
17825 use serde::ser::SerializeStruct;
17826 let mut len = 0;
17827 if self.context_id != 0 {
17828 len += 1;
17829 }
17830 if self.unpin_version_before != 0 {
17831 len += 1;
17832 }
17833 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeRequest", len)?;
17834 if self.context_id != 0 {
17835 struct_ser.serialize_field("contextId", &self.context_id)?;
17836 }
17837 if self.unpin_version_before != 0 {
17838 #[allow(clippy::needless_borrow)]
17839 #[allow(clippy::needless_borrows_for_generic_args)]
17840 struct_ser.serialize_field("unpinVersionBefore", ToString::to_string(&self.unpin_version_before).as_str())?;
17841 }
17842 struct_ser.end()
17843 }
17844}
17845impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeRequest {
17846 #[allow(deprecated)]
17847 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17848 where
17849 D: serde::Deserializer<'de>,
17850 {
17851 const FIELDS: &[&str] = &[
17852 "context_id",
17853 "contextId",
17854 "unpin_version_before",
17855 "unpinVersionBefore",
17856 ];
17857
17858 #[allow(clippy::enum_variant_names)]
17859 enum GeneratedField {
17860 ContextId,
17861 UnpinVersionBefore,
17862 }
17863 impl<'de> serde::Deserialize<'de> for GeneratedField {
17864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17865 where
17866 D: serde::Deserializer<'de>,
17867 {
17868 struct GeneratedVisitor;
17869
17870 impl serde::de::Visitor<'_> for GeneratedVisitor {
17871 type Value = GeneratedField;
17872
17873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17874 write!(formatter, "expected one of: {:?}", &FIELDS)
17875 }
17876
17877 #[allow(unused_variables)]
17878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17879 where
17880 E: serde::de::Error,
17881 {
17882 match value {
17883 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
17884 "unpinVersionBefore" | "unpin_version_before" => Ok(GeneratedField::UnpinVersionBefore),
17885 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17886 }
17887 }
17888 }
17889 deserializer.deserialize_identifier(GeneratedVisitor)
17890 }
17891 }
17892 struct GeneratedVisitor;
17893 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17894 type Value = UnpinVersionBeforeRequest;
17895
17896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17897 formatter.write_str("struct hummock.UnpinVersionBeforeRequest")
17898 }
17899
17900 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeRequest, V::Error>
17901 where
17902 V: serde::de::MapAccess<'de>,
17903 {
17904 let mut context_id__ = None;
17905 let mut unpin_version_before__ = None;
17906 while let Some(k) = map_.next_key()? {
17907 match k {
17908 GeneratedField::ContextId => {
17909 if context_id__.is_some() {
17910 return Err(serde::de::Error::duplicate_field("contextId"));
17911 }
17912 context_id__ =
17913 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17914 ;
17915 }
17916 GeneratedField::UnpinVersionBefore => {
17917 if unpin_version_before__.is_some() {
17918 return Err(serde::de::Error::duplicate_field("unpinVersionBefore"));
17919 }
17920 unpin_version_before__ =
17921 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17922 ;
17923 }
17924 }
17925 }
17926 Ok(UnpinVersionBeforeRequest {
17927 context_id: context_id__.unwrap_or_default(),
17928 unpin_version_before: unpin_version_before__.unwrap_or_default(),
17929 })
17930 }
17931 }
17932 deserializer.deserialize_struct("hummock.UnpinVersionBeforeRequest", FIELDS, GeneratedVisitor)
17933 }
17934}
17935impl serde::Serialize for UnpinVersionBeforeResponse {
17936 #[allow(deprecated)]
17937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17938 where
17939 S: serde::Serializer,
17940 {
17941 use serde::ser::SerializeStruct;
17942 let mut len = 0;
17943 if self.status.is_some() {
17944 len += 1;
17945 }
17946 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeResponse", len)?;
17947 if let Some(v) = self.status.as_ref() {
17948 struct_ser.serialize_field("status", v)?;
17949 }
17950 struct_ser.end()
17951 }
17952}
17953impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeResponse {
17954 #[allow(deprecated)]
17955 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17956 where
17957 D: serde::Deserializer<'de>,
17958 {
17959 const FIELDS: &[&str] = &[
17960 "status",
17961 ];
17962
17963 #[allow(clippy::enum_variant_names)]
17964 enum GeneratedField {
17965 Status,
17966 }
17967 impl<'de> serde::Deserialize<'de> for GeneratedField {
17968 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17969 where
17970 D: serde::Deserializer<'de>,
17971 {
17972 struct GeneratedVisitor;
17973
17974 impl serde::de::Visitor<'_> for GeneratedVisitor {
17975 type Value = GeneratedField;
17976
17977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17978 write!(formatter, "expected one of: {:?}", &FIELDS)
17979 }
17980
17981 #[allow(unused_variables)]
17982 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17983 where
17984 E: serde::de::Error,
17985 {
17986 match value {
17987 "status" => Ok(GeneratedField::Status),
17988 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17989 }
17990 }
17991 }
17992 deserializer.deserialize_identifier(GeneratedVisitor)
17993 }
17994 }
17995 struct GeneratedVisitor;
17996 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17997 type Value = UnpinVersionBeforeResponse;
17998
17999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18000 formatter.write_str("struct hummock.UnpinVersionBeforeResponse")
18001 }
18002
18003 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeResponse, V::Error>
18004 where
18005 V: serde::de::MapAccess<'de>,
18006 {
18007 let mut status__ = None;
18008 while let Some(k) = map_.next_key()? {
18009 match k {
18010 GeneratedField::Status => {
18011 if status__.is_some() {
18012 return Err(serde::de::Error::duplicate_field("status"));
18013 }
18014 status__ = map_.next_value()?;
18015 }
18016 }
18017 }
18018 Ok(UnpinVersionBeforeResponse {
18019 status: status__,
18020 })
18021 }
18022 }
18023 deserializer.deserialize_struct("hummock.UnpinVersionBeforeResponse", FIELDS, GeneratedVisitor)
18024 }
18025}
18026impl serde::Serialize for UnpinVersionRequest {
18027 #[allow(deprecated)]
18028 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18029 where
18030 S: serde::Serializer,
18031 {
18032 use serde::ser::SerializeStruct;
18033 let mut len = 0;
18034 if self.context_id != 0 {
18035 len += 1;
18036 }
18037 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionRequest", len)?;
18038 if self.context_id != 0 {
18039 struct_ser.serialize_field("contextId", &self.context_id)?;
18040 }
18041 struct_ser.end()
18042 }
18043}
18044impl<'de> serde::Deserialize<'de> for UnpinVersionRequest {
18045 #[allow(deprecated)]
18046 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18047 where
18048 D: serde::Deserializer<'de>,
18049 {
18050 const FIELDS: &[&str] = &[
18051 "context_id",
18052 "contextId",
18053 ];
18054
18055 #[allow(clippy::enum_variant_names)]
18056 enum GeneratedField {
18057 ContextId,
18058 }
18059 impl<'de> serde::Deserialize<'de> for GeneratedField {
18060 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18061 where
18062 D: serde::Deserializer<'de>,
18063 {
18064 struct GeneratedVisitor;
18065
18066 impl serde::de::Visitor<'_> for GeneratedVisitor {
18067 type Value = GeneratedField;
18068
18069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18070 write!(formatter, "expected one of: {:?}", &FIELDS)
18071 }
18072
18073 #[allow(unused_variables)]
18074 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18075 where
18076 E: serde::de::Error,
18077 {
18078 match value {
18079 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
18080 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18081 }
18082 }
18083 }
18084 deserializer.deserialize_identifier(GeneratedVisitor)
18085 }
18086 }
18087 struct GeneratedVisitor;
18088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18089 type Value = UnpinVersionRequest;
18090
18091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18092 formatter.write_str("struct hummock.UnpinVersionRequest")
18093 }
18094
18095 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionRequest, V::Error>
18096 where
18097 V: serde::de::MapAccess<'de>,
18098 {
18099 let mut context_id__ = None;
18100 while let Some(k) = map_.next_key()? {
18101 match k {
18102 GeneratedField::ContextId => {
18103 if context_id__.is_some() {
18104 return Err(serde::de::Error::duplicate_field("contextId"));
18105 }
18106 context_id__ =
18107 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18108 ;
18109 }
18110 }
18111 }
18112 Ok(UnpinVersionRequest {
18113 context_id: context_id__.unwrap_or_default(),
18114 })
18115 }
18116 }
18117 deserializer.deserialize_struct("hummock.UnpinVersionRequest", FIELDS, GeneratedVisitor)
18118 }
18119}
18120impl serde::Serialize for UnpinVersionResponse {
18121 #[allow(deprecated)]
18122 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18123 where
18124 S: serde::Serializer,
18125 {
18126 use serde::ser::SerializeStruct;
18127 let mut len = 0;
18128 if self.status.is_some() {
18129 len += 1;
18130 }
18131 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionResponse", len)?;
18132 if let Some(v) = self.status.as_ref() {
18133 struct_ser.serialize_field("status", v)?;
18134 }
18135 struct_ser.end()
18136 }
18137}
18138impl<'de> serde::Deserialize<'de> for UnpinVersionResponse {
18139 #[allow(deprecated)]
18140 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18141 where
18142 D: serde::Deserializer<'de>,
18143 {
18144 const FIELDS: &[&str] = &[
18145 "status",
18146 ];
18147
18148 #[allow(clippy::enum_variant_names)]
18149 enum GeneratedField {
18150 Status,
18151 }
18152 impl<'de> serde::Deserialize<'de> for GeneratedField {
18153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18154 where
18155 D: serde::Deserializer<'de>,
18156 {
18157 struct GeneratedVisitor;
18158
18159 impl serde::de::Visitor<'_> for GeneratedVisitor {
18160 type Value = GeneratedField;
18161
18162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18163 write!(formatter, "expected one of: {:?}", &FIELDS)
18164 }
18165
18166 #[allow(unused_variables)]
18167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18168 where
18169 E: serde::de::Error,
18170 {
18171 match value {
18172 "status" => Ok(GeneratedField::Status),
18173 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18174 }
18175 }
18176 }
18177 deserializer.deserialize_identifier(GeneratedVisitor)
18178 }
18179 }
18180 struct GeneratedVisitor;
18181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18182 type Value = UnpinVersionResponse;
18183
18184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18185 formatter.write_str("struct hummock.UnpinVersionResponse")
18186 }
18187
18188 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionResponse, V::Error>
18189 where
18190 V: serde::de::MapAccess<'de>,
18191 {
18192 let mut status__ = None;
18193 while let Some(k) = map_.next_key()? {
18194 match k {
18195 GeneratedField::Status => {
18196 if status__.is_some() {
18197 return Err(serde::de::Error::duplicate_field("status"));
18198 }
18199 status__ = map_.next_value()?;
18200 }
18201 }
18202 }
18203 Ok(UnpinVersionResponse {
18204 status: status__,
18205 })
18206 }
18207 }
18208 deserializer.deserialize_struct("hummock.UnpinVersionResponse", FIELDS, GeneratedVisitor)
18209 }
18210}
18211impl serde::Serialize for VacuumTask {
18212 #[allow(deprecated)]
18213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18214 where
18215 S: serde::Serializer,
18216 {
18217 use serde::ser::SerializeStruct;
18218 let mut len = 0;
18219 if !self.sstable_object_ids.is_empty() {
18220 len += 1;
18221 }
18222 let mut struct_ser = serializer.serialize_struct("hummock.VacuumTask", len)?;
18223 if !self.sstable_object_ids.is_empty() {
18224 struct_ser.serialize_field("sstableObjectIds", &self.sstable_object_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
18225 }
18226 struct_ser.end()
18227 }
18228}
18229impl<'de> serde::Deserialize<'de> for VacuumTask {
18230 #[allow(deprecated)]
18231 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18232 where
18233 D: serde::Deserializer<'de>,
18234 {
18235 const FIELDS: &[&str] = &[
18236 "sstable_object_ids",
18237 "sstableObjectIds",
18238 ];
18239
18240 #[allow(clippy::enum_variant_names)]
18241 enum GeneratedField {
18242 SstableObjectIds,
18243 }
18244 impl<'de> serde::Deserialize<'de> for GeneratedField {
18245 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18246 where
18247 D: serde::Deserializer<'de>,
18248 {
18249 struct GeneratedVisitor;
18250
18251 impl serde::de::Visitor<'_> for GeneratedVisitor {
18252 type Value = GeneratedField;
18253
18254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18255 write!(formatter, "expected one of: {:?}", &FIELDS)
18256 }
18257
18258 #[allow(unused_variables)]
18259 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18260 where
18261 E: serde::de::Error,
18262 {
18263 match value {
18264 "sstableObjectIds" | "sstable_object_ids" => Ok(GeneratedField::SstableObjectIds),
18265 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18266 }
18267 }
18268 }
18269 deserializer.deserialize_identifier(GeneratedVisitor)
18270 }
18271 }
18272 struct GeneratedVisitor;
18273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18274 type Value = VacuumTask;
18275
18276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18277 formatter.write_str("struct hummock.VacuumTask")
18278 }
18279
18280 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VacuumTask, V::Error>
18281 where
18282 V: serde::de::MapAccess<'de>,
18283 {
18284 let mut sstable_object_ids__ = None;
18285 while let Some(k) = map_.next_key()? {
18286 match k {
18287 GeneratedField::SstableObjectIds => {
18288 if sstable_object_ids__.is_some() {
18289 return Err(serde::de::Error::duplicate_field("sstableObjectIds"));
18290 }
18291 sstable_object_ids__ =
18292 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18293 .into_iter().map(|x| x.0).collect())
18294 ;
18295 }
18296 }
18297 }
18298 Ok(VacuumTask {
18299 sstable_object_ids: sstable_object_ids__.unwrap_or_default(),
18300 })
18301 }
18302 }
18303 deserializer.deserialize_struct("hummock.VacuumTask", FIELDS, GeneratedVisitor)
18304 }
18305}
18306impl serde::Serialize for ValidationTask {
18307 #[allow(deprecated)]
18308 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18309 where
18310 S: serde::Serializer,
18311 {
18312 use serde::ser::SerializeStruct;
18313 let mut len = 0;
18314 if !self.sst_infos.is_empty() {
18315 len += 1;
18316 }
18317 if !self.sst_id_to_worker_id.is_empty() {
18318 len += 1;
18319 }
18320 let mut struct_ser = serializer.serialize_struct("hummock.ValidationTask", len)?;
18321 if !self.sst_infos.is_empty() {
18322 struct_ser.serialize_field("sstInfos", &self.sst_infos)?;
18323 }
18324 if !self.sst_id_to_worker_id.is_empty() {
18325 struct_ser.serialize_field("sstIdToWorkerId", &self.sst_id_to_worker_id)?;
18326 }
18327 struct_ser.end()
18328 }
18329}
18330impl<'de> serde::Deserialize<'de> for ValidationTask {
18331 #[allow(deprecated)]
18332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18333 where
18334 D: serde::Deserializer<'de>,
18335 {
18336 const FIELDS: &[&str] = &[
18337 "sst_infos",
18338 "sstInfos",
18339 "sst_id_to_worker_id",
18340 "sstIdToWorkerId",
18341 ];
18342
18343 #[allow(clippy::enum_variant_names)]
18344 enum GeneratedField {
18345 SstInfos,
18346 SstIdToWorkerId,
18347 }
18348 impl<'de> serde::Deserialize<'de> for GeneratedField {
18349 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18350 where
18351 D: serde::Deserializer<'de>,
18352 {
18353 struct GeneratedVisitor;
18354
18355 impl serde::de::Visitor<'_> for GeneratedVisitor {
18356 type Value = GeneratedField;
18357
18358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18359 write!(formatter, "expected one of: {:?}", &FIELDS)
18360 }
18361
18362 #[allow(unused_variables)]
18363 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18364 where
18365 E: serde::de::Error,
18366 {
18367 match value {
18368 "sstInfos" | "sst_infos" => Ok(GeneratedField::SstInfos),
18369 "sstIdToWorkerId" | "sst_id_to_worker_id" => Ok(GeneratedField::SstIdToWorkerId),
18370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18371 }
18372 }
18373 }
18374 deserializer.deserialize_identifier(GeneratedVisitor)
18375 }
18376 }
18377 struct GeneratedVisitor;
18378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18379 type Value = ValidationTask;
18380
18381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18382 formatter.write_str("struct hummock.ValidationTask")
18383 }
18384
18385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationTask, V::Error>
18386 where
18387 V: serde::de::MapAccess<'de>,
18388 {
18389 let mut sst_infos__ = None;
18390 let mut sst_id_to_worker_id__ = None;
18391 while let Some(k) = map_.next_key()? {
18392 match k {
18393 GeneratedField::SstInfos => {
18394 if sst_infos__.is_some() {
18395 return Err(serde::de::Error::duplicate_field("sstInfos"));
18396 }
18397 sst_infos__ = Some(map_.next_value()?);
18398 }
18399 GeneratedField::SstIdToWorkerId => {
18400 if sst_id_to_worker_id__.is_some() {
18401 return Err(serde::de::Error::duplicate_field("sstIdToWorkerId"));
18402 }
18403 sst_id_to_worker_id__ = Some(
18404 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u32>>>()?
18405 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
18406 );
18407 }
18408 }
18409 }
18410 Ok(ValidationTask {
18411 sst_infos: sst_infos__.unwrap_or_default(),
18412 sst_id_to_worker_id: sst_id_to_worker_id__.unwrap_or_default(),
18413 })
18414 }
18415 }
18416 deserializer.deserialize_struct("hummock.ValidationTask", FIELDS, GeneratedVisitor)
18417 }
18418}
18419impl serde::Serialize for VectorFileInfo {
18420 #[allow(deprecated)]
18421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18422 where
18423 S: serde::Serializer,
18424 {
18425 use serde::ser::SerializeStruct;
18426 let mut len = 0;
18427 if self.object_id != 0 {
18428 len += 1;
18429 }
18430 if self.file_size != 0 {
18431 len += 1;
18432 }
18433 if self.start_vector_id != 0 {
18434 len += 1;
18435 }
18436 if self.vector_count != 0 {
18437 len += 1;
18438 }
18439 if self.meta_offset != 0 {
18440 len += 1;
18441 }
18442 let mut struct_ser = serializer.serialize_struct("hummock.VectorFileInfo", len)?;
18443 if self.object_id != 0 {
18444 #[allow(clippy::needless_borrow)]
18445 #[allow(clippy::needless_borrows_for_generic_args)]
18446 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
18447 }
18448 if self.file_size != 0 {
18449 #[allow(clippy::needless_borrow)]
18450 #[allow(clippy::needless_borrows_for_generic_args)]
18451 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
18452 }
18453 if self.start_vector_id != 0 {
18454 #[allow(clippy::needless_borrow)]
18455 #[allow(clippy::needless_borrows_for_generic_args)]
18456 struct_ser.serialize_field("startVectorId", ToString::to_string(&self.start_vector_id).as_str())?;
18457 }
18458 if self.vector_count != 0 {
18459 struct_ser.serialize_field("vectorCount", &self.vector_count)?;
18460 }
18461 if self.meta_offset != 0 {
18462 #[allow(clippy::needless_borrow)]
18463 #[allow(clippy::needless_borrows_for_generic_args)]
18464 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
18465 }
18466 struct_ser.end()
18467 }
18468}
18469impl<'de> serde::Deserialize<'de> for VectorFileInfo {
18470 #[allow(deprecated)]
18471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18472 where
18473 D: serde::Deserializer<'de>,
18474 {
18475 const FIELDS: &[&str] = &[
18476 "object_id",
18477 "objectId",
18478 "file_size",
18479 "fileSize",
18480 "start_vector_id",
18481 "startVectorId",
18482 "vector_count",
18483 "vectorCount",
18484 "meta_offset",
18485 "metaOffset",
18486 ];
18487
18488 #[allow(clippy::enum_variant_names)]
18489 enum GeneratedField {
18490 ObjectId,
18491 FileSize,
18492 StartVectorId,
18493 VectorCount,
18494 MetaOffset,
18495 }
18496 impl<'de> serde::Deserialize<'de> for GeneratedField {
18497 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18498 where
18499 D: serde::Deserializer<'de>,
18500 {
18501 struct GeneratedVisitor;
18502
18503 impl serde::de::Visitor<'_> for GeneratedVisitor {
18504 type Value = GeneratedField;
18505
18506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18507 write!(formatter, "expected one of: {:?}", &FIELDS)
18508 }
18509
18510 #[allow(unused_variables)]
18511 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18512 where
18513 E: serde::de::Error,
18514 {
18515 match value {
18516 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
18517 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
18518 "startVectorId" | "start_vector_id" => Ok(GeneratedField::StartVectorId),
18519 "vectorCount" | "vector_count" => Ok(GeneratedField::VectorCount),
18520 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
18521 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18522 }
18523 }
18524 }
18525 deserializer.deserialize_identifier(GeneratedVisitor)
18526 }
18527 }
18528 struct GeneratedVisitor;
18529 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18530 type Value = VectorFileInfo;
18531
18532 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18533 formatter.write_str("struct hummock.VectorFileInfo")
18534 }
18535
18536 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorFileInfo, V::Error>
18537 where
18538 V: serde::de::MapAccess<'de>,
18539 {
18540 let mut object_id__ = None;
18541 let mut file_size__ = None;
18542 let mut start_vector_id__ = None;
18543 let mut vector_count__ = None;
18544 let mut meta_offset__ = None;
18545 while let Some(k) = map_.next_key()? {
18546 match k {
18547 GeneratedField::ObjectId => {
18548 if object_id__.is_some() {
18549 return Err(serde::de::Error::duplicate_field("objectId"));
18550 }
18551 object_id__ =
18552 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18553 ;
18554 }
18555 GeneratedField::FileSize => {
18556 if file_size__.is_some() {
18557 return Err(serde::de::Error::duplicate_field("fileSize"));
18558 }
18559 file_size__ =
18560 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18561 ;
18562 }
18563 GeneratedField::StartVectorId => {
18564 if start_vector_id__.is_some() {
18565 return Err(serde::de::Error::duplicate_field("startVectorId"));
18566 }
18567 start_vector_id__ =
18568 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18569 ;
18570 }
18571 GeneratedField::VectorCount => {
18572 if vector_count__.is_some() {
18573 return Err(serde::de::Error::duplicate_field("vectorCount"));
18574 }
18575 vector_count__ =
18576 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18577 ;
18578 }
18579 GeneratedField::MetaOffset => {
18580 if meta_offset__.is_some() {
18581 return Err(serde::de::Error::duplicate_field("metaOffset"));
18582 }
18583 meta_offset__ =
18584 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18585 ;
18586 }
18587 }
18588 }
18589 Ok(VectorFileInfo {
18590 object_id: object_id__.unwrap_or_default(),
18591 file_size: file_size__.unwrap_or_default(),
18592 start_vector_id: start_vector_id__.unwrap_or_default(),
18593 vector_count: vector_count__.unwrap_or_default(),
18594 meta_offset: meta_offset__.unwrap_or_default(),
18595 })
18596 }
18597 }
18598 deserializer.deserialize_struct("hummock.VectorFileInfo", FIELDS, GeneratedVisitor)
18599 }
18600}
18601impl serde::Serialize for VectorIndex {
18602 #[allow(deprecated)]
18603 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18604 where
18605 S: serde::Serializer,
18606 {
18607 use serde::ser::SerializeStruct;
18608 let mut len = 0;
18609 if self.dimension != 0 {
18610 len += 1;
18611 }
18612 if self.distance_type != 0 {
18613 len += 1;
18614 }
18615 if self.variant.is_some() {
18616 len += 1;
18617 }
18618 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndex", len)?;
18619 if self.dimension != 0 {
18620 struct_ser.serialize_field("dimension", &self.dimension)?;
18621 }
18622 if self.distance_type != 0 {
18623 let v = super::common::DistanceType::try_from(self.distance_type)
18624 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
18625 struct_ser.serialize_field("distanceType", &v)?;
18626 }
18627 if let Some(v) = self.variant.as_ref() {
18628 match v {
18629 vector_index::Variant::Flat(v) => {
18630 struct_ser.serialize_field("flat", v)?;
18631 }
18632 vector_index::Variant::HnswFlat(v) => {
18633 struct_ser.serialize_field("hnswFlat", v)?;
18634 }
18635 }
18636 }
18637 struct_ser.end()
18638 }
18639}
18640impl<'de> serde::Deserialize<'de> for VectorIndex {
18641 #[allow(deprecated)]
18642 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18643 where
18644 D: serde::Deserializer<'de>,
18645 {
18646 const FIELDS: &[&str] = &[
18647 "dimension",
18648 "distance_type",
18649 "distanceType",
18650 "flat",
18651 "hnsw_flat",
18652 "hnswFlat",
18653 ];
18654
18655 #[allow(clippy::enum_variant_names)]
18656 enum GeneratedField {
18657 Dimension,
18658 DistanceType,
18659 Flat,
18660 HnswFlat,
18661 }
18662 impl<'de> serde::Deserialize<'de> for GeneratedField {
18663 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18664 where
18665 D: serde::Deserializer<'de>,
18666 {
18667 struct GeneratedVisitor;
18668
18669 impl serde::de::Visitor<'_> for GeneratedVisitor {
18670 type Value = GeneratedField;
18671
18672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18673 write!(formatter, "expected one of: {:?}", &FIELDS)
18674 }
18675
18676 #[allow(unused_variables)]
18677 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18678 where
18679 E: serde::de::Error,
18680 {
18681 match value {
18682 "dimension" => Ok(GeneratedField::Dimension),
18683 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
18684 "flat" => Ok(GeneratedField::Flat),
18685 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
18686 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18687 }
18688 }
18689 }
18690 deserializer.deserialize_identifier(GeneratedVisitor)
18691 }
18692 }
18693 struct GeneratedVisitor;
18694 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18695 type Value = VectorIndex;
18696
18697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18698 formatter.write_str("struct hummock.VectorIndex")
18699 }
18700
18701 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndex, V::Error>
18702 where
18703 V: serde::de::MapAccess<'de>,
18704 {
18705 let mut dimension__ = None;
18706 let mut distance_type__ = None;
18707 let mut variant__ = None;
18708 while let Some(k) = map_.next_key()? {
18709 match k {
18710 GeneratedField::Dimension => {
18711 if dimension__.is_some() {
18712 return Err(serde::de::Error::duplicate_field("dimension"));
18713 }
18714 dimension__ =
18715 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18716 ;
18717 }
18718 GeneratedField::DistanceType => {
18719 if distance_type__.is_some() {
18720 return Err(serde::de::Error::duplicate_field("distanceType"));
18721 }
18722 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
18723 }
18724 GeneratedField::Flat => {
18725 if variant__.is_some() {
18726 return Err(serde::de::Error::duplicate_field("flat"));
18727 }
18728 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::Flat)
18729;
18730 }
18731 GeneratedField::HnswFlat => {
18732 if variant__.is_some() {
18733 return Err(serde::de::Error::duplicate_field("hnswFlat"));
18734 }
18735 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::HnswFlat)
18736;
18737 }
18738 }
18739 }
18740 Ok(VectorIndex {
18741 dimension: dimension__.unwrap_or_default(),
18742 distance_type: distance_type__.unwrap_or_default(),
18743 variant: variant__,
18744 })
18745 }
18746 }
18747 deserializer.deserialize_struct("hummock.VectorIndex", FIELDS, GeneratedVisitor)
18748 }
18749}
18750impl serde::Serialize for VectorIndexDelta {
18751 #[allow(deprecated)]
18752 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18753 where
18754 S: serde::Serializer,
18755 {
18756 use serde::ser::SerializeStruct;
18757 let mut len = 0;
18758 if self.delta.is_some() {
18759 len += 1;
18760 }
18761 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta", len)?;
18762 if let Some(v) = self.delta.as_ref() {
18763 match v {
18764 vector_index_delta::Delta::Init(v) => {
18765 struct_ser.serialize_field("init", v)?;
18766 }
18767 vector_index_delta::Delta::Adds(v) => {
18768 struct_ser.serialize_field("adds", v)?;
18769 }
18770 }
18771 }
18772 struct_ser.end()
18773 }
18774}
18775impl<'de> serde::Deserialize<'de> for VectorIndexDelta {
18776 #[allow(deprecated)]
18777 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18778 where
18779 D: serde::Deserializer<'de>,
18780 {
18781 const FIELDS: &[&str] = &[
18782 "init",
18783 "adds",
18784 ];
18785
18786 #[allow(clippy::enum_variant_names)]
18787 enum GeneratedField {
18788 Init,
18789 Adds,
18790 }
18791 impl<'de> serde::Deserialize<'de> for GeneratedField {
18792 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18793 where
18794 D: serde::Deserializer<'de>,
18795 {
18796 struct GeneratedVisitor;
18797
18798 impl serde::de::Visitor<'_> for GeneratedVisitor {
18799 type Value = GeneratedField;
18800
18801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18802 write!(formatter, "expected one of: {:?}", &FIELDS)
18803 }
18804
18805 #[allow(unused_variables)]
18806 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18807 where
18808 E: serde::de::Error,
18809 {
18810 match value {
18811 "init" => Ok(GeneratedField::Init),
18812 "adds" => Ok(GeneratedField::Adds),
18813 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18814 }
18815 }
18816 }
18817 deserializer.deserialize_identifier(GeneratedVisitor)
18818 }
18819 }
18820 struct GeneratedVisitor;
18821 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18822 type Value = VectorIndexDelta;
18823
18824 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18825 formatter.write_str("struct hummock.VectorIndexDelta")
18826 }
18827
18828 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexDelta, V::Error>
18829 where
18830 V: serde::de::MapAccess<'de>,
18831 {
18832 let mut delta__ = None;
18833 while let Some(k) = map_.next_key()? {
18834 match k {
18835 GeneratedField::Init => {
18836 if delta__.is_some() {
18837 return Err(serde::de::Error::duplicate_field("init"));
18838 }
18839 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Init)
18840;
18841 }
18842 GeneratedField::Adds => {
18843 if delta__.is_some() {
18844 return Err(serde::de::Error::duplicate_field("adds"));
18845 }
18846 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Adds)
18847;
18848 }
18849 }
18850 }
18851 Ok(VectorIndexDelta {
18852 delta: delta__,
18853 })
18854 }
18855 }
18856 deserializer.deserialize_struct("hummock.VectorIndexDelta", FIELDS, GeneratedVisitor)
18857 }
18858}
18859impl serde::Serialize for vector_index_delta::VectorIndexAdd {
18860 #[allow(deprecated)]
18861 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18862 where
18863 S: serde::Serializer,
18864 {
18865 use serde::ser::SerializeStruct;
18866 let mut len = 0;
18867 if self.add.is_some() {
18868 len += 1;
18869 }
18870 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", len)?;
18871 if let Some(v) = self.add.as_ref() {
18872 match v {
18873 vector_index_delta::vector_index_add::Add::Flat(v) => {
18874 struct_ser.serialize_field("flat", v)?;
18875 }
18876 vector_index_delta::vector_index_add::Add::HnswFlat(v) => {
18877 struct_ser.serialize_field("hnswFlat", v)?;
18878 }
18879 }
18880 }
18881 struct_ser.end()
18882 }
18883}
18884impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdd {
18885 #[allow(deprecated)]
18886 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18887 where
18888 D: serde::Deserializer<'de>,
18889 {
18890 const FIELDS: &[&str] = &[
18891 "flat",
18892 "hnsw_flat",
18893 "hnswFlat",
18894 ];
18895
18896 #[allow(clippy::enum_variant_names)]
18897 enum GeneratedField {
18898 Flat,
18899 HnswFlat,
18900 }
18901 impl<'de> serde::Deserialize<'de> for GeneratedField {
18902 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18903 where
18904 D: serde::Deserializer<'de>,
18905 {
18906 struct GeneratedVisitor;
18907
18908 impl serde::de::Visitor<'_> for GeneratedVisitor {
18909 type Value = GeneratedField;
18910
18911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18912 write!(formatter, "expected one of: {:?}", &FIELDS)
18913 }
18914
18915 #[allow(unused_variables)]
18916 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18917 where
18918 E: serde::de::Error,
18919 {
18920 match value {
18921 "flat" => Ok(GeneratedField::Flat),
18922 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
18923 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18924 }
18925 }
18926 }
18927 deserializer.deserialize_identifier(GeneratedVisitor)
18928 }
18929 }
18930 struct GeneratedVisitor;
18931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18932 type Value = vector_index_delta::VectorIndexAdd;
18933
18934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18935 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdd")
18936 }
18937
18938 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdd, V::Error>
18939 where
18940 V: serde::de::MapAccess<'de>,
18941 {
18942 let mut add__ = None;
18943 while let Some(k) = map_.next_key()? {
18944 match k {
18945 GeneratedField::Flat => {
18946 if add__.is_some() {
18947 return Err(serde::de::Error::duplicate_field("flat"));
18948 }
18949 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::Flat)
18950;
18951 }
18952 GeneratedField::HnswFlat => {
18953 if add__.is_some() {
18954 return Err(serde::de::Error::duplicate_field("hnswFlat"));
18955 }
18956 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::HnswFlat)
18957;
18958 }
18959 }
18960 }
18961 Ok(vector_index_delta::VectorIndexAdd {
18962 add: add__,
18963 })
18964 }
18965 }
18966 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", FIELDS, GeneratedVisitor)
18967 }
18968}
18969impl serde::Serialize for vector_index_delta::VectorIndexAdds {
18970 #[allow(deprecated)]
18971 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18972 where
18973 S: serde::Serializer,
18974 {
18975 use serde::ser::SerializeStruct;
18976 let mut len = 0;
18977 if !self.adds.is_empty() {
18978 len += 1;
18979 }
18980 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", len)?;
18981 if !self.adds.is_empty() {
18982 struct_ser.serialize_field("adds", &self.adds)?;
18983 }
18984 struct_ser.end()
18985 }
18986}
18987impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdds {
18988 #[allow(deprecated)]
18989 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18990 where
18991 D: serde::Deserializer<'de>,
18992 {
18993 const FIELDS: &[&str] = &[
18994 "adds",
18995 ];
18996
18997 #[allow(clippy::enum_variant_names)]
18998 enum GeneratedField {
18999 Adds,
19000 }
19001 impl<'de> serde::Deserialize<'de> for GeneratedField {
19002 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19003 where
19004 D: serde::Deserializer<'de>,
19005 {
19006 struct GeneratedVisitor;
19007
19008 impl serde::de::Visitor<'_> for GeneratedVisitor {
19009 type Value = GeneratedField;
19010
19011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19012 write!(formatter, "expected one of: {:?}", &FIELDS)
19013 }
19014
19015 #[allow(unused_variables)]
19016 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19017 where
19018 E: serde::de::Error,
19019 {
19020 match value {
19021 "adds" => Ok(GeneratedField::Adds),
19022 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19023 }
19024 }
19025 }
19026 deserializer.deserialize_identifier(GeneratedVisitor)
19027 }
19028 }
19029 struct GeneratedVisitor;
19030 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19031 type Value = vector_index_delta::VectorIndexAdds;
19032
19033 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19034 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdds")
19035 }
19036
19037 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdds, V::Error>
19038 where
19039 V: serde::de::MapAccess<'de>,
19040 {
19041 let mut adds__ = None;
19042 while let Some(k) = map_.next_key()? {
19043 match k {
19044 GeneratedField::Adds => {
19045 if adds__.is_some() {
19046 return Err(serde::de::Error::duplicate_field("adds"));
19047 }
19048 adds__ = Some(map_.next_value()?);
19049 }
19050 }
19051 }
19052 Ok(vector_index_delta::VectorIndexAdds {
19053 adds: adds__.unwrap_or_default(),
19054 })
19055 }
19056 }
19057 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", FIELDS, GeneratedVisitor)
19058 }
19059}
19060impl serde::Serialize for vector_index_delta::VectorIndexInit {
19061 #[allow(deprecated)]
19062 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19063 where
19064 S: serde::Serializer,
19065 {
19066 use serde::ser::SerializeStruct;
19067 let mut len = 0;
19068 if self.info.is_some() {
19069 len += 1;
19070 }
19071 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexInit", len)?;
19072 if let Some(v) = self.info.as_ref() {
19073 struct_ser.serialize_field("info", v)?;
19074 }
19075 struct_ser.end()
19076 }
19077}
19078impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexInit {
19079 #[allow(deprecated)]
19080 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19081 where
19082 D: serde::Deserializer<'de>,
19083 {
19084 const FIELDS: &[&str] = &[
19085 "info",
19086 ];
19087
19088 #[allow(clippy::enum_variant_names)]
19089 enum GeneratedField {
19090 Info,
19091 }
19092 impl<'de> serde::Deserialize<'de> for GeneratedField {
19093 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19094 where
19095 D: serde::Deserializer<'de>,
19096 {
19097 struct GeneratedVisitor;
19098
19099 impl serde::de::Visitor<'_> for GeneratedVisitor {
19100 type Value = GeneratedField;
19101
19102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19103 write!(formatter, "expected one of: {:?}", &FIELDS)
19104 }
19105
19106 #[allow(unused_variables)]
19107 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19108 where
19109 E: serde::de::Error,
19110 {
19111 match value {
19112 "info" => Ok(GeneratedField::Info),
19113 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19114 }
19115 }
19116 }
19117 deserializer.deserialize_identifier(GeneratedVisitor)
19118 }
19119 }
19120 struct GeneratedVisitor;
19121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19122 type Value = vector_index_delta::VectorIndexInit;
19123
19124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19125 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexInit")
19126 }
19127
19128 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexInit, V::Error>
19129 where
19130 V: serde::de::MapAccess<'de>,
19131 {
19132 let mut info__ = None;
19133 while let Some(k) = map_.next_key()? {
19134 match k {
19135 GeneratedField::Info => {
19136 if info__.is_some() {
19137 return Err(serde::de::Error::duplicate_field("info"));
19138 }
19139 info__ = map_.next_value()?;
19140 }
19141 }
19142 }
19143 Ok(vector_index_delta::VectorIndexInit {
19144 info: info__,
19145 })
19146 }
19147 }
19148 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexInit", FIELDS, GeneratedVisitor)
19149 }
19150}
19151impl serde::Serialize for VectorIndexObject {
19152 #[allow(deprecated)]
19153 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19154 where
19155 S: serde::Serializer,
19156 {
19157 use serde::ser::SerializeStruct;
19158 let mut len = 0;
19159 if self.id != 0 {
19160 len += 1;
19161 }
19162 if self.object_type != 0 {
19163 len += 1;
19164 }
19165 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexObject", len)?;
19166 if self.id != 0 {
19167 #[allow(clippy::needless_borrow)]
19168 #[allow(clippy::needless_borrows_for_generic_args)]
19169 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
19170 }
19171 if self.object_type != 0 {
19172 let v = VectorIndexObjectType::try_from(self.object_type)
19173 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
19174 struct_ser.serialize_field("objectType", &v)?;
19175 }
19176 struct_ser.end()
19177 }
19178}
19179impl<'de> serde::Deserialize<'de> for VectorIndexObject {
19180 #[allow(deprecated)]
19181 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19182 where
19183 D: serde::Deserializer<'de>,
19184 {
19185 const FIELDS: &[&str] = &[
19186 "id",
19187 "object_type",
19188 "objectType",
19189 ];
19190
19191 #[allow(clippy::enum_variant_names)]
19192 enum GeneratedField {
19193 Id,
19194 ObjectType,
19195 }
19196 impl<'de> serde::Deserialize<'de> for GeneratedField {
19197 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19198 where
19199 D: serde::Deserializer<'de>,
19200 {
19201 struct GeneratedVisitor;
19202
19203 impl serde::de::Visitor<'_> for GeneratedVisitor {
19204 type Value = GeneratedField;
19205
19206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19207 write!(formatter, "expected one of: {:?}", &FIELDS)
19208 }
19209
19210 #[allow(unused_variables)]
19211 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19212 where
19213 E: serde::de::Error,
19214 {
19215 match value {
19216 "id" => Ok(GeneratedField::Id),
19217 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
19218 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19219 }
19220 }
19221 }
19222 deserializer.deserialize_identifier(GeneratedVisitor)
19223 }
19224 }
19225 struct GeneratedVisitor;
19226 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19227 type Value = VectorIndexObject;
19228
19229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19230 formatter.write_str("struct hummock.VectorIndexObject")
19231 }
19232
19233 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexObject, V::Error>
19234 where
19235 V: serde::de::MapAccess<'de>,
19236 {
19237 let mut id__ = None;
19238 let mut object_type__ = None;
19239 while let Some(k) = map_.next_key()? {
19240 match k {
19241 GeneratedField::Id => {
19242 if id__.is_some() {
19243 return Err(serde::de::Error::duplicate_field("id"));
19244 }
19245 id__ =
19246 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19247 ;
19248 }
19249 GeneratedField::ObjectType => {
19250 if object_type__.is_some() {
19251 return Err(serde::de::Error::duplicate_field("objectType"));
19252 }
19253 object_type__ = Some(map_.next_value::<VectorIndexObjectType>()? as i32);
19254 }
19255 }
19256 }
19257 Ok(VectorIndexObject {
19258 id: id__.unwrap_or_default(),
19259 object_type: object_type__.unwrap_or_default(),
19260 })
19261 }
19262 }
19263 deserializer.deserialize_struct("hummock.VectorIndexObject", FIELDS, GeneratedVisitor)
19264 }
19265}
19266impl serde::Serialize for VectorIndexObjectType {
19267 #[allow(deprecated)]
19268 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19269 where
19270 S: serde::Serializer,
19271 {
19272 let variant = match self {
19273 Self::VectorIndexObjectUnspecified => "VECTOR_INDEX_OBJECT_UNSPECIFIED",
19274 Self::VectorIndexObjectVector => "VECTOR_INDEX_OBJECT_VECTOR",
19275 Self::VectorIndexObjectHnswGraph => "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
19276 };
19277 serializer.serialize_str(variant)
19278 }
19279}
19280impl<'de> serde::Deserialize<'de> for VectorIndexObjectType {
19281 #[allow(deprecated)]
19282 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19283 where
19284 D: serde::Deserializer<'de>,
19285 {
19286 const FIELDS: &[&str] = &[
19287 "VECTOR_INDEX_OBJECT_UNSPECIFIED",
19288 "VECTOR_INDEX_OBJECT_VECTOR",
19289 "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
19290 ];
19291
19292 struct GeneratedVisitor;
19293
19294 impl serde::de::Visitor<'_> for GeneratedVisitor {
19295 type Value = VectorIndexObjectType;
19296
19297 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19298 write!(formatter, "expected one of: {:?}", &FIELDS)
19299 }
19300
19301 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19302 where
19303 E: serde::de::Error,
19304 {
19305 i32::try_from(v)
19306 .ok()
19307 .and_then(|x| x.try_into().ok())
19308 .ok_or_else(|| {
19309 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19310 })
19311 }
19312
19313 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19314 where
19315 E: serde::de::Error,
19316 {
19317 i32::try_from(v)
19318 .ok()
19319 .and_then(|x| x.try_into().ok())
19320 .ok_or_else(|| {
19321 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19322 })
19323 }
19324
19325 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19326 where
19327 E: serde::de::Error,
19328 {
19329 match value {
19330 "VECTOR_INDEX_OBJECT_UNSPECIFIED" => Ok(VectorIndexObjectType::VectorIndexObjectUnspecified),
19331 "VECTOR_INDEX_OBJECT_VECTOR" => Ok(VectorIndexObjectType::VectorIndexObjectVector),
19332 "VECTOR_INDEX_OBJECT_HNSW_GRAPH" => Ok(VectorIndexObjectType::VectorIndexObjectHnswGraph),
19333 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19334 }
19335 }
19336 }
19337 deserializer.deserialize_any(GeneratedVisitor)
19338 }
19339}
19340impl serde::Serialize for VersionUpdatePayload {
19341 #[allow(deprecated)]
19342 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19343 where
19344 S: serde::Serializer,
19345 {
19346 use serde::ser::SerializeStruct;
19347 let mut len = 0;
19348 if self.payload.is_some() {
19349 len += 1;
19350 }
19351 let mut struct_ser = serializer.serialize_struct("hummock.VersionUpdatePayload", len)?;
19352 if let Some(v) = self.payload.as_ref() {
19353 match v {
19354 version_update_payload::Payload::VersionDeltas(v) => {
19355 struct_ser.serialize_field("versionDeltas", v)?;
19356 }
19357 version_update_payload::Payload::PinnedVersion(v) => {
19358 struct_ser.serialize_field("pinnedVersion", v)?;
19359 }
19360 }
19361 }
19362 struct_ser.end()
19363 }
19364}
19365impl<'de> serde::Deserialize<'de> for VersionUpdatePayload {
19366 #[allow(deprecated)]
19367 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19368 where
19369 D: serde::Deserializer<'de>,
19370 {
19371 const FIELDS: &[&str] = &[
19372 "version_deltas",
19373 "versionDeltas",
19374 "pinned_version",
19375 "pinnedVersion",
19376 ];
19377
19378 #[allow(clippy::enum_variant_names)]
19379 enum GeneratedField {
19380 VersionDeltas,
19381 PinnedVersion,
19382 }
19383 impl<'de> serde::Deserialize<'de> for GeneratedField {
19384 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19385 where
19386 D: serde::Deserializer<'de>,
19387 {
19388 struct GeneratedVisitor;
19389
19390 impl serde::de::Visitor<'_> for GeneratedVisitor {
19391 type Value = GeneratedField;
19392
19393 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19394 write!(formatter, "expected one of: {:?}", &FIELDS)
19395 }
19396
19397 #[allow(unused_variables)]
19398 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19399 where
19400 E: serde::de::Error,
19401 {
19402 match value {
19403 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
19404 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
19405 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19406 }
19407 }
19408 }
19409 deserializer.deserialize_identifier(GeneratedVisitor)
19410 }
19411 }
19412 struct GeneratedVisitor;
19413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19414 type Value = VersionUpdatePayload;
19415
19416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19417 formatter.write_str("struct hummock.VersionUpdatePayload")
19418 }
19419
19420 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VersionUpdatePayload, V::Error>
19421 where
19422 V: serde::de::MapAccess<'de>,
19423 {
19424 let mut payload__ = None;
19425 while let Some(k) = map_.next_key()? {
19426 match k {
19427 GeneratedField::VersionDeltas => {
19428 if payload__.is_some() {
19429 return Err(serde::de::Error::duplicate_field("versionDeltas"));
19430 }
19431 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::VersionDeltas)
19432;
19433 }
19434 GeneratedField::PinnedVersion => {
19435 if payload__.is_some() {
19436 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
19437 }
19438 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::PinnedVersion)
19439;
19440 }
19441 }
19442 }
19443 Ok(VersionUpdatePayload {
19444 payload: payload__,
19445 })
19446 }
19447 }
19448 deserializer.deserialize_struct("hummock.VersionUpdatePayload", FIELDS, GeneratedVisitor)
19449 }
19450}
19451impl serde::Serialize for VnodeStatistics {
19452 #[allow(deprecated)]
19453 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19454 where
19455 S: serde::Serializer,
19456 {
19457 use serde::ser::SerializeStruct;
19458 let mut len = 0;
19459 if !self.vnode_user_key_ranges.is_empty() {
19460 len += 1;
19461 }
19462 let mut struct_ser = serializer.serialize_struct("hummock.VnodeStatistics", len)?;
19463 if !self.vnode_user_key_ranges.is_empty() {
19464 struct_ser.serialize_field("vnodeUserKeyRanges", &self.vnode_user_key_ranges)?;
19465 }
19466 struct_ser.end()
19467 }
19468}
19469impl<'de> serde::Deserialize<'de> for VnodeStatistics {
19470 #[allow(deprecated)]
19471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19472 where
19473 D: serde::Deserializer<'de>,
19474 {
19475 const FIELDS: &[&str] = &[
19476 "vnode_user_key_ranges",
19477 "vnodeUserKeyRanges",
19478 ];
19479
19480 #[allow(clippy::enum_variant_names)]
19481 enum GeneratedField {
19482 VnodeUserKeyRanges,
19483 }
19484 impl<'de> serde::Deserialize<'de> for GeneratedField {
19485 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19486 where
19487 D: serde::Deserializer<'de>,
19488 {
19489 struct GeneratedVisitor;
19490
19491 impl serde::de::Visitor<'_> for GeneratedVisitor {
19492 type Value = GeneratedField;
19493
19494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19495 write!(formatter, "expected one of: {:?}", &FIELDS)
19496 }
19497
19498 #[allow(unused_variables)]
19499 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19500 where
19501 E: serde::de::Error,
19502 {
19503 match value {
19504 "vnodeUserKeyRanges" | "vnode_user_key_ranges" => Ok(GeneratedField::VnodeUserKeyRanges),
19505 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19506 }
19507 }
19508 }
19509 deserializer.deserialize_identifier(GeneratedVisitor)
19510 }
19511 }
19512 struct GeneratedVisitor;
19513 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19514 type Value = VnodeStatistics;
19515
19516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19517 formatter.write_str("struct hummock.VnodeStatistics")
19518 }
19519
19520 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeStatistics, V::Error>
19521 where
19522 V: serde::de::MapAccess<'de>,
19523 {
19524 let mut vnode_user_key_ranges__ = None;
19525 while let Some(k) = map_.next_key()? {
19526 match k {
19527 GeneratedField::VnodeUserKeyRanges => {
19528 if vnode_user_key_ranges__.is_some() {
19529 return Err(serde::de::Error::duplicate_field("vnodeUserKeyRanges"));
19530 }
19531 vnode_user_key_ranges__ = Some(
19532 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19533 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19534 );
19535 }
19536 }
19537 }
19538 Ok(VnodeStatistics {
19539 vnode_user_key_ranges: vnode_user_key_ranges__.unwrap_or_default(),
19540 })
19541 }
19542 }
19543 deserializer.deserialize_struct("hummock.VnodeStatistics", FIELDS, GeneratedVisitor)
19544 }
19545}
19546impl serde::Serialize for VnodeUserKeyRange {
19547 #[allow(deprecated)]
19548 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19549 where
19550 S: serde::Serializer,
19551 {
19552 use serde::ser::SerializeStruct;
19553 let mut len = 0;
19554 if !self.min_key.is_empty() {
19555 len += 1;
19556 }
19557 if !self.max_key.is_empty() {
19558 len += 1;
19559 }
19560 let mut struct_ser = serializer.serialize_struct("hummock.VnodeUserKeyRange", len)?;
19561 if !self.min_key.is_empty() {
19562 #[allow(clippy::needless_borrow)]
19563 #[allow(clippy::needless_borrows_for_generic_args)]
19564 struct_ser.serialize_field("minKey", pbjson::private::base64::encode(&self.min_key).as_str())?;
19565 }
19566 if !self.max_key.is_empty() {
19567 #[allow(clippy::needless_borrow)]
19568 #[allow(clippy::needless_borrows_for_generic_args)]
19569 struct_ser.serialize_field("maxKey", pbjson::private::base64::encode(&self.max_key).as_str())?;
19570 }
19571 struct_ser.end()
19572 }
19573}
19574impl<'de> serde::Deserialize<'de> for VnodeUserKeyRange {
19575 #[allow(deprecated)]
19576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19577 where
19578 D: serde::Deserializer<'de>,
19579 {
19580 const FIELDS: &[&str] = &[
19581 "min_key",
19582 "minKey",
19583 "max_key",
19584 "maxKey",
19585 ];
19586
19587 #[allow(clippy::enum_variant_names)]
19588 enum GeneratedField {
19589 MinKey,
19590 MaxKey,
19591 }
19592 impl<'de> serde::Deserialize<'de> for GeneratedField {
19593 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19594 where
19595 D: serde::Deserializer<'de>,
19596 {
19597 struct GeneratedVisitor;
19598
19599 impl serde::de::Visitor<'_> for GeneratedVisitor {
19600 type Value = GeneratedField;
19601
19602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19603 write!(formatter, "expected one of: {:?}", &FIELDS)
19604 }
19605
19606 #[allow(unused_variables)]
19607 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19608 where
19609 E: serde::de::Error,
19610 {
19611 match value {
19612 "minKey" | "min_key" => Ok(GeneratedField::MinKey),
19613 "maxKey" | "max_key" => Ok(GeneratedField::MaxKey),
19614 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19615 }
19616 }
19617 }
19618 deserializer.deserialize_identifier(GeneratedVisitor)
19619 }
19620 }
19621 struct GeneratedVisitor;
19622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19623 type Value = VnodeUserKeyRange;
19624
19625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19626 formatter.write_str("struct hummock.VnodeUserKeyRange")
19627 }
19628
19629 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeUserKeyRange, V::Error>
19630 where
19631 V: serde::de::MapAccess<'de>,
19632 {
19633 let mut min_key__ = None;
19634 let mut max_key__ = None;
19635 while let Some(k) = map_.next_key()? {
19636 match k {
19637 GeneratedField::MinKey => {
19638 if min_key__.is_some() {
19639 return Err(serde::de::Error::duplicate_field("minKey"));
19640 }
19641 min_key__ =
19642 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
19643 ;
19644 }
19645 GeneratedField::MaxKey => {
19646 if max_key__.is_some() {
19647 return Err(serde::de::Error::duplicate_field("maxKey"));
19648 }
19649 max_key__ =
19650 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
19651 ;
19652 }
19653 }
19654 }
19655 Ok(VnodeUserKeyRange {
19656 min_key: min_key__.unwrap_or_default(),
19657 max_key: max_key__.unwrap_or_default(),
19658 })
19659 }
19660 }
19661 deserializer.deserialize_struct("hummock.VnodeUserKeyRange", FIELDS, GeneratedVisitor)
19662 }
19663}
19664impl serde::Serialize for VnodeWatermark {
19665 #[allow(deprecated)]
19666 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19667 where
19668 S: serde::Serializer,
19669 {
19670 use serde::ser::SerializeStruct;
19671 let mut len = 0;
19672 if !self.watermark.is_empty() {
19673 len += 1;
19674 }
19675 if self.vnode_bitmap.is_some() {
19676 len += 1;
19677 }
19678 let mut struct_ser = serializer.serialize_struct("hummock.VnodeWatermark", len)?;
19679 if !self.watermark.is_empty() {
19680 #[allow(clippy::needless_borrow)]
19681 #[allow(clippy::needless_borrows_for_generic_args)]
19682 struct_ser.serialize_field("watermark", pbjson::private::base64::encode(&self.watermark).as_str())?;
19683 }
19684 if let Some(v) = self.vnode_bitmap.as_ref() {
19685 struct_ser.serialize_field("vnodeBitmap", v)?;
19686 }
19687 struct_ser.end()
19688 }
19689}
19690impl<'de> serde::Deserialize<'de> for VnodeWatermark {
19691 #[allow(deprecated)]
19692 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19693 where
19694 D: serde::Deserializer<'de>,
19695 {
19696 const FIELDS: &[&str] = &[
19697 "watermark",
19698 "vnode_bitmap",
19699 "vnodeBitmap",
19700 ];
19701
19702 #[allow(clippy::enum_variant_names)]
19703 enum GeneratedField {
19704 Watermark,
19705 VnodeBitmap,
19706 }
19707 impl<'de> serde::Deserialize<'de> for GeneratedField {
19708 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19709 where
19710 D: serde::Deserializer<'de>,
19711 {
19712 struct GeneratedVisitor;
19713
19714 impl serde::de::Visitor<'_> for GeneratedVisitor {
19715 type Value = GeneratedField;
19716
19717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19718 write!(formatter, "expected one of: {:?}", &FIELDS)
19719 }
19720
19721 #[allow(unused_variables)]
19722 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19723 where
19724 E: serde::de::Error,
19725 {
19726 match value {
19727 "watermark" => Ok(GeneratedField::Watermark),
19728 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
19729 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19730 }
19731 }
19732 }
19733 deserializer.deserialize_identifier(GeneratedVisitor)
19734 }
19735 }
19736 struct GeneratedVisitor;
19737 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19738 type Value = VnodeWatermark;
19739
19740 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19741 formatter.write_str("struct hummock.VnodeWatermark")
19742 }
19743
19744 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeWatermark, V::Error>
19745 where
19746 V: serde::de::MapAccess<'de>,
19747 {
19748 let mut watermark__ = None;
19749 let mut vnode_bitmap__ = None;
19750 while let Some(k) = map_.next_key()? {
19751 match k {
19752 GeneratedField::Watermark => {
19753 if watermark__.is_some() {
19754 return Err(serde::de::Error::duplicate_field("watermark"));
19755 }
19756 watermark__ =
19757 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
19758 ;
19759 }
19760 GeneratedField::VnodeBitmap => {
19761 if vnode_bitmap__.is_some() {
19762 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
19763 }
19764 vnode_bitmap__ = map_.next_value()?;
19765 }
19766 }
19767 }
19768 Ok(VnodeWatermark {
19769 watermark: watermark__.unwrap_or_default(),
19770 vnode_bitmap: vnode_bitmap__,
19771 })
19772 }
19773 }
19774 deserializer.deserialize_struct("hummock.VnodeWatermark", FIELDS, GeneratedVisitor)
19775 }
19776}
19777impl serde::Serialize for WatermarkSerdeType {
19778 #[allow(deprecated)]
19779 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19780 where
19781 S: serde::Serializer,
19782 {
19783 let variant = match self {
19784 Self::TypeUnspecified => "TYPE_UNSPECIFIED",
19785 Self::PkPrefix => "PK_PREFIX",
19786 Self::NonPkPrefix => "NON_PK_PREFIX",
19787 Self::Value => "VALUE",
19788 };
19789 serializer.serialize_str(variant)
19790 }
19791}
19792impl<'de> serde::Deserialize<'de> for WatermarkSerdeType {
19793 #[allow(deprecated)]
19794 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19795 where
19796 D: serde::Deserializer<'de>,
19797 {
19798 const FIELDS: &[&str] = &[
19799 "TYPE_UNSPECIFIED",
19800 "PK_PREFIX",
19801 "NON_PK_PREFIX",
19802 "VALUE",
19803 ];
19804
19805 struct GeneratedVisitor;
19806
19807 impl serde::de::Visitor<'_> for GeneratedVisitor {
19808 type Value = WatermarkSerdeType;
19809
19810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19811 write!(formatter, "expected one of: {:?}", &FIELDS)
19812 }
19813
19814 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19815 where
19816 E: serde::de::Error,
19817 {
19818 i32::try_from(v)
19819 .ok()
19820 .and_then(|x| x.try_into().ok())
19821 .ok_or_else(|| {
19822 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19823 })
19824 }
19825
19826 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19827 where
19828 E: serde::de::Error,
19829 {
19830 i32::try_from(v)
19831 .ok()
19832 .and_then(|x| x.try_into().ok())
19833 .ok_or_else(|| {
19834 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19835 })
19836 }
19837
19838 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19839 where
19840 E: serde::de::Error,
19841 {
19842 match value {
19843 "TYPE_UNSPECIFIED" => Ok(WatermarkSerdeType::TypeUnspecified),
19844 "PK_PREFIX" => Ok(WatermarkSerdeType::PkPrefix),
19845 "NON_PK_PREFIX" => Ok(WatermarkSerdeType::NonPkPrefix),
19846 "VALUE" => Ok(WatermarkSerdeType::Value),
19847 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19848 }
19849 }
19850 }
19851 deserializer.deserialize_any(GeneratedVisitor)
19852 }
19853}
19854impl serde::Serialize for WriteLimits {
19855 #[allow(deprecated)]
19856 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19857 where
19858 S: serde::Serializer,
19859 {
19860 use serde::ser::SerializeStruct;
19861 let mut len = 0;
19862 if !self.write_limits.is_empty() {
19863 len += 1;
19864 }
19865 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits", len)?;
19866 if !self.write_limits.is_empty() {
19867 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
19868 }
19869 struct_ser.end()
19870 }
19871}
19872impl<'de> serde::Deserialize<'de> for WriteLimits {
19873 #[allow(deprecated)]
19874 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19875 where
19876 D: serde::Deserializer<'de>,
19877 {
19878 const FIELDS: &[&str] = &[
19879 "write_limits",
19880 "writeLimits",
19881 ];
19882
19883 #[allow(clippy::enum_variant_names)]
19884 enum GeneratedField {
19885 WriteLimits,
19886 }
19887 impl<'de> serde::Deserialize<'de> for GeneratedField {
19888 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19889 where
19890 D: serde::Deserializer<'de>,
19891 {
19892 struct GeneratedVisitor;
19893
19894 impl serde::de::Visitor<'_> for GeneratedVisitor {
19895 type Value = GeneratedField;
19896
19897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19898 write!(formatter, "expected one of: {:?}", &FIELDS)
19899 }
19900
19901 #[allow(unused_variables)]
19902 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19903 where
19904 E: serde::de::Error,
19905 {
19906 match value {
19907 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
19908 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19909 }
19910 }
19911 }
19912 deserializer.deserialize_identifier(GeneratedVisitor)
19913 }
19914 }
19915 struct GeneratedVisitor;
19916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19917 type Value = WriteLimits;
19918
19919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19920 formatter.write_str("struct hummock.WriteLimits")
19921 }
19922
19923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WriteLimits, V::Error>
19924 where
19925 V: serde::de::MapAccess<'de>,
19926 {
19927 let mut write_limits__ = None;
19928 while let Some(k) = map_.next_key()? {
19929 match k {
19930 GeneratedField::WriteLimits => {
19931 if write_limits__.is_some() {
19932 return Err(serde::de::Error::duplicate_field("writeLimits"));
19933 }
19934 write_limits__ = Some(
19935 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
19936 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19937 );
19938 }
19939 }
19940 }
19941 Ok(WriteLimits {
19942 write_limits: write_limits__.unwrap_or_default(),
19943 })
19944 }
19945 }
19946 deserializer.deserialize_struct("hummock.WriteLimits", FIELDS, GeneratedVisitor)
19947 }
19948}
19949impl serde::Serialize for write_limits::WriteLimit {
19950 #[allow(deprecated)]
19951 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19952 where
19953 S: serde::Serializer,
19954 {
19955 use serde::ser::SerializeStruct;
19956 let mut len = 0;
19957 if !self.table_ids.is_empty() {
19958 len += 1;
19959 }
19960 if !self.reason.is_empty() {
19961 len += 1;
19962 }
19963 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits.WriteLimit", len)?;
19964 if !self.table_ids.is_empty() {
19965 struct_ser.serialize_field("tableIds", &self.table_ids)?;
19966 }
19967 if !self.reason.is_empty() {
19968 struct_ser.serialize_field("reason", &self.reason)?;
19969 }
19970 struct_ser.end()
19971 }
19972}
19973impl<'de> serde::Deserialize<'de> for write_limits::WriteLimit {
19974 #[allow(deprecated)]
19975 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19976 where
19977 D: serde::Deserializer<'de>,
19978 {
19979 const FIELDS: &[&str] = &[
19980 "table_ids",
19981 "tableIds",
19982 "reason",
19983 ];
19984
19985 #[allow(clippy::enum_variant_names)]
19986 enum GeneratedField {
19987 TableIds,
19988 Reason,
19989 }
19990 impl<'de> serde::Deserialize<'de> for GeneratedField {
19991 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19992 where
19993 D: serde::Deserializer<'de>,
19994 {
19995 struct GeneratedVisitor;
19996
19997 impl serde::de::Visitor<'_> for GeneratedVisitor {
19998 type Value = GeneratedField;
19999
20000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20001 write!(formatter, "expected one of: {:?}", &FIELDS)
20002 }
20003
20004 #[allow(unused_variables)]
20005 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20006 where
20007 E: serde::de::Error,
20008 {
20009 match value {
20010 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
20011 "reason" => Ok(GeneratedField::Reason),
20012 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20013 }
20014 }
20015 }
20016 deserializer.deserialize_identifier(GeneratedVisitor)
20017 }
20018 }
20019 struct GeneratedVisitor;
20020 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20021 type Value = write_limits::WriteLimit;
20022
20023 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20024 formatter.write_str("struct hummock.WriteLimits.WriteLimit")
20025 }
20026
20027 fn visit_map<V>(self, mut map_: V) -> std::result::Result<write_limits::WriteLimit, V::Error>
20028 where
20029 V: serde::de::MapAccess<'de>,
20030 {
20031 let mut table_ids__ = None;
20032 let mut reason__ = None;
20033 while let Some(k) = map_.next_key()? {
20034 match k {
20035 GeneratedField::TableIds => {
20036 if table_ids__.is_some() {
20037 return Err(serde::de::Error::duplicate_field("tableIds"));
20038 }
20039 table_ids__ =
20040 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20041 .into_iter().map(|x| x.0).collect())
20042 ;
20043 }
20044 GeneratedField::Reason => {
20045 if reason__.is_some() {
20046 return Err(serde::de::Error::duplicate_field("reason"));
20047 }
20048 reason__ = Some(map_.next_value()?);
20049 }
20050 }
20051 }
20052 Ok(write_limits::WriteLimit {
20053 table_ids: table_ids__.unwrap_or_default(),
20054 reason: reason__.unwrap_or_default(),
20055 })
20056 }
20057 }
20058 deserializer.deserialize_struct("hummock.WriteLimits.WriteLimit", FIELDS, GeneratedVisitor)
20059 }
20060}