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

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

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