krabka_protocol/opt/rustwide/workdir/generated/
VoteResponse.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    codegen_helpers::is_default,
8    primitives::{
9        array::{array_len_prefix_len, get_array_len, put_array_len},
10        fixed::{get_bool, get_i16, get_i32, get_u16, put_bool, put_i16, put_i32, put_u16},
11        string_bytes::{
12            compact_string_len, get_compact_string_owned, get_string_owned, put_compact_string,
13            put_string, string_len,
14        },
15    },
16    tagged_fields::{WriteTaggedFields, encode_to_bytes, read_tagged_fields, tagged_fields_len},
17};
18pub const API_KEY: i16 = 52;
19pub const MIN_VERSION: i16 = 0;
20pub const MAX_VERSION: i16 = 2;
21pub const FLEXIBLE_MIN: i16 = 0;
22#[inline]
23#[must_use]
24pub fn is_flexible(version: i16) -> bool {
25    version >= FLEXIBLE_MIN
26}
27#[derive(Debug, Clone, PartialEq, Eq, Default)]
28pub struct VoteResponse {
29    pub error_code: i16,
30    pub topics: Vec<TopicData>,
31    pub node_endpoints: Vec<NodeEndpoint>,
32    pub unknown_tagged_fields: UnknownTaggedFields,
33}
34impl Encode for VoteResponse {
35    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
36        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
37            return Err(ProtocolError::UnsupportedVersion {
38                api_key: API_KEY,
39                version,
40            });
41        }
42        let flex = is_flexible(version);
43        if version >= 0 {
44            put_i16(buf, self.error_code);
45        }
46        if version >= 0 {
47            {
48                put_array_len(buf, (self.topics).len(), flex)?;
49                for it in &self.topics {
50                    it.encode(buf, version)?;
51                }
52            }
53        }
54        if flex {
55            let mut tagged = WriteTaggedFields::new();
56            if version >= 1 && !(is_default(&self.node_endpoints)) {
57                let payload = encode_to_bytes(
58                    {
59                        let prefix = array_len_prefix_len((self.node_endpoints).len(), flex);
60                        let body: usize = (self.node_endpoints)
61                            .iter()
62                            .map(|it| it.encoded_len(version))
63                            .sum();
64                        prefix + body
65                    },
66                    |b| {
67                        {
68                            put_array_len(b, (self.node_endpoints).len(), flex)?;
69                            for it in &self.node_endpoints {
70                                it.encode(b, version)?;
71                            }
72                        }
73                        Ok(())
74                    },
75                )?;
76                tagged.add(0, payload);
77            }
78            tagged.write(buf, &self.unknown_tagged_fields)?;
79        }
80        Ok(())
81    }
82    fn encoded_len(&self, version: i16) -> usize {
83        let flex = is_flexible(version);
84        let mut n: usize = 0;
85        if version >= 0 {
86            n += 2;
87        }
88        if version >= 0 {
89            n += {
90                let prefix = array_len_prefix_len((self.topics).len(), flex);
91                let body: usize = (self.topics).iter().map(|it| it.encoded_len(version)).sum();
92                prefix + body
93            };
94        }
95        if flex {
96            let mut known_pairs: Vec<(u32, usize)> = Vec::new();
97            if version >= 1 && !(is_default(&self.node_endpoints)) {
98                known_pairs.push((0, {
99                    let prefix = array_len_prefix_len((self.node_endpoints).len(), flex);
100                    let body: usize = (self.node_endpoints)
101                        .iter()
102                        .map(|it| it.encoded_len(version))
103                        .sum();
104                    prefix + body
105                }));
106            }
107            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
108        }
109        n
110    }
111}
112impl Decode<'_> for VoteResponse {
113    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
114        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
115            return Err(ProtocolError::UnsupportedVersion {
116                api_key: API_KEY,
117                version,
118            });
119        }
120        let flex = is_flexible(version);
121        let mut out = Self::default();
122        if version >= 0 {
123            out.error_code = get_i16(buf)?;
124        }
125        if version >= 0 {
126            out.topics = {
127                let n = get_array_len(buf, flex)?;
128                let mut v = Vec::with_capacity(n);
129                for _ in 0..n {
130                    v.push(TopicData::decode(buf, version)?);
131                }
132                v
133            };
134        }
135        if flex {
136            let mut tag_node_endpoints = None;
137            out.unknown_tagged_fields = read_tagged_fields(buf, |tag, payload| match tag {
138                0 if version >= 1 => {
139                    tag_node_endpoints = Some({
140                        let b: &mut &[u8] = payload;
141                        {
142                            let n = get_array_len(b, flex)?;
143                            let mut v = Vec::with_capacity(n);
144                            for _ in 0..n {
145                                v.push(NodeEndpoint::decode(b, version)?);
146                            }
147                            v
148                        }
149                    });
150                    Ok(true)
151                }
152                0 => Err(ProtocolError::TagNotValidForVersion { tag: 0, version }),
153                _ => Ok(false),
154            })?;
155            if let Some(v) = tag_node_endpoints {
156                out.node_endpoints = v;
157            }
158        }
159        Ok(out)
160    }
161}
162#[cfg(test)]
163impl VoteResponse {
164    #[must_use]
165    pub fn populated(version: i16) -> Self {
166        let mut m = Self::default();
167        if version >= 0 {
168            m.error_code = 1i16;
169        }
170        if version >= 0 {
171            m.topics = vec![TopicData::populated(version)];
172        }
173        if version >= 1 {
174            m.node_endpoints = vec![NodeEndpoint::populated(version)];
175        }
176        m
177    }
178}
179#[derive(Debug, Clone, PartialEq, Eq, Default)]
180pub struct TopicData {
181    pub topic_name: String,
182    pub partitions: Vec<PartitionData>,
183    pub unknown_tagged_fields: UnknownTaggedFields,
184}
185impl Encode for TopicData {
186    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
187        let flex = version >= 0;
188        if version >= 0 {
189            if flex {
190                put_compact_string(buf, &self.topic_name)?;
191            } else {
192                put_string(buf, &self.topic_name)?;
193            }
194        }
195        if version >= 0 {
196            {
197                put_array_len(buf, (self.partitions).len(), flex)?;
198                for it in &self.partitions {
199                    it.encode(buf, version)?;
200                }
201            }
202        }
203        if flex {
204            let tagged = WriteTaggedFields::new();
205            tagged.write(buf, &self.unknown_tagged_fields)?;
206        }
207        Ok(())
208    }
209    fn encoded_len(&self, version: i16) -> usize {
210        let flex = version >= 0;
211        let mut n: usize = 0;
212        if version >= 0 {
213            n += if flex {
214                compact_string_len(&self.topic_name)
215            } else {
216                string_len(&self.topic_name)
217            };
218        }
219        if version >= 0 {
220            n += {
221                let prefix = array_len_prefix_len((self.partitions).len(), flex);
222                let body: usize = (self.partitions)
223                    .iter()
224                    .map(|it| it.encoded_len(version))
225                    .sum();
226                prefix + body
227            };
228        }
229        if flex {
230            let known_pairs: Vec<(u32, usize)> = Vec::new();
231            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
232        }
233        n
234    }
235}
236impl Decode<'_> for TopicData {
237    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
238        let flex = version >= 0;
239        let mut out = Self::default();
240        if version >= 0 {
241            out.topic_name = if flex {
242                get_compact_string_owned(buf)?
243            } else {
244                get_string_owned(buf)?
245            };
246        }
247        if version >= 0 {
248            out.partitions = {
249                let n = get_array_len(buf, flex)?;
250                let mut v = Vec::with_capacity(n);
251                for _ in 0..n {
252                    v.push(PartitionData::decode(buf, version)?);
253                }
254                v
255            };
256        }
257        if flex {
258            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
259        }
260        Ok(out)
261    }
262}
263#[cfg(test)]
264impl TopicData {
265    #[must_use]
266    pub fn populated(version: i16) -> Self {
267        let mut m = Self::default();
268        if version >= 0 {
269            m.topic_name = "x".to_owned();
270        }
271        if version >= 0 {
272            m.partitions = vec![PartitionData::populated(version)];
273        }
274        m
275    }
276}
277#[derive(Debug, Clone, PartialEq, Eq, Default)]
278pub struct PartitionData {
279    pub partition_index: i32,
280    pub error_code: i16,
281    pub leader_id: i32,
282    pub leader_epoch: i32,
283    pub vote_granted: bool,
284    pub unknown_tagged_fields: UnknownTaggedFields,
285}
286impl Encode for PartitionData {
287    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
288        let flex = version >= 0;
289        if version >= 0 {
290            put_i32(buf, self.partition_index);
291        }
292        if version >= 0 {
293            put_i16(buf, self.error_code);
294        }
295        if version >= 0 {
296            put_i32(buf, self.leader_id);
297        }
298        if version >= 0 {
299            put_i32(buf, self.leader_epoch);
300        }
301        if version >= 0 {
302            put_bool(buf, self.vote_granted);
303        }
304        if flex {
305            let tagged = WriteTaggedFields::new();
306            tagged.write(buf, &self.unknown_tagged_fields)?;
307        }
308        Ok(())
309    }
310    fn encoded_len(&self, version: i16) -> usize {
311        let flex = version >= 0;
312        let mut n: usize = 0;
313        if version >= 0 {
314            n += 4;
315        }
316        if version >= 0 {
317            n += 2;
318        }
319        if version >= 0 {
320            n += 4;
321        }
322        if version >= 0 {
323            n += 4;
324        }
325        if version >= 0 {
326            n += 1;
327        }
328        if flex {
329            let known_pairs: Vec<(u32, usize)> = Vec::new();
330            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
331        }
332        n
333    }
334}
335impl Decode<'_> for PartitionData {
336    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
337        let flex = version >= 0;
338        let mut out = Self::default();
339        if version >= 0 {
340            out.partition_index = get_i32(buf)?;
341        }
342        if version >= 0 {
343            out.error_code = get_i16(buf)?;
344        }
345        if version >= 0 {
346            out.leader_id = get_i32(buf)?;
347        }
348        if version >= 0 {
349            out.leader_epoch = get_i32(buf)?;
350        }
351        if version >= 0 {
352            out.vote_granted = get_bool(buf)?;
353        }
354        if flex {
355            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
356        }
357        Ok(out)
358    }
359}
360#[cfg(test)]
361impl PartitionData {
362    #[must_use]
363    pub fn populated(version: i16) -> Self {
364        let mut m = Self::default();
365        if version >= 0 {
366            m.partition_index = 1i32;
367        }
368        if version >= 0 {
369            m.error_code = 1i16;
370        }
371        if version >= 0 {
372            m.leader_id = 1i32;
373        }
374        if version >= 0 {
375            m.leader_epoch = 1i32;
376        }
377        if version >= 0 {
378            m.vote_granted = true;
379        }
380        m
381    }
382}
383#[derive(Debug, Clone, PartialEq, Eq, Default)]
384pub struct NodeEndpoint {
385    pub node_id: i32,
386    pub host: String,
387    pub port: u16,
388    pub unknown_tagged_fields: UnknownTaggedFields,
389}
390impl Encode for NodeEndpoint {
391    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
392        let flex = version >= 0;
393        if version >= 1 {
394            put_i32(buf, self.node_id);
395        }
396        if version >= 1 {
397            if flex {
398                put_compact_string(buf, &self.host)?;
399            } else {
400                put_string(buf, &self.host)?;
401            }
402        }
403        if version >= 1 {
404            put_u16(buf, self.port);
405        }
406        if flex {
407            let tagged = WriteTaggedFields::new();
408            tagged.write(buf, &self.unknown_tagged_fields)?;
409        }
410        Ok(())
411    }
412    fn encoded_len(&self, version: i16) -> usize {
413        let flex = version >= 0;
414        let mut n: usize = 0;
415        if version >= 1 {
416            n += 4;
417        }
418        if version >= 1 {
419            n += if flex {
420                compact_string_len(&self.host)
421            } else {
422                string_len(&self.host)
423            };
424        }
425        if version >= 1 {
426            n += 2;
427        }
428        if flex {
429            let known_pairs: Vec<(u32, usize)> = Vec::new();
430            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
431        }
432        n
433    }
434}
435impl Decode<'_> for NodeEndpoint {
436    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
437        let flex = version >= 0;
438        let mut out = Self::default();
439        if version >= 1 {
440            out.node_id = get_i32(buf)?;
441        }
442        if version >= 1 {
443            out.host = if flex {
444                get_compact_string_owned(buf)?
445            } else {
446                get_string_owned(buf)?
447            };
448        }
449        if version >= 1 {
450            out.port = get_u16(buf)?;
451        }
452        if flex {
453            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
454        }
455        Ok(out)
456    }
457}
458#[cfg(test)]
459impl NodeEndpoint {
460    #[must_use]
461    pub fn populated(version: i16) -> Self {
462        let mut m = Self::default();
463        if version >= 1 {
464            m.node_id = 1i32;
465        }
466        if version >= 1 {
467            m.host = "x".to_owned();
468        }
469        if version >= 1 {
470            m.port = 1u16;
471        }
472        m
473    }
474}
475/// Default JSON payload matching `Self::default()` for JVM oracle differential testing.
476/// Only includes fields valid for the given version.
477#[must_use]
478#[allow(unused_comparisons)]
479pub fn default_json(version: i16) -> ::serde_json::Value {
480    let mut obj = ::serde_json::Map::new();
481    obj.insert("errorCode".to_owned(), ::serde_json::json!(0));
482    obj.insert("topics".to_owned(), ::serde_json::Value::Array(vec![]));
483    if version >= 1 {
484        obj.insert(
485            "nodeEndpoints".to_owned(),
486            ::serde_json::Value::Array(vec![]),
487        );
488    }
489    ::serde_json::Value::Object(obj)
490}
491/// A message with a non-default value in every tagged field, at every depth, for
492/// the JVM oracle differential sweep. The value is the same at every version.
493#[must_use]
494pub fn tagged_fixture() -> VoteResponse {
495    VoteResponse {
496        node_endpoints: vec![NodeEndpoint {
497            node_id: 1i32,
498            host: "x".to_owned(),
499            port: 1u16,
500            ..NodeEndpoint::default()
501        }],
502        ..VoteResponse::default()
503    }
504}
505/// The JSON form of `tagged_fixture()` that Kafka's JSON converter reads at
506/// `version`. It holds only the fields that the schema declares at that version.
507#[must_use]
508pub fn tagged_fixture_json(version: i16) -> ::serde_json::Value {
509    let mut m = ::serde_json::Map::new();
510    m.insert("errorCode".to_owned(), ::serde_json::json!(0));
511    m.insert("topics".to_owned(), ::serde_json::Value::Array(vec![]));
512    if version >= 1 {
513        m.insert(
514            "nodeEndpoints".to_owned(),
515            ::serde_json::Value::Array(vec![{
516                let mut m = ::serde_json::Map::new();
517                m.insert("nodeId".to_owned(), ::serde_json::json!(1));
518                m.insert(
519                    "host".to_owned(),
520                    ::serde_json::Value::String("x".to_owned()),
521                );
522                m.insert("port".to_owned(), ::serde_json::json!(1));
523                ::serde_json::Value::Object(m)
524            }]),
525        );
526    }
527    ::serde_json::Value::Object(m)
528}
krabka_protocol/opt/rustwide/workdir/generated/VoteResponse.owned.rs

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