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

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

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