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        array::{array_len_prefix_len, get_array_len, put_array_len},
9        fixed::{get_i16, get_i32, get_u16, put_i16, put_i32, put_u16},
10        string_bytes::{
11            compact_string_len, get_compact_string_owned, get_string_owned, put_compact_string,
12            put_string, string_len,
13        },
14        uuid::{Uuid, get_uuid, put_uuid},
15    },
16    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
17};
18pub const MIN_VERSION: i16 = 0;
19pub const MAX_VERSION: i16 = 0;
20pub const FLEXIBLE_MIN: i16 = 0;
21#[inline]
22#[must_use]
23pub fn is_flexible(version: i16) -> bool {
24    version >= FLEXIBLE_MIN
25}
26#[derive(Debug, Clone, PartialEq, Eq, Default)]
27pub struct VotersRecord {
28    pub version: i16,
29    pub voters: Vec<Voter>,
30    pub unknown_tagged_fields: UnknownTaggedFields,
31}
32impl Encode for VotersRecord {
33    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
34        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
35            return Err(ProtocolError::SchemaMismatch(
36                "VotersRecord version out of range",
37            ));
38        }
39        let flex = is_flexible(version);
40        if version >= 0 {
41            put_i16(buf, self.version);
42        }
43        if version >= 0 {
44            {
45                put_array_len(buf, (self.voters).len(), flex)?;
46                for it in &self.voters {
47                    it.encode(buf, version)?;
48                }
49            }
50        }
51        if flex {
52            let tagged = WriteTaggedFields::new();
53            tagged.write(buf, &self.unknown_tagged_fields)?;
54        }
55        Ok(())
56    }
57    fn encoded_len(&self, version: i16) -> usize {
58        let flex = is_flexible(version);
59        let mut n: usize = 0;
60        if version >= 0 {
61            n += 2;
62        }
63        if version >= 0 {
64            n += {
65                let prefix = array_len_prefix_len((self.voters).len(), flex);
66                let body: usize = (self.voters).iter().map(|it| it.encoded_len(version)).sum();
67                prefix + body
68            };
69        }
70        if flex {
71            let known_pairs: Vec<(u32, usize)> = Vec::new();
72            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
73        }
74        n
75    }
76}
77impl Decode<'_> for VotersRecord {
78    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
79        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
80            return Err(ProtocolError::SchemaMismatch(
81                "VotersRecord version out of range",
82            ));
83        }
84        let flex = is_flexible(version);
85        let mut out = Self::default();
86        if version >= 0 {
87            out.version = get_i16(buf)?;
88        }
89        if version >= 0 {
90            out.voters = {
91                let n = get_array_len(buf, flex)?;
92                let mut v = Vec::with_capacity(n);
93                for _ in 0..n {
94                    v.push(Voter::decode(buf, version)?);
95                }
96                v
97            };
98        }
99        if flex {
100            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
101        }
102        Ok(out)
103    }
104}
105#[cfg(test)]
106impl VotersRecord {
107    #[must_use]
108    pub fn populated(version: i16) -> Self {
109        let mut m = Self::default();
110        if version >= 0 {
111            m.version = 1i16;
112        }
113        if version >= 0 {
114            m.voters = vec![Voter::populated(version)];
115        }
116        m
117    }
118}
119#[derive(Debug, Clone, PartialEq, Eq, Default)]
120pub struct Voter {
121    pub voter_id: i32,
122    pub voter_directory_id: Uuid,
123    pub endpoints: Vec<Endpoint>,
124    pub k_raft_version_feature: KRaftVersionFeature,
125    pub unknown_tagged_fields: UnknownTaggedFields,
126}
127impl Encode for Voter {
128    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
129        let flex = version >= 0;
130        if version >= 0 {
131            put_i32(buf, self.voter_id);
132        }
133        if version >= 0 {
134            put_uuid(buf, self.voter_directory_id);
135        }
136        if version >= 0 {
137            {
138                put_array_len(buf, (self.endpoints).len(), flex)?;
139                for it in &self.endpoints {
140                    it.encode(buf, version)?;
141                }
142            }
143        }
144        if version >= 0 {
145            self.k_raft_version_feature.encode(buf, version)?;
146        }
147        if flex {
148            let tagged = WriteTaggedFields::new();
149            tagged.write(buf, &self.unknown_tagged_fields)?;
150        }
151        Ok(())
152    }
153    fn encoded_len(&self, version: i16) -> usize {
154        let flex = version >= 0;
155        let mut n: usize = 0;
156        if version >= 0 {
157            n += 4;
158        }
159        if version >= 0 {
160            n += 16;
161        }
162        if version >= 0 {
163            n += {
164                let prefix = 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 = get_uuid(buf)?;
191        }
192        if version >= 0 {
193            out.endpoints = {
194                let n = 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 = 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                put_compact_string(buf, &self.name)?;
244            } else {
245                put_string(buf, &self.name)?;
246            }
247        }
248        if version >= 0 {
249            if flex {
250                put_compact_string(buf, &self.host)?;
251            } else {
252                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_owned();
325        }
326        if version >= 0 {
327            m.host = "x".to_owned();
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_owned(), ::serde_json::json!(0));
409    obj.insert("voters".to_owned(), ::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
