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(array_read_capacity(len, (buf).len()));
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(array_read_capacity(len, (buf).len()));
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 =
124                                Vec::with_capacity(array_read_capacity(len, (&mut tag_buf).len()));
125                            for _ in 0..len {
126                                arr.push(SupportedFeatureKey::read(&mut tag_buf, version)?);
127                            }
128                            arr
129                        };
130                    },
131                    1 => {
132                        let mut tag_buf = field.data.clone();
133                        finalized_features_epoch = read_i64(&mut tag_buf)?;
134                    },
135                    2 => {
136                        let mut tag_buf = field.data.clone();
137                        finalized_features = {
138                            let len = read_compact_array_length(&mut tag_buf)?;
139                            let mut arr =
140                                Vec::with_capacity(array_read_capacity(len, (&mut tag_buf).len()));
141                            for _ in 0..len {
142                                arr.push(FinalizedFeatureKey::read(&mut tag_buf, version)?);
143                            }
144                            arr
145                        };
146                    },
147                    3 => {
148                        let mut tag_buf = field.data.clone();
149                        zk_migration_ready = read_bool(&mut tag_buf)?;
150                    },
151                    _ => {
152                        _unknown_tagged_fields.push(field.clone());
153                    },
154                }
155            }
156        }
157        Ok(Self {
158            error_code,
159            api_keys,
160            throttle_time_ms,
161            supported_features,
162            finalized_features_epoch,
163            finalized_features,
164            zk_migration_ready,
165            _unknown_tagged_fields,
166        })
167    }
168    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
169        if version < 0 || version > 4 {
170            return Err(UnsupportedVersion::new(18, version).into());
171        }
172        write_i16(buf, self.error_code);
173        if version >= 3 {
174            write_compact_array_length(buf, self.api_keys.len() as i32);
175            for el in &self.api_keys {
176                el.write(buf, version)?;
177            }
178        } else {
179            write_array_length(buf, self.api_keys.len() as i32);
180            for el in &self.api_keys {
181                el.write(buf, version)?;
182            }
183        }
184        if version >= 1 {
185            write_i32(buf, self.throttle_time_ms);
186        } else if self.throttle_time_ms != 0_i32 {
187            return Err(UnsupportedFieldVersion::new(18, "throttle_time_ms", version).into());
188        }
189        if version >= 3 {
190            let mut known_tagged_fields: Vec<RawTaggedField> = Vec::new();
191            if !self.supported_features.is_empty() {
192                let mut tag_buf = BytesMut::new();
193                write_compact_array_length(&mut tag_buf, self.supported_features.len() as i32);
194                for el in &self.supported_features {
195                    el.write(&mut tag_buf, version)?;
196                }
197                known_tagged_fields.push(RawTaggedField {
198                    tag: 0,
199                    data: tag_buf.freeze(),
200                });
201            }
202            if self.finalized_features_epoch != -1_i64 {
203                let mut tag_buf = BytesMut::new();
204                write_i64(&mut tag_buf, self.finalized_features_epoch);
205                known_tagged_fields.push(RawTaggedField {
206                    tag: 1,
207                    data: tag_buf.freeze(),
208                });
209            }
210            if !self.finalized_features.is_empty() {
211                let mut tag_buf = BytesMut::new();
212                write_compact_array_length(&mut tag_buf, self.finalized_features.len() as i32);
213                for el in &self.finalized_features {
214                    el.write(&mut tag_buf, version)?;
215                }
216                known_tagged_fields.push(RawTaggedField {
217                    tag: 2,
218                    data: tag_buf.freeze(),
219                });
220            }
221            if self.zk_migration_ready {
222                let mut tag_buf = BytesMut::new();
223                write_bool(&mut tag_buf, self.zk_migration_ready);
224                known_tagged_fields.push(RawTaggedField {
225                    tag: 3,
226                    data: tag_buf.freeze(),
227                });
228            }
229            let mut all_tags = known_tagged_fields;
230            all_tags.extend(self._unknown_tagged_fields.iter().cloned());
231            all_tags.sort_by_key(|f| f.tag);
232            write_tagged_fields(buf, &all_tags)?;
233        }
234        Ok(())
235    }
236    pub fn encoded_len(&self, version: i16) -> Result<usize> {
237        if version < 0 || version > 4 {
238            return Err(UnsupportedVersion::new(18, version).into());
239        }
240        let mut len: usize = 0;
241        len += 2;
242        if version >= 3 {
243            len += compact_array_length_len(self.api_keys.len() as i32);
244            for el in &self.api_keys {
245                len += el.encoded_len(version)?;
246            }
247        } else {
248            len += array_length_len();
249            for el in &self.api_keys {
250                len += el.encoded_len(version)?;
251            }
252        }
253        if version >= 1 {
254            len += 4;
255        } else if self.throttle_time_ms != 0_i32 {
256            return Err(UnsupportedFieldVersion::new(18, "throttle_time_ms", version).into());
257        }
258        if version >= 3 {
259            let mut known_tagged_fields: Vec<RawTaggedField> = Vec::new();
260            if !self.supported_features.is_empty() {
261                let mut tag_buf = BytesMut::new();
262                write_compact_array_length(&mut tag_buf, self.supported_features.len() as i32);
263                for el in &self.supported_features {
264                    el.write(&mut tag_buf, version)?;
265                }
266                known_tagged_fields.push(RawTaggedField {
267                    tag: 0,
268                    data: tag_buf.freeze(),
269                });
270            }
271            if self.finalized_features_epoch != -1_i64 {
272                let mut tag_buf = BytesMut::new();
273                write_i64(&mut tag_buf, self.finalized_features_epoch);
274                known_tagged_fields.push(RawTaggedField {
275                    tag: 1,
276                    data: tag_buf.freeze(),
277                });
278            }
279            if !self.finalized_features.is_empty() {
280                let mut tag_buf = BytesMut::new();
281                write_compact_array_length(&mut tag_buf, self.finalized_features.len() as i32);
282                for el in &self.finalized_features {
283                    el.write(&mut tag_buf, version)?;
284                }
285                known_tagged_fields.push(RawTaggedField {
286                    tag: 2,
287                    data: tag_buf.freeze(),
288                });
289            }
290            if self.zk_migration_ready {
291                let mut tag_buf = BytesMut::new();
292                write_bool(&mut tag_buf, self.zk_migration_ready);
293                known_tagged_fields.push(RawTaggedField {
294                    tag: 3,
295                    data: tag_buf.freeze(),
296                });
297            }
298            let mut all_tags = known_tagged_fields;
299            all_tags.extend(self._unknown_tagged_fields.iter().cloned());
300            all_tags.sort_by_key(|f| f.tag);
301            len += tagged_fields_len(&all_tags)?;
302        }
303        Ok(len)
304    }
305}
306#[derive(Debug, Clone, PartialEq)]
307pub struct ApiVersion {
308    /// The API index.
309    pub api_key: i16,
310    /// The minimum supported version, inclusive.
311    pub min_version: i16,
312    /// The maximum supported version, inclusive.
313    pub max_version: i16,
314    pub _unknown_tagged_fields: Vec<RawTaggedField>,
315}
316impl Default for ApiVersion {
317    fn default() -> Self {
318        Self {
319            api_key: 0_i16,
320            min_version: 0_i16,
321            max_version: 0_i16,
322            _unknown_tagged_fields: Vec::new(),
323        }
324    }
325}
326impl ApiVersion {
327    pub fn with_api_key(mut self, value: i16) -> Self {
328        self.api_key = value;
329        self
330    }
331    pub fn with_min_version(mut self, value: i16) -> Self {
332        self.min_version = value;
333        self
334    }
335    pub fn with_max_version(mut self, value: i16) -> Self {
336        self.max_version = value;
337        self
338    }
339    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
340        let api_key;
341        let min_version;
342        let max_version;
343        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
344        api_key = read_i16(buf)?;
345        min_version = read_i16(buf)?;
346        max_version = read_i16(buf)?;
347        if version >= 3 {
348            let tagged_fields = read_tagged_fields(buf)?;
349            for field in &tagged_fields {
350                match field.tag {
351                    _ => {
352                        _unknown_tagged_fields.push(field.clone());
353                    },
354                }
355            }
356        }
357        Ok(Self {
358            api_key,
359            min_version,
360            max_version,
361            _unknown_tagged_fields,
362        })
363    }
364    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
365        write_i16(buf, self.api_key);
366        write_i16(buf, self.min_version);
367        write_i16(buf, self.max_version);
368        if version >= 3 {
369            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
370            all_tags.sort_by_key(|f| f.tag);
371            write_tagged_fields(buf, &all_tags)?;
372        }
373        Ok(())
374    }
375    pub fn encoded_len(&self, version: i16) -> Result<usize> {
376        let mut len: usize = 0;
377        len += 2;
378        len += 2;
379        len += 2;
380        if version >= 3 {
381            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
382            all_tags.sort_by_key(|f| f.tag);
383            len += tagged_fields_len(&all_tags)?;
384        }
385        Ok(len)
386    }
387}
388#[derive(Debug, Clone, PartialEq)]
389pub struct SupportedFeatureKey {
390    /// The name of the feature.
391    pub name: KafkaString,
392    /// The minimum supported version for the feature.
393    pub min_version: i16,
394    /// The maximum supported version for the feature.
395    pub max_version: i16,
396    pub _unknown_tagged_fields: Vec<RawTaggedField>,
397}
398impl Default for SupportedFeatureKey {
399    fn default() -> Self {
400        Self {
401            name: KafkaString::default(),
402            min_version: 0_i16,
403            max_version: 0_i16,
404            _unknown_tagged_fields: Vec::new(),
405        }
406    }
407}
408impl SupportedFeatureKey {
409    pub fn with_name(mut self, value: KafkaString) -> Self {
410        self.name = value;
411        self
412    }
413    pub fn with_min_version(mut self, value: i16) -> Self {
414        self.min_version = value;
415        self
416    }
417    pub fn with_max_version(mut self, value: i16) -> Self {
418        self.max_version = value;
419        self
420    }
421    pub fn read(buf: &mut Bytes, _version: i16) -> Result<Self> {
422        let name;
423        let min_version;
424        let max_version;
425        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
426        name = read_compact_string(buf)?;
427        min_version = read_i16(buf)?;
428        max_version = read_i16(buf)?;
429        let tagged_fields = read_tagged_fields(buf)?;
430        for field in &tagged_fields {
431            match field.tag {
432                _ => {
433                    _unknown_tagged_fields.push(field.clone());
434                },
435            }
436        }
437        Ok(Self {
438            name,
439            min_version,
440            max_version,
441            _unknown_tagged_fields,
442        })
443    }
444    pub fn write(&self, buf: &mut BytesMut, _version: i16) -> Result<()> {
445        write_compact_string(buf, &self.name)?;
446        write_i16(buf, self.min_version);
447        write_i16(buf, self.max_version);
448        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
449        all_tags.sort_by_key(|f| f.tag);
450        write_tagged_fields(buf, &all_tags)?;
451        Ok(())
452    }
453    pub fn encoded_len(&self, _version: i16) -> Result<usize> {
454        let mut len: usize = 0;
455        len += compact_string_len(&self.name)?;
456        len += 2;
457        len += 2;
458        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
459        all_tags.sort_by_key(|f| f.tag);
460        len += tagged_fields_len(&all_tags)?;
461        Ok(len)
462    }
463}
464#[derive(Debug, Clone, PartialEq)]
465pub struct FinalizedFeatureKey {
466    /// The name of the feature.
467    pub name: KafkaString,
468    /// The cluster-wide finalized max version level for the feature.
469    pub max_version_level: i16,
470    /// The cluster-wide finalized min version level for the feature.
471    pub min_version_level: i16,
472    pub _unknown_tagged_fields: Vec<RawTaggedField>,
473}
474impl Default for FinalizedFeatureKey {
475    fn default() -> Self {
476        Self {
477            name: KafkaString::default(),
478            max_version_level: 0_i16,
479            min_version_level: 0_i16,
480            _unknown_tagged_fields: Vec::new(),
481        }
482    }
483}
484impl FinalizedFeatureKey {
485    pub fn with_name(mut self, value: KafkaString) -> Self {
486        self.name = value;
487        self
488    }
489    pub fn with_max_version_level(mut self, value: i16) -> Self {
490        self.max_version_level = value;
491        self
492    }
493    pub fn with_min_version_level(mut self, value: i16) -> Self {
494        self.min_version_level = value;
495        self
496    }
497    pub fn read(buf: &mut Bytes, _version: i16) -> Result<Self> {
498        let name;
499        let max_version_level;
500        let min_version_level;
501        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
502        name = read_compact_string(buf)?;
503        max_version_level = read_i16(buf)?;
504        min_version_level = read_i16(buf)?;
505        let tagged_fields = read_tagged_fields(buf)?;
506        for field in &tagged_fields {
507            match field.tag {
508                _ => {
509                    _unknown_tagged_fields.push(field.clone());
510                },
511            }
512        }
513        Ok(Self {
514            name,
515            max_version_level,
516            min_version_level,
517            _unknown_tagged_fields,
518        })
519    }
520    pub fn write(&self, buf: &mut BytesMut, _version: i16) -> Result<()> {
521        write_compact_string(buf, &self.name)?;
522        write_i16(buf, self.max_version_level);
523        write_i16(buf, self.min_version_level);
524        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
525        all_tags.sort_by_key(|f| f.tag);
526        write_tagged_fields(buf, &all_tags)?;
527        Ok(())
528    }
529    pub fn encoded_len(&self, _version: i16) -> Result<usize> {
530        let mut len: usize = 0;
531        len += compact_string_len(&self.name)?;
532        len += 2;
533        len += 2;
534        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
535        all_tags.sort_by_key(|f| f.tag);
536        len += tagged_fields_len(&all_tags)?;
537        Ok(len)
538    }
539}
kacrab_protocol/generated/api_versions_response.rs

kacrab_protocol/generated/
api_versions_response.rs
