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

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

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