krabka_protocol/opt/rustwide/workdir/generated/
EndQuorumEpochResponse.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_i16, get_i32, get_u16, 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 = 54;
19pub const MIN_VERSION: i16 = 0;
20pub const MAX_VERSION: i16 = 1;
21pub const FLEXIBLE_MIN: i16 = 1;
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 EndQuorumEpochResponse {
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 EndQuorumEpochResponse {
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 !(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 !(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 EndQuorumEpochResponse {
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 => {
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                _ => Ok(false),
153            })?;
154            if let Some(v) = tag_node_endpoints {
155                out.node_endpoints = v;
156            }
157        }
158        Ok(out)
159    }
160}
161#[cfg(test)]
162impl EndQuorumEpochResponse {
163    #[must_use]
164    pub fn populated(version: i16) -> Self {
165        let mut m = Self::default();
166        if version >= 0 {
167            m.error_code = 1i16;
168        }
169        if version >= 0 {
170            m.topics = vec![TopicData::populated(version)];
171        }
172        if version >= 1 {
173            m.node_endpoints = vec![NodeEndpoint::populated(version)];
174        }
175        m
176    }
177}
178#[derive(Debug, Clone, PartialEq, Eq, Default)]
179pub struct TopicData {
180    pub topic_name: String,
181    pub partitions: Vec<PartitionData>,
182    pub unknown_tagged_fields: UnknownTaggedFields,
183}
184impl Encode for TopicData {
185    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
186        let flex = version >= 1;
187        if version >= 0 {
188            if flex {
189                put_compact_string(buf, &self.topic_name)?;
190            } else {
191                put_string(buf, &self.topic_name)?;
192            }
193        }
194        if version >= 0 {
195            {
196                put_array_len(buf, (self.partitions).len(), flex)?;
197                for it in &self.partitions {
198                    it.encode(buf, version)?;
199                }
200            }
201        }
202        if flex {
203            let tagged = WriteTaggedFields::new();
204            tagged.write(buf, &self.unknown_tagged_fields)?;
205        }
206        Ok(())
207    }
208    fn encoded_len(&self, version: i16) -> usize {
209        let flex = version >= 1;
210        let mut n: usize = 0;
211        if version >= 0 {
212            n += if flex {
213                compact_string_len(&self.topic_name)
214            } else {
215                string_len(&self.topic_name)
216            };
217        }
218        if version >= 0 {
219            n += {
220                let prefix = array_len_prefix_len((self.partitions).len(), flex);
221                let body: usize = (self.partitions)
222                    .iter()
223                    .map(|it| it.encoded_len(version))
224                    .sum();
225                prefix + body
226            };
227        }
228        if flex {
229            let known_pairs: Vec<(u32, usize)> = Vec::new();
230            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
231        }
232        n
233    }
234}
235impl Decode<'_> for TopicData {
236    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
237        let flex = version >= 1;
238        let mut out = Self::default();
239        if version >= 0 {
240            out.topic_name = if flex {
241                get_compact_string_owned(buf)?
242            } else {
243                get_string_owned(buf)?
244            };
245        }
246        if version >= 0 {
247            out.partitions = {
248                let n = get_array_len(buf, flex)?;
249                let mut v = Vec::with_capacity(n);
250                for _ in 0..n {
251                    v.push(PartitionData::decode(buf, version)?);
252                }
253                v
254            };
255        }
256        if flex {
257            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
258        }
259        Ok(out)
260    }
261}
262#[cfg(test)]
263impl TopicData {
264    #[must_use]
265    pub fn populated(version: i16) -> Self {
266        let mut m = Self::default();
267        if version >= 0 {
268            m.topic_name = "x".to_owned();
269        }
270        if version >= 0 {
271            m.partitions = vec![PartitionData::populated(version)];
272        }
273        m
274    }
275}
276#[derive(Debug, Clone, PartialEq, Eq, Default)]
277pub struct PartitionData {
278    pub partition_index: i32,
279    pub error_code: i16,
280    pub leader_id: i32,
281    pub leader_epoch: i32,
282    pub unknown_tagged_fields: UnknownTaggedFields,
283}
284impl Encode for PartitionData {
285    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
286        let flex = version >= 1;
287        if version >= 0 {
288            put_i32(buf, self.partition_index);
289        }
290        if version >= 0 {
291            put_i16(buf, self.error_code);
292        }
293        if version >= 0 {
294            put_i32(buf, self.leader_id);
295        }
296        if version >= 0 {
297            put_i32(buf, self.leader_epoch);
298        }
299        if flex {
300            let tagged = WriteTaggedFields::new();
301            tagged.write(buf, &self.unknown_tagged_fields)?;
302        }
303        Ok(())
304    }
305    fn encoded_len(&self, version: i16) -> usize {
306        let flex = version >= 1;
307        let mut n: usize = 0;
308        if version >= 0 {
309            n += 4;
310        }
311        if version >= 0 {
312            n += 2;
313        }
314        if version >= 0 {
315            n += 4;
316        }
317        if version >= 0 {
318            n += 4;
319        }
320        if flex {
321            let known_pairs: Vec<(u32, usize)> = Vec::new();
322            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
323        }
324        n
325    }
326}
327impl Decode<'_> for PartitionData {
328    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
329        let flex = version >= 1;
330        let mut out = Self::default();
331        if version >= 0 {
332            out.partition_index = get_i32(buf)?;
333        }
334        if version >= 0 {
335            out.error_code = get_i16(buf)?;
336        }
337        if version >= 0 {
338            out.leader_id = get_i32(buf)?;
339        }
340        if version >= 0 {
341            out.leader_epoch = get_i32(buf)?;
342        }
343        if flex {
344            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
345        }
346        Ok(out)
347    }
348}
349#[cfg(test)]
350impl PartitionData {
351    #[must_use]
352    pub fn populated(version: i16) -> Self {
353        let mut m = Self::default();
354        if version >= 0 {
355            m.partition_index = 1i32;
356        }
357        if version >= 0 {
358            m.error_code = 1i16;
359        }
360        if version >= 0 {
361            m.leader_id = 1i32;
362        }
363        if version >= 0 {
364            m.leader_epoch = 1i32;
365        }
366        m
367    }
368}
369#[derive(Debug, Clone, PartialEq, Eq, Default)]
370pub struct NodeEndpoint {
371    pub node_id: i32,
372    pub host: String,
373    pub port: u16,
374    pub unknown_tagged_fields: UnknownTaggedFields,
375}
376impl Encode for NodeEndpoint {
377    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
378        let flex = version >= 1;
379        if version >= 1 {
380            put_i32(buf, self.node_id);
381        }
382        if version >= 1 {
383            if flex {
384                put_compact_string(buf, &self.host)?;
385            } else {
386                put_string(buf, &self.host)?;
387            }
388        }
389        if version >= 1 {
390            put_u16(buf, self.port);
391        }
392        if flex {
393            let tagged = WriteTaggedFields::new();
394            tagged.write(buf, &self.unknown_tagged_fields)?;
395        }
396        Ok(())
397    }
398    fn encoded_len(&self, version: i16) -> usize {
399        let flex = version >= 1;
400        let mut n: usize = 0;
401        if version >= 1 {
402            n += 4;
403        }
404        if version >= 1 {
405            n += if flex {
406                compact_string_len(&self.host)
407            } else {
408                string_len(&self.host)
409            };
410        }
411        if version >= 1 {
412            n += 2;
413        }
414        if flex {
415            let known_pairs: Vec<(u32, usize)> = Vec::new();
416            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
417        }
418        n
419    }
420}
421impl Decode<'_> for NodeEndpoint {
422    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
423        let flex = version >= 1;
424        let mut out = Self::default();
425        if version >= 1 {
426            out.node_id = get_i32(buf)?;
427        }
428        if version >= 1 {
429            out.host = if flex {
430                get_compact_string_owned(buf)?
431            } else {
432                get_string_owned(buf)?
433            };
434        }
435        if version >= 1 {
436            out.port = get_u16(buf)?;
437        }
438        if flex {
439            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
440        }
441        Ok(out)
442    }
443}
444#[cfg(test)]
445impl NodeEndpoint {
446    #[must_use]
447    pub fn populated(version: i16) -> Self {
448        let mut m = Self::default();
449        if version >= 1 {
450            m.node_id = 1i32;
451        }
452        if version >= 1 {
453            m.host = "x".to_owned();
454        }
455        if version >= 1 {
456            m.port = 1u16;
457        }
458        m
459    }
460}
461/// Default JSON payload matching `Self::default()` for JVM oracle differential testing.
462/// Only includes fields valid for the given version.
463#[must_use]
464#[allow(unused_comparisons)]
465pub fn default_json(version: i16) -> ::serde_json::Value {
466    let mut obj = ::serde_json::Map::new();
467    obj.insert("errorCode".to_owned(), ::serde_json::json!(0));
468    obj.insert("topics".to_owned(), ::serde_json::Value::Array(vec![]));
469    if version >= 1 {
470        obj.insert(
471            "nodeEndpoints".to_owned(),
472            ::serde_json::Value::Array(vec![]),
473        );
474    }
475    ::serde_json::Value::Object(obj)
476}
477/// A message with a non-default value in every tagged field, at every depth, for
478/// the JVM oracle differential sweep. The value is the same at every version.
479#[must_use]
480pub fn tagged_fixture() -> EndQuorumEpochResponse {
481    EndQuorumEpochResponse {
482        node_endpoints: vec![NodeEndpoint {
483            node_id: 1i32,
484            host: "x".to_owned(),
485            port: 1u16,
486            ..NodeEndpoint::default()
487        }],
488        ..EndQuorumEpochResponse::default()
489    }
490}
491/// The JSON form of `tagged_fixture()` that Kafka's JSON converter reads at
492/// `version`. It holds only the fields that the schema declares at that version.
493#[must_use]
494pub fn tagged_fixture_json(version: i16) -> ::serde_json::Value {
495    let mut m = ::serde_json::Map::new();
496    m.insert("errorCode".to_owned(), ::serde_json::json!(0));
497    m.insert("topics".to_owned(), ::serde_json::Value::Array(vec![]));
498    if version == 1 {
499        m.insert(
500            "nodeEndpoints".to_owned(),
501            ::serde_json::Value::Array(vec![{
502                let mut m = ::serde_json::Map::new();
503                m.insert("nodeId".to_owned(), ::serde_json::json!(1));
504                m.insert(
505                    "host".to_owned(),
506                    ::serde_json::Value::String("x".to_owned()),
507                );
508                m.insert("port".to_owned(), ::serde_json::json!(1));
509                ::serde_json::Value::Object(m)
510            }]),
511        );
512    }
513    ::serde_json::Value::Object(m)
514}
krabka_protocol/opt/rustwide/workdir/generated/EndQuorumEpochResponse.owned.rs

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