1#![allow(clippy::useless_conversion)]
2use crate::java_binding::*;
3impl serde::Serialize for KeyRange {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if !self.left.is_empty() {
12 len += 1;
13 }
14 if !self.right.is_empty() {
15 len += 1;
16 }
17 if self.left_bound != 0 {
18 len += 1;
19 }
20 if self.right_bound != 0 {
21 len += 1;
22 }
23 let mut struct_ser = serializer.serialize_struct("java_binding.KeyRange", len)?;
24 if !self.left.is_empty() {
25 #[allow(clippy::needless_borrow)]
26 #[allow(clippy::needless_borrows_for_generic_args)]
27 struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
28 }
29 if !self.right.is_empty() {
30 #[allow(clippy::needless_borrow)]
31 #[allow(clippy::needless_borrows_for_generic_args)]
32 struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
33 }
34 if self.left_bound != 0 {
35 let v = key_range::Bound::try_from(self.left_bound)
36 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.left_bound)))?;
37 struct_ser.serialize_field("leftBound", &v)?;
38 }
39 if self.right_bound != 0 {
40 let v = key_range::Bound::try_from(self.right_bound)
41 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.right_bound)))?;
42 struct_ser.serialize_field("rightBound", &v)?;
43 }
44 struct_ser.end()
45 }
46}
47impl<'de> serde::Deserialize<'de> for KeyRange {
48 #[allow(deprecated)]
49 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
50 where
51 D: serde::Deserializer<'de>,
52 {
53 const FIELDS: &[&str] = &[
54 "left",
55 "right",
56 "left_bound",
57 "leftBound",
58 "right_bound",
59 "rightBound",
60 ];
61
62 #[allow(clippy::enum_variant_names)]
63 enum GeneratedField {
64 Left,
65 Right,
66 LeftBound,
67 RightBound,
68 }
69 impl<'de> serde::Deserialize<'de> for GeneratedField {
70 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
71 where
72 D: serde::Deserializer<'de>,
73 {
74 struct GeneratedVisitor;
75
76 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
77 type Value = GeneratedField;
78
79 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
80 write!(formatter, "expected one of: {:?}", &FIELDS)
81 }
82
83 #[allow(unused_variables)]
84 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
85 where
86 E: serde::de::Error,
87 {
88 match value {
89 "left" => Ok(GeneratedField::Left),
90 "right" => Ok(GeneratedField::Right),
91 "leftBound" | "left_bound" => Ok(GeneratedField::LeftBound),
92 "rightBound" | "right_bound" => Ok(GeneratedField::RightBound),
93 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
94 }
95 }
96 }
97 deserializer.deserialize_identifier(GeneratedVisitor)
98 }
99 }
100 struct GeneratedVisitor;
101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
102 type Value = KeyRange;
103
104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
105 formatter.write_str("struct java_binding.KeyRange")
106 }
107
108 fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
109 where
110 V: serde::de::MapAccess<'de>,
111 {
112 let mut left__ = None;
113 let mut right__ = None;
114 let mut left_bound__ = None;
115 let mut right_bound__ = None;
116 while let Some(k) = map_.next_key()? {
117 match k {
118 GeneratedField::Left => {
119 if left__.is_some() {
120 return Err(serde::de::Error::duplicate_field("left"));
121 }
122 left__ =
123 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
124 ;
125 }
126 GeneratedField::Right => {
127 if right__.is_some() {
128 return Err(serde::de::Error::duplicate_field("right"));
129 }
130 right__ =
131 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
132 ;
133 }
134 GeneratedField::LeftBound => {
135 if left_bound__.is_some() {
136 return Err(serde::de::Error::duplicate_field("leftBound"));
137 }
138 left_bound__ = Some(map_.next_value::<key_range::Bound>()? as i32);
139 }
140 GeneratedField::RightBound => {
141 if right_bound__.is_some() {
142 return Err(serde::de::Error::duplicate_field("rightBound"));
143 }
144 right_bound__ = Some(map_.next_value::<key_range::Bound>()? as i32);
145 }
146 }
147 }
148 Ok(KeyRange {
149 left: left__.unwrap_or_default(),
150 right: right__.unwrap_or_default(),
151 left_bound: left_bound__.unwrap_or_default(),
152 right_bound: right_bound__.unwrap_or_default(),
153 })
154 }
155 }
156 deserializer.deserialize_struct("java_binding.KeyRange", FIELDS, GeneratedVisitor)
157 }
158}
159impl serde::Serialize for key_range::Bound {
160 #[allow(deprecated)]
161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
162 where
163 S: serde::Serializer,
164 {
165 let variant = match self {
166 Self::Unspecified => "UNSPECIFIED",
167 Self::Unbounded => "UNBOUNDED",
168 Self::Included => "INCLUDED",
169 Self::Excluded => "EXCLUDED",
170 };
171 serializer.serialize_str(variant)
172 }
173}
174impl<'de> serde::Deserialize<'de> for key_range::Bound {
175 #[allow(deprecated)]
176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
177 where
178 D: serde::Deserializer<'de>,
179 {
180 const FIELDS: &[&str] = &[
181 "UNSPECIFIED",
182 "UNBOUNDED",
183 "INCLUDED",
184 "EXCLUDED",
185 ];
186
187 struct GeneratedVisitor;
188
189 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
190 type Value = key_range::Bound;
191
192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
193 write!(formatter, "expected one of: {:?}", &FIELDS)
194 }
195
196 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
197 where
198 E: serde::de::Error,
199 {
200 i32::try_from(v)
201 .ok()
202 .and_then(|x| x.try_into().ok())
203 .ok_or_else(|| {
204 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
205 })
206 }
207
208 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
209 where
210 E: serde::de::Error,
211 {
212 i32::try_from(v)
213 .ok()
214 .and_then(|x| x.try_into().ok())
215 .ok_or_else(|| {
216 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
217 })
218 }
219
220 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
221 where
222 E: serde::de::Error,
223 {
224 match value {
225 "UNSPECIFIED" => Ok(key_range::Bound::Unspecified),
226 "UNBOUNDED" => Ok(key_range::Bound::Unbounded),
227 "INCLUDED" => Ok(key_range::Bound::Included),
228 "EXCLUDED" => Ok(key_range::Bound::Excluded),
229 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
230 }
231 }
232 }
233 deserializer.deserialize_any(GeneratedVisitor)
234 }
235}
236impl serde::Serialize for ReadPlan {
237 #[allow(deprecated)]
238 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
239 where
240 S: serde::Serializer,
241 {
242 use serde::ser::SerializeStruct;
243 let mut len = 0;
244 if !self.object_store_url.is_empty() {
245 len += 1;
246 }
247 if !self.data_dir.is_empty() {
248 len += 1;
249 }
250 if self.key_range.is_some() {
251 len += 1;
252 }
253 if self.table_id != 0 {
254 len += 1;
255 }
256 if self.epoch != 0 {
257 len += 1;
258 }
259 if self.version.is_some() {
260 len += 1;
261 }
262 if self.table_catalog.is_some() {
263 len += 1;
264 }
265 if !self.vnode_ids.is_empty() {
266 len += 1;
267 }
268 if self.use_new_object_prefix_strategy {
269 len += 1;
270 }
271 let mut struct_ser = serializer.serialize_struct("java_binding.ReadPlan", len)?;
272 if !self.object_store_url.is_empty() {
273 struct_ser.serialize_field("objectStoreUrl", &self.object_store_url)?;
274 }
275 if !self.data_dir.is_empty() {
276 struct_ser.serialize_field("dataDir", &self.data_dir)?;
277 }
278 if let Some(v) = self.key_range.as_ref() {
279 struct_ser.serialize_field("keyRange", v)?;
280 }
281 if self.table_id != 0 {
282 struct_ser.serialize_field("tableId", &self.table_id)?;
283 }
284 if self.epoch != 0 {
285 #[allow(clippy::needless_borrow)]
286 #[allow(clippy::needless_borrows_for_generic_args)]
287 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
288 }
289 if let Some(v) = self.version.as_ref() {
290 struct_ser.serialize_field("version", v)?;
291 }
292 if let Some(v) = self.table_catalog.as_ref() {
293 struct_ser.serialize_field("tableCatalog", v)?;
294 }
295 if !self.vnode_ids.is_empty() {
296 struct_ser.serialize_field("vnodeIds", &self.vnode_ids)?;
297 }
298 if self.use_new_object_prefix_strategy {
299 struct_ser.serialize_field("useNewObjectPrefixStrategy", &self.use_new_object_prefix_strategy)?;
300 }
301 struct_ser.end()
302 }
303}
304impl<'de> serde::Deserialize<'de> for ReadPlan {
305 #[allow(deprecated)]
306 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
307 where
308 D: serde::Deserializer<'de>,
309 {
310 const FIELDS: &[&str] = &[
311 "object_store_url",
312 "objectStoreUrl",
313 "data_dir",
314 "dataDir",
315 "key_range",
316 "keyRange",
317 "table_id",
318 "tableId",
319 "epoch",
320 "version",
321 "table_catalog",
322 "tableCatalog",
323 "vnode_ids",
324 "vnodeIds",
325 "use_new_object_prefix_strategy",
326 "useNewObjectPrefixStrategy",
327 ];
328
329 #[allow(clippy::enum_variant_names)]
330 enum GeneratedField {
331 ObjectStoreUrl,
332 DataDir,
333 KeyRange,
334 TableId,
335 Epoch,
336 Version,
337 TableCatalog,
338 VnodeIds,
339 UseNewObjectPrefixStrategy,
340 }
341 impl<'de> serde::Deserialize<'de> for GeneratedField {
342 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
343 where
344 D: serde::Deserializer<'de>,
345 {
346 struct GeneratedVisitor;
347
348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
349 type Value = GeneratedField;
350
351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
352 write!(formatter, "expected one of: {:?}", &FIELDS)
353 }
354
355 #[allow(unused_variables)]
356 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
357 where
358 E: serde::de::Error,
359 {
360 match value {
361 "objectStoreUrl" | "object_store_url" => Ok(GeneratedField::ObjectStoreUrl),
362 "dataDir" | "data_dir" => Ok(GeneratedField::DataDir),
363 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
364 "tableId" | "table_id" => Ok(GeneratedField::TableId),
365 "epoch" => Ok(GeneratedField::Epoch),
366 "version" => Ok(GeneratedField::Version),
367 "tableCatalog" | "table_catalog" => Ok(GeneratedField::TableCatalog),
368 "vnodeIds" | "vnode_ids" => Ok(GeneratedField::VnodeIds),
369 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
371 }
372 }
373 }
374 deserializer.deserialize_identifier(GeneratedVisitor)
375 }
376 }
377 struct GeneratedVisitor;
378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
379 type Value = ReadPlan;
380
381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
382 formatter.write_str("struct java_binding.ReadPlan")
383 }
384
385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReadPlan, V::Error>
386 where
387 V: serde::de::MapAccess<'de>,
388 {
389 let mut object_store_url__ = None;
390 let mut data_dir__ = None;
391 let mut key_range__ = None;
392 let mut table_id__ = None;
393 let mut epoch__ = None;
394 let mut version__ = None;
395 let mut table_catalog__ = None;
396 let mut vnode_ids__ = None;
397 let mut use_new_object_prefix_strategy__ = None;
398 while let Some(k) = map_.next_key()? {
399 match k {
400 GeneratedField::ObjectStoreUrl => {
401 if object_store_url__.is_some() {
402 return Err(serde::de::Error::duplicate_field("objectStoreUrl"));
403 }
404 object_store_url__ = Some(map_.next_value()?);
405 }
406 GeneratedField::DataDir => {
407 if data_dir__.is_some() {
408 return Err(serde::de::Error::duplicate_field("dataDir"));
409 }
410 data_dir__ = Some(map_.next_value()?);
411 }
412 GeneratedField::KeyRange => {
413 if key_range__.is_some() {
414 return Err(serde::de::Error::duplicate_field("keyRange"));
415 }
416 key_range__ = map_.next_value()?;
417 }
418 GeneratedField::TableId => {
419 if table_id__.is_some() {
420 return Err(serde::de::Error::duplicate_field("tableId"));
421 }
422 table_id__ =
423 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
424 ;
425 }
426 GeneratedField::Epoch => {
427 if epoch__.is_some() {
428 return Err(serde::de::Error::duplicate_field("epoch"));
429 }
430 epoch__ =
431 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
432 ;
433 }
434 GeneratedField::Version => {
435 if version__.is_some() {
436 return Err(serde::de::Error::duplicate_field("version"));
437 }
438 version__ = map_.next_value()?;
439 }
440 GeneratedField::TableCatalog => {
441 if table_catalog__.is_some() {
442 return Err(serde::de::Error::duplicate_field("tableCatalog"));
443 }
444 table_catalog__ = map_.next_value()?;
445 }
446 GeneratedField::VnodeIds => {
447 if vnode_ids__.is_some() {
448 return Err(serde::de::Error::duplicate_field("vnodeIds"));
449 }
450 vnode_ids__ =
451 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
452 .into_iter().map(|x| x.0).collect())
453 ;
454 }
455 GeneratedField::UseNewObjectPrefixStrategy => {
456 if use_new_object_prefix_strategy__.is_some() {
457 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
458 }
459 use_new_object_prefix_strategy__ = Some(map_.next_value()?);
460 }
461 }
462 }
463 Ok(ReadPlan {
464 object_store_url: object_store_url__.unwrap_or_default(),
465 data_dir: data_dir__.unwrap_or_default(),
466 key_range: key_range__,
467 table_id: table_id__.unwrap_or_default(),
468 epoch: epoch__.unwrap_or_default(),
469 version: version__,
470 table_catalog: table_catalog__,
471 vnode_ids: vnode_ids__.unwrap_or_default(),
472 use_new_object_prefix_strategy: use_new_object_prefix_strategy__.unwrap_or_default(),
473 })
474 }
475 }
476 deserializer.deserialize_struct("java_binding.ReadPlan", FIELDS, GeneratedVisitor)
477 }
478}