kacrab_protocol/generated/
api_versions_response.rs

1//! Generated from ApiVersionsResponse.json - DO NOT EDIT
2#![allow(
3    missing_docs,
4    clippy::all,
5    clippy::pedantic,
6    clippy::nursery,
7    clippy::arithmetic_side_effects,
8    reason = "Generated protocol modules mirror Kafka's schema shape and intentionally trade \
9              hand-written lint style for reproducible wire-code output."
10)]
11use bytes::{Bytes, BytesMut};
12
13use crate::*;
14
15#[derive(Debug, Clone, PartialEq)]
16pub struct ApiVersionsResponseData {
17    /// The top-level error code.
18    pub error_code: i16,
19    /// The APIs supported by the broker.
20    pub api_keys: Vec<ApiVersion>,
21    /// The duration in milliseconds for which the request was throttled due to a quota violation,
22    /// or zero if the request did not violate any quota.
23    pub throttle_time_ms: i32,
24    /// Features supported by the broker. Note: in v0-v3, features with MinSupportedVersion = 0 are
25    /// omitted.
26    pub supported_features: Vec<SupportedFeatureKey>,
27    /// The monotonically increasing epoch for the finalized features information. Valid values are
28    /// >= 0. A value of -1 is special and represents unknown epoch.
29    pub finalized_features_epoch: i64,
30    /// List of cluster-wide finalized features. The information is valid only if
31    /// FinalizedFeaturesEpoch >= 0.
32    pub finalized_features: Vec<FinalizedFeatureKey>,
33    /// Set by a KRaft controller if the required configurations for ZK migration are present.
34    pub zk_migration_ready: bool,
35    pub _unknown_tagged_fields: Vec<RawTaggedField>,
36}
37impl Default for ApiVersionsResponseData {
38    fn default() -> Self {
39        Self {
40            error_code: 0_i16,
41            api_keys: Vec::new(),
42            throttle_time_ms: 0_i32,
43            supported_features: Vec::new(),
44            finalized_features_epoch: -1i64,
45            finalized_features: Vec::new(),
46            zk_migration_ready: false,
47            _unknown_tagged_fields: Vec::new(),
48        }
49    }
50}
51impl ApiVersionsResponseData {
52    pub fn with_error_code(mut self, value: i16) -> Self {
53        self.error_code = value;
54        self
55    }
56    pub fn with_api_keys(mut self, value: Vec<ApiVersion>) -> Self {
57        self.api_keys = value;
58        self
59    }
60    pub fn with_throttle_time_ms(mut self, value: i32) -> Self {
61        self.throttle_time_ms = value;
62        self
63    }
64    pub fn with_supported_features(mut self, value: Vec<SupportedFeatureKey>) -> Self {
65        self.supported_features = value;
66        self
67    }
68    pub fn with_finalized_features_epoch(mut self, value: i64) -> Self {
69        self.finalized_features_epoch = value;
70        self
71    }
72    pub fn with_finalized_features(mut self, value: Vec<FinalizedFeatureKey>) -> Self {
73        self.finalized_features = value;
74        self
75    }
76    pub fn with_zk_migration_ready(mut self, value: bool) -> Self {
77        self.zk_migration_ready = value;
78        self
79    }
80    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
81        if version < 0 || version > 4 {
82            return Err(UnsupportedVersion::new(18, version).into());
83        }
84        let error_code;
85        let api_keys;
86        let mut throttle_time_ms = 0_i32;
87        let mut supported_features = Vec::new();
88        let mut finalized_features_epoch = -1i64;
89        let mut finalized_features = Vec::new();
90        let mut zk_migration_ready = false;
91        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
92        error_code = read_i16(buf)?;
93        if version >= 3 {
94            api_keys = {
95                let len = read_compact_array_length(buf)?;
96                let mut arr = Vec::with_capacity(len.max(0) as usize);
97                for _ in 0..len {
98                    arr.push(ApiVersion::read(buf, version)?);
99                }
100                arr
101            };
102        } else {
103            api_keys = {
104                let len = read_array_length(buf)?;
105                let mut arr = Vec::with_capacity(len.max(0) as usize);
106                for _ in 0..len {
107                    arr.push(ApiVersion::read(buf, version)?);
108                }
109                arr
110            };
111        }
112        if version >= 1 {
113            throttle_time_ms = read_i32(buf)?;
114        }
115        if version >= 3 {
116            let tagged_fields = read_tagged_fields(buf)?;
117            for field in &tagged_fields {
118                match field.tag {
119                    0 => {
120                        let mut tag_buf = field.data.clone();
121                        supported_features = {
122                            let len = read_compact_array_length(&mut tag_buf)?;
123                            let mut arr = Vec::with_capacity(len.max(0) as usize);
124                            for _ in 0..len {
125                                arr.push(SupportedFeatureKey::read(&mut tag_buf, version)?);
126                            }
127                            arr
128                        };
129                    },
130                    1 => {
131                        let mut tag_buf = field.data.clone();
132                        finalized_features_epoch = read_i64(&mut tag_buf)?;
133                    },
134                    2 => {
135                        let mut tag_buf = field.data.clone();
136                        finalized_features = {
137                            let len = read_compact_array_length(&mut tag_buf)?;
138                            let mut arr = Vec::with_capacity(len.max(0) as usize);
139                            for _ in 0..len {
140                                arr.push(FinalizedFeatureKey::read(&mut tag_buf, version)?);
141                            }
142                            arr
143                        };
144                    },
145                    3 => {
146                        let mut tag_buf = field.data.clone();
147                        zk_migration_ready = read_bool(&mut tag_buf)?;
148                    },
149                    _ => {
150                        _unknown_tagged_fields.push(field.clone());
151                    },
152                }
153            }
154        }
155        Ok(Self {
156            error_code,
157            api_keys,
158            throttle_time_ms,
159            supported_features,
160            finalized_features_epoch,
161            finalized_features,
162            zk_migration_ready,
163            _unknown_tagged_fields,
164        })
165    }
166    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
167        if version < 0 || version > 4 {
168            return Err(UnsupportedVersion::new(18, version).into());
169        }
170        write_i16(buf, self.error_code);
171        if version >= 3 {
172            write_compact_array_length(buf, self.api_keys.len() as i32);
173            for el in &self.api_keys {
174                el.write(buf, version)?;
175            }
176        } else {
177            write_array_length(buf, self.api_keys.len() as i32);
178            for el in &self.api_keys {
179                el.write(buf, version)?;
180            }
181        }
182        if version >= 1 {
183            write_i32(buf, self.throttle_time_ms);
184        } else if self.throttle_time_ms != 0_i32 {
185            return Err(UnsupportedFieldVersion::new(18, "throttle_time_ms", version).into());
186        }
187        if version >= 3 {
188            let mut known_tagged_fields: Vec<RawTaggedField> = Vec::new();
189            if !self.supported_features.is_empty() {
190                let mut tag_buf = BytesMut::new();
191                write_compact_array_length(&mut tag_buf, self.supported_features.len() as i32);
192                for el in &self.supported_features {
193                    el.write(&mut tag_buf, version)?;
194                }
195                known_tagged_fields.push(RawTaggedField {
196                    tag: 0,
197                    data: tag_buf.freeze(),
198                });
199            }
200            if self.finalized_features_epoch != -1_i64 {
201                let mut tag_buf = BytesMut::new();
202                write_i64(&mut tag_buf, self.finalized_features_epoch);
203                known_tagged_fields.push(RawTaggedField {
204                    tag: 1,
205                    data: tag_buf.freeze(),
206                });
207            }
208            if !self.finalized_features.is_empty() {
209                let mut tag_buf = BytesMut::new();
210                write_compact_array_length(&mut tag_buf, self.finalized_features.len() as i32);
211                for el in &self.finalized_features {
212                    el.write(&mut tag_buf, version)?;
213                }
214                known_tagged_fields.push(RawTaggedField {
215                    tag: 2,
216                    data: tag_buf.freeze(),
217                });
218            }
219            if self.zk_migration_ready {
220                let mut tag_buf = BytesMut::new();
221                write_bool(&mut tag_buf, self.zk_migration_ready);
222                known_tagged_fields.push(RawTaggedField {
223                    tag: 3,
224                    data: tag_buf.freeze(),
225                });
226            }
227            let mut all_tags = known_tagged_fields;
228            all_tags.extend(self._unknown_tagged_fields.iter().cloned());
229            all_tags.sort_by_key(|f| f.tag);
230            write_tagged_fields(buf, &all_tags)?;
231        }
232        Ok(())
233    }
234    pub fn encoded_len(&self, version: i16) -> Result<usize> {
235        if version < 0 || version > 4 {
236            return Err(UnsupportedVersion::new(18, version).into());
237        }
238        let mut len: usize = 0;
239        len += 2;
240        if version >= 3 {
241            len += compact_array_length_len(self.api_keys.len() as i32);
242            for el in &self.api_keys {
243                len += el.encoded_len(version)?;
244            }
245        } else {
246            len += array_length_len();
247            for el in &self.api_keys {
248                len += el.encoded_len(version)?;
249            }
250        }
251        if version >= 1 {
252            len += 4;
253        } else if self.throttle_time_ms != 0_i32 {
254            return Err(UnsupportedFieldVersion::new(18, "throttle_time_ms", version).into());
255        }
256        if version >= 3 {
257            let mut known_tagged_fields: Vec<RawTaggedField> = Vec::new();
258            if !self.supported_features.is_empty() {
259                let mut tag_buf = BytesMut::new();
260                write_compact_array_length(&mut tag_buf, self.supported_features.len() as i32);
261                for el in &self.supported_features {
262                    el.write(&mut tag_buf, version)?;
263                }
264                known_tagged_fields.push(RawTaggedField {
265                    tag: 0,
266                    data: tag_buf.freeze(),
267                });
268            }
269            if self.finalized_features_epoch != -1_i64 {
270                let mut tag_buf = BytesMut::new();
271                write_i64(&mut tag_buf, self.finalized_features_epoch);
272                known_tagged_fields.push(RawTaggedField {
273                    tag: 1,
274                    data: tag_buf.freeze(),
275                });
276            }
277            if !self.finalized_features.is_empty() {
278                let mut tag_buf = BytesMut::new();
279                write_compact_array_length(&mut tag_buf, self.finalized_features.len() as i32);
280                for el in &self.finalized_features {
281                    el.write(&mut tag_buf, version)?;
282                }
283                known_tagged_fields.push(RawTaggedField {
284                    tag: 2,
285                    data: tag_buf.freeze(),
286                });
287            }
288            if self.zk_migration_ready {
289                let mut tag_buf = BytesMut::new();
290                write_bool(&mut tag_buf, self.zk_migration_ready);
291                known_tagged_fields.push(RawTaggedField {
292                    tag: 3,
293                    data: tag_buf.freeze(),
294                });
295            }
296            let mut all_tags = known_tagged_fields;
297            all_tags.extend(self._unknown_tagged_fields.iter().cloned());
298            all_tags.sort_by_key(|f| f.tag);
299            len += tagged_fields_len(&all_tags)?;
300        }
301        Ok(len)
302    }
303}
304#[derive(Debug, Clone, PartialEq)]
305pub struct ApiVersion {
306    /// The API index.
307    pub api_key: i16,
308    /// The minimum supported version, inclusive.
309    pub min_version: i16,
310    /// The maximum supported version, inclusive.
311    pub max_version: i16,
312    pub _unknown_tagged_fields: Vec<RawTaggedField>,
313}
314impl Default for ApiVersion {
315    fn default() -> Self {
316        Self {
317            api_key: 0_i16,
318            min_version: 0_i16,
319            max_version: 0_i16,
320            _unknown_tagged_fields: Vec::new(),
321        }
322    }
323}
324impl ApiVersion {
325    pub fn with_api_key(mut self, value: i16) -> Self {
326        self.api_key = value;
327        self
328    }
329    pub fn with_min_version(mut self, value: i16) -> Self {
330        self.min_version = value;
331        self
332    }
333    pub fn with_max_version(mut self, value: i16) -> Self {
334        self.max_version = value;
335        self
336    }
337    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
338        let api_key;
339        let min_version;
340        let max_version;
341        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
342        api_key = read_i16(buf)?;
343        min_version = read_i16(buf)?;
344        max_version = read_i16(buf)?;
345        if version >= 3 {
346            let tagged_fields = read_tagged_fields(buf)?;
347            for field in &tagged_fields {
348                match field.tag {
349                    _ => {
350                        _unknown_tagged_fields.push(field.clone());
351                    },
352                }
353            }
354        }
355        Ok(Self {
356            api_key,
357            min_version,
358            max_version,
359            _unknown_tagged_fields,
360        })
361    }
362    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
363        write_i16(buf, self.api_key);
364        write_i16(buf, self.min_version);
365        write_i16(buf, self.max_version);
366        if version >= 3 {
367            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
368            all_tags.sort_by_key(|f| f.tag);
369            write_tagged_fields(buf, &all_tags)?;
370        }
371        Ok(())
372    }
373    pub fn encoded_len(&self, version: i16) -> Result<usize> {
374        let mut len: usize = 0;
375        len += 2;
376        len += 2;
377        len += 2;
378        if version >= 3 {
379            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
380            all_tags.sort_by_key(|f| f.tag);
381            len += tagged_fields_len(&all_tags)?;
382        }
383        Ok(len)
384    }
385}
386#[derive(Debug, Clone, PartialEq)]
387pub struct SupportedFeatureKey {
388    /// The name of the feature.
389    pub name: KafkaString,
390    /// The minimum supported version for the feature.
391    pub min_version: i16,
392    /// The maximum supported version for the feature.
393    pub max_version: i16,
394    pub _unknown_tagged_fields: Vec<RawTaggedField>,
395}
396impl Default for SupportedFeatureKey {
397    fn default() -> Self {
398        Self {
399            name: KafkaString::default(),
400            min_version: 0_i16,
401            max_version: 0_i16,
402            _unknown_tagged_fields: Vec::new(),
403        }
404    }
405}
406impl SupportedFeatureKey {
407    pub fn with_name(mut self, value: KafkaString) -> Self {
408        self.name = value;
409        self
410    }
411    pub fn with_min_version(mut self, value: i16) -> Self {
412        self.min_version = value;
413        self
414    }
415    pub fn with_max_version(mut self, value: i16) -> Self {
416        self.max_version = value;
417        self
418    }
419    pub fn read(buf: &mut Bytes, _version: i16) -> Result<Self> {
420        let name;
421        let min_version;
422        let max_version;
423        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
424        name = read_compact_string(buf)?;
425        min_version = read_i16(buf)?;
426        max_version = read_i16(buf)?;
427        let tagged_fields = read_tagged_fields(buf)?;
428        for field in &tagged_fields {
429            match field.tag {
430                _ => {
431                    _unknown_tagged_fields.push(field.clone());
432                },
433            }
434        }
435        Ok(Self {
436            name,
437            min_version,
438            max_version,
439            _unknown_tagged_fields,
440        })
441    }
442    pub fn write(&self, buf: &mut BytesMut, _version: i16) -> Result<()> {
443        write_compact_string(buf, &self.name)?;
444        write_i16(buf, self.min_version);
445        write_i16(buf, self.max_version);
446        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
447        all_tags.sort_by_key(|f| f.tag);
448        write_tagged_fields(buf, &all_tags)?;
449        Ok(())
450    }
451    pub fn encoded_len(&self, _version: i16) -> Result<usize> {
452        let mut len: usize = 0;
453        len += compact_string_len(&self.name)?;
454        len += 2;
455        len += 2;
456        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
457        all_tags.sort_by_key(|f| f.tag);
458        len += tagged_fields_len(&all_tags)?;
459        Ok(len)
460    }
461}
462#[derive(Debug, Clone, PartialEq)]
463pub struct FinalizedFeatureKey {
464    /// The name of the feature.
465    pub name: KafkaString,
466    /// The cluster-wide finalized max version level for the feature.
467    pub max_version_level: i16,
468    /// The cluster-wide finalized min version level for the feature.
469    pub min_version_level: i16,
470    pub _unknown_tagged_fields: Vec<RawTaggedField>,
471}
472impl Default for FinalizedFeatureKey {
473    fn default() -> Self {
474        Self {
475            name: KafkaString::default(),
476            max_version_level: 0_i16,
477            min_version_level: 0_i16,
478            _unknown_tagged_fields: Vec::new(),
479        }
480    }
481}
482impl FinalizedFeatureKey {
483    pub fn with_name(mut self, value: KafkaString) -> Self {
484        self.name = value;
485        self
486    }
487    pub fn with_max_version_level(mut self, value: i16) -> Self {
488        self.max_version_level = value;
489        self
490    }
491    pub fn with_min_version_level(mut self, value: i16) -> Self {
492        self.min_version_level = value;
493        self
494    }
495    pub fn read(buf: &mut Bytes, _version: i16) -> Result<Self> {
496        let name;
497        let max_version_level;
498        let min_version_level;
499        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
500        name = read_compact_string(buf)?;
501        max_version_level = read_i16(buf)?;
502        min_version_level = read_i16(buf)?;
503        let tagged_fields = read_tagged_fields(buf)?;
504        for field in &tagged_fields {
505            match field.tag {
506                _ => {
507                    _unknown_tagged_fields.push(field.clone());
508                },
509            }
510        }
511        Ok(Self {
512            name,
513            max_version_level,
514            min_version_level,
515            _unknown_tagged_fields,
516        })
517    }
518    pub fn write(&self, buf: &mut BytesMut, _version: i16) -> Result<()> {
519        write_compact_string(buf, &self.name)?;
520        write_i16(buf, self.max_version_level);
521        write_i16(buf, self.min_version_level);
522        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
523        all_tags.sort_by_key(|f| f.tag);
524        write_tagged_fields(buf, &all_tags)?;
525        Ok(())
526    }
527    pub fn encoded_len(&self, _version: i16) -> Result<usize> {
528        let mut len: usize = 0;
529        len += compact_string_len(&self.name)?;
530        len += 2;
531        len += 2;
532        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
533        all_tags.sort_by_key(|f| f.tag);
534        len += tagged_fields_len(&all_tags)?;
535        Ok(len)
536    }
537}
kacrab_protocol/generated/api_versions_response.rs

kacrab_protocol/generated/
api_versions_response.rs
