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