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

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

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