krabka_protocol/opt/rustwide/workdir/generated/
VotersRecord.owned.rs

1// AUTO-GENERATED by krabka-protocol-codegen against a9ce3221537b8653448750697915607dc7936cf3. Do not edit.
2
3use bytes::{Buf, BufMut};
4
5use crate::{
6    Decode, Encode, ProtocolError, UnknownTaggedFields,
7    primitives::{
8        fixed::{get_i16, get_i32, get_u16, put_i16, put_i32, put_u16},
9        string_bytes::{
10            compact_string_len, get_compact_string_owned, get_string_owned, put_compact_string,
11            put_string, string_len,
12        },
13    },
14    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
15};
16pub const MIN_VERSION: i16 = 0;
17pub const MAX_VERSION: i16 = 0;
18pub const FLEXIBLE_MIN: i16 = 0;
19#[inline]
20#[must_use]
21pub fn is_flexible(version: i16) -> bool {
22    version >= FLEXIBLE_MIN
23}
24#[derive(Debug, Clone, PartialEq, Eq, Default)]
25pub struct VotersRecord {
26    pub version: i16,
27    pub voters: Vec<Voter>,
28    pub unknown_tagged_fields: UnknownTaggedFields,
29}
30impl Encode for VotersRecord {
31    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
32        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
33            return Err(ProtocolError::SchemaMismatch(
34                "VotersRecord version out of range",
35            ));
36        }
37        let flex = is_flexible(version);
38        if version >= 0 {
39            put_i16(buf, self.version);
40        }
41        if version >= 0 {
42            {
43                crate::primitives::array::put_array_len(buf, (self.voters).len(), flex);
44                for it in &self.voters {
45                    it.encode(buf, version)?;
46                }
47            };
48        }
49        if flex {
50            let tagged = WriteTaggedFields::new();
51            tagged.write(buf, &self.unknown_tagged_fields);
52        }
53        Ok(())
54    }
55    fn encoded_len(&self, version: i16) -> usize {
56        let flex = is_flexible(version);
57        let mut n: usize = 0;
58        if version >= 0 {
59            n += 2;
60        }
61        if version >= 0 {
62            n += {
63                let prefix =
64                    crate::primitives::array::array_len_prefix_len((self.voters).len(), flex);
65                let body: usize = (self.voters).iter().map(|it| it.encoded_len(version)).sum();
66                prefix + body
67            };
68        }
69        if flex {
70            let known_pairs: Vec<(u32, usize)> = Vec::new();
71            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
72        }
73        n
74    }
75}
76impl Decode<'_> for VotersRecord {
77    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
78        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
79            return Err(ProtocolError::SchemaMismatch(
80                "VotersRecord version out of range",
81            ));
82        }
83        let flex = is_flexible(version);
84        let mut out = Self::default();
85        if version >= 0 {
86            out.version = get_i16(buf)?;
87        }
88        if version >= 0 {
89            out.voters = {
90                let n = crate::primitives::array::get_array_len(buf, flex)?;
91                let mut v = Vec::with_capacity(n);
92                for _ in 0..n {
93                    v.push(Voter::decode(buf, version)?);
94                }
95                v
96            };
97        }
98        if flex {
99            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
100        }
101        Ok(out)
102    }
103}
104#[cfg(test)]
105impl VotersRecord {
106    #[must_use]
107    pub fn populated(version: i16) -> Self {
108        let mut m = Self::default();
109        if version >= 0 {
110            m.version = 1i16;
111        }
112        if version >= 0 {
113            m.voters = vec![Voter::populated(version)];
114        }
115        m
116    }
117}
118#[derive(Debug, Clone, PartialEq, Eq, Default)]
119pub struct Voter {
120    pub voter_id: i32,
121    pub voter_directory_id: crate::primitives::uuid::Uuid,
122    pub endpoints: Vec<Endpoint>,
123    pub k_raft_version_feature: KRaftVersionFeature,
124    pub unknown_tagged_fields: UnknownTaggedFields,
125}
126impl Encode for Voter {
127    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
128        let flex = version >= 0;
129        if version >= 0 {
130            put_i32(buf, self.voter_id);
131        }
132        if version >= 0 {
133            crate::primitives::uuid::put_uuid(buf, self.voter_directory_id);
134        }
135        if version >= 0 {
136            {
137                crate::primitives::array::put_array_len(buf, (self.endpoints).len(), flex);
138                for it in &self.endpoints {
139                    it.encode(buf, version)?;
140                }
141            };
142        }
143        if version >= 0 {
144            self.k_raft_version_feature.encode(buf, version)?;
145        }
146        if flex {
147            let tagged = WriteTaggedFields::new();
148            tagged.write(buf, &self.unknown_tagged_fields);
149        }
150        Ok(())
151    }
152    fn encoded_len(&self, version: i16) -> usize {
153        let flex = version >= 0;
154        let mut n: usize = 0;
155        if version >= 0 {
156            n += 4;
157        }
158        if version >= 0 {
159            n += 16;
160        }
161        if version >= 0 {
162            n += {
163                let prefix =
164                    crate::primitives::array::array_len_prefix_len((self.endpoints).len(), flex);
165                let body: usize = (self.endpoints)
166                    .iter()
167                    .map(|it| it.encoded_len(version))
168                    .sum();
169                prefix + body
170            };
171        }
172        if version >= 0 {
173            n += self.k_raft_version_feature.encoded_len(version);
174        }
175        if flex {
176            let known_pairs: Vec<(u32, usize)> = Vec::new();
177            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
178        }
179        n
180    }
181}
182impl Decode<'_> for Voter {
183    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
184        let flex = version >= 0;
185        let mut out = Self::default();
186        if version >= 0 {
187            out.voter_id = get_i32(buf)?;
188        }
189        if version >= 0 {
190            out.voter_directory_id = crate::primitives::uuid::get_uuid(buf)?;
191        }
192        if version >= 0 {
193            out.endpoints = {
194                let n = crate::primitives::array::get_array_len(buf, flex)?;
195                let mut v = Vec::with_capacity(n);
196                for _ in 0..n {
197                    v.push(Endpoint::decode(buf, version)?);
198                }
199                v
200            };
201        }
202        if version >= 0 {
203            out.k_raft_version_feature = KRaftVersionFeature::decode(buf, version)?;
204        }
205        if flex {
206            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
207        }
208        Ok(out)
209    }
210}
211#[cfg(test)]
212impl Voter {
213    #[must_use]
214    pub fn populated(version: i16) -> Self {
215        let mut m = Self::default();
216        if version >= 0 {
217            m.voter_id = 1i32;
218        }
219        if version >= 0 {
220            m.voter_directory_id = crate::primitives::uuid::Uuid([1u8; 16]);
221        }
222        if version >= 0 {
223            m.endpoints = vec![Endpoint::populated(version)];
224        }
225        if version >= 0 {
226            m.k_raft_version_feature = KRaftVersionFeature::populated(version);
227        }
228        m
229    }
230}
231#[derive(Debug, Clone, PartialEq, Eq, Default)]
232pub struct Endpoint {
233    pub name: String,
234    pub host: String,
235    pub port: u16,
236    pub unknown_tagged_fields: UnknownTaggedFields,
237}
238impl Encode for Endpoint {
239    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
240        let flex = version >= 0;
241        if version >= 0 {
242            if flex {
243                let () = put_compact_string(buf, &self.name);
244            } else {
245                let () = put_string(buf, &self.name);
246            }
247        }
248        if version >= 0 {
249            if flex {
250                let () = put_compact_string(buf, &self.host);
251            } else {
252                let () = put_string(buf, &self.host);
253            }
254        }
255        if version >= 0 {
256            put_u16(buf, self.port);
257        }
258        if flex {
259            let tagged = WriteTaggedFields::new();
260            tagged.write(buf, &self.unknown_tagged_fields);
261        }
262        Ok(())
263    }
264    fn encoded_len(&self, version: i16) -> usize {
265        let flex = version >= 0;
266        let mut n: usize = 0;
267        if version >= 0 {
268            n += if flex {
269                compact_string_len(&self.name)
270            } else {
271                string_len(&self.name)
272            };
273        }
274        if version >= 0 {
275            n += if flex {
276                compact_string_len(&self.host)
277            } else {
278                string_len(&self.host)
279            };
280        }
281        if version >= 0 {
282            n += 2;
283        }
284        if flex {
285            let known_pairs: Vec<(u32, usize)> = Vec::new();
286            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
287        }
288        n
289    }
290}
291impl Decode<'_> for Endpoint {
292    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
293        let flex = version >= 0;
294        let mut out = Self::default();
295        if version >= 0 {
296            out.name = if flex {
297                get_compact_string_owned(buf)?
298            } else {
299                get_string_owned(buf)?
300            };
301        }
302        if version >= 0 {
303            out.host = if flex {
304                get_compact_string_owned(buf)?
305            } else {
306                get_string_owned(buf)?
307            };
308        }
309        if version >= 0 {
310            out.port = get_u16(buf)?;
311        }
312        if flex {
313            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
314        }
315        Ok(out)
316    }
317}
318#[cfg(test)]
319impl Endpoint {
320    #[must_use]
321    pub fn populated(version: i16) -> Self {
322        let mut m = Self::default();
323        if version >= 0 {
324            m.name = "x".to_string();
325        }
326        if version >= 0 {
327            m.host = "x".to_string();
328        }
329        if version >= 0 {
330            m.port = 1u16;
331        }
332        m
333    }
334}
335#[derive(Debug, Clone, PartialEq, Eq, Default)]
336pub struct KRaftVersionFeature {
337    pub min_supported_version: i16,
338    pub max_supported_version: i16,
339    pub unknown_tagged_fields: UnknownTaggedFields,
340}
341impl Encode for KRaftVersionFeature {
342    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
343        let flex = version >= 0;
344        if version >= 0 {
345            put_i16(buf, self.min_supported_version);
346        }
347        if version >= 0 {
348            put_i16(buf, self.max_supported_version);
349        }
350        if flex {
351            let tagged = WriteTaggedFields::new();
352            tagged.write(buf, &self.unknown_tagged_fields);
353        }
354        Ok(())
355    }
356    fn encoded_len(&self, version: i16) -> usize {
357        let flex = version >= 0;
358        let mut n: usize = 0;
359        if version >= 0 {
360            n += 2;
361        }
362        if version >= 0 {
363            n += 2;
364        }
365        if flex {
366            let known_pairs: Vec<(u32, usize)> = Vec::new();
367            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
368        }
369        n
370    }
371}
372impl Decode<'_> for KRaftVersionFeature {
373    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
374        let flex = version >= 0;
375        let mut out = Self::default();
376        if version >= 0 {
377            out.min_supported_version = get_i16(buf)?;
378        }
379        if version >= 0 {
380            out.max_supported_version = get_i16(buf)?;
381        }
382        if flex {
383            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
384        }
385        Ok(out)
386    }
387}
388#[cfg(test)]
389impl KRaftVersionFeature {
390    #[must_use]
391    pub fn populated(version: i16) -> Self {
392        let mut m = Self::default();
393        if version >= 0 {
394            m.min_supported_version = 1i16;
395        }
396        if version >= 0 {
397            m.max_supported_version = 1i16;
398        }
399        m
400    }
401}
402/// Default JSON payload matching `Self::default()` for JVM oracle differential testing.
403/// Only includes fields valid for the given version.
404#[must_use]
405#[allow(unused_comparisons)]
406pub fn default_json(_version: i16) -> ::serde_json::Value {
407    let mut obj = ::serde_json::Map::new();
408    obj.insert("version".to_string(), ::serde_json::json!(0));
409    obj.insert("voters".to_string(), ::serde_json::Value::Array(vec![]));
410    ::serde_json::Value::Object(obj)
411}
krabka_protocol/opt/rustwide/workdir/generated/VotersRecord.owned.rs

krabka_protocol/opt/rustwide/workdir/generated/
VotersRecord.owned.rs
