kacrab_protocol/generated/
describe_client_quotas_response.rs

1//! Generated from DescribeClientQuotasResponse.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 DescribeClientQuotasResponseData {
17    /// The duration in milliseconds for which the request was throttled due to a quota violation,
18    /// or zero if the request did not violate any quota.
19    pub throttle_time_ms: i32,
20    /// The error code, or `0` if the quota description succeeded.
21    pub error_code: i16,
22    /// The error message, or `null` if the quota description succeeded.
23    pub error_message: Option<KafkaString>,
24    /// A result entry.
25    pub entries: Option<Vec<EntryData>>,
26    pub _unknown_tagged_fields: Vec<RawTaggedField>,
27}
28impl Default for DescribeClientQuotasResponseData {
29    fn default() -> Self {
30        Self {
31            throttle_time_ms: 0_i32,
32            error_code: 0_i16,
33            error_message: None,
34            entries: None,
35            _unknown_tagged_fields: Vec::new(),
36        }
37    }
38}
39impl DescribeClientQuotasResponseData {
40    pub fn with_throttle_time_ms(mut self, value: i32) -> Self {
41        self.throttle_time_ms = value;
42        self
43    }
44    pub fn with_error_code(mut self, value: i16) -> Self {
45        self.error_code = value;
46        self
47    }
48    pub fn with_error_message(mut self, value: Option<KafkaString>) -> Self {
49        self.error_message = value;
50        self
51    }
52    pub fn with_entries(mut self, value: Option<Vec<EntryData>>) -> Self {
53        self.entries = value;
54        self
55    }
56    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
57        if version < 0 || version > 1 {
58            return Err(UnsupportedVersion::new(48, version).into());
59        }
60        let throttle_time_ms;
61        let error_code;
62        let error_message;
63        let entries;
64        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
65        throttle_time_ms = read_i32(buf)?;
66        error_code = read_i16(buf)?;
67        if version >= 1 {
68            error_message = read_compact_nullable_string(buf)?;
69        } else {
70            error_message = read_nullable_string(buf)?;
71        }
72        if version >= 1 {
73            entries = {
74                let len = read_compact_array_length(buf)?;
75                if len < 0 {
76                    None
77                } else {
78                    let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
79                    for _ in 0..len {
80                        arr.push(EntryData::read(buf, version)?);
81                    }
82                    Some(arr)
83                }
84            };
85        } else {
86            entries = {
87                let len = read_array_length(buf)?;
88                if len < 0 {
89                    None
90                } else {
91                    let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
92                    for _ in 0..len {
93                        arr.push(EntryData::read(buf, version)?);
94                    }
95                    Some(arr)
96                }
97            };
98        }
99        if version >= 1 {
100            let tagged_fields = read_tagged_fields(buf)?;
101            for field in &tagged_fields {
102                match field.tag {
103                    _ => {
104                        _unknown_tagged_fields.push(field.clone());
105                    },
106                }
107            }
108        }
109        Ok(Self {
110            throttle_time_ms,
111            error_code,
112            error_message,
113            entries,
114            _unknown_tagged_fields,
115        })
116    }
117    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
118        if version < 0 || version > 1 {
119            return Err(UnsupportedVersion::new(48, version).into());
120        }
121        write_i32(buf, self.throttle_time_ms);
122        write_i16(buf, self.error_code);
123        if version >= 1 {
124            write_compact_nullable_string(buf, self.error_message.as_ref())?;
125        } else {
126            write_nullable_string(buf, self.error_message.as_ref())?;
127        }
128        if version >= 1 {
129            match &self.entries {
130                None => {
131                    write_compact_array_length(buf, -1);
132                },
133                Some(arr) => {
134                    write_compact_array_length(buf, arr.len() as i32);
135                    for el in arr {
136                        el.write(buf, version)?;
137                    }
138                },
139            }
140        } else {
141            match &self.entries {
142                None => {
143                    write_array_length(buf, -1);
144                },
145                Some(arr) => {
146                    write_array_length(buf, arr.len() as i32);
147                    for el in arr {
148                        el.write(buf, version)?;
149                    }
150                },
151            }
152        }
153        if version >= 1 {
154            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
155            all_tags.sort_by_key(|f| f.tag);
156            write_tagged_fields(buf, &all_tags)?;
157        }
158        Ok(())
159    }
160    pub fn encoded_len(&self, version: i16) -> Result<usize> {
161        if version < 0 || version > 1 {
162            return Err(UnsupportedVersion::new(48, version).into());
163        }
164        let mut len: usize = 0;
165        len += 4;
166        len += 2;
167        if version >= 1 {
168            len += compact_nullable_string_len(self.error_message.as_ref())?;
169        } else {
170            len += nullable_string_len(self.error_message.as_ref())?;
171        }
172        if version >= 1 {
173            match &self.entries {
174                None => {
175                    len += compact_array_length_len(-1);
176                },
177                Some(arr) => {
178                    len += compact_array_length_len(arr.len() as i32);
179                    for el in arr {
180                        len += el.encoded_len(version)?;
181                    }
182                },
183            }
184        } else {
185            match &self.entries {
186                None => {
187                    len += array_length_len();
188                },
189                Some(arr) => {
190                    len += array_length_len();
191                    for el in arr {
192                        len += el.encoded_len(version)?;
193                    }
194                },
195            }
196        }
197        if version >= 1 {
198            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
199            all_tags.sort_by_key(|f| f.tag);
200            len += tagged_fields_len(&all_tags)?;
201        }
202        Ok(len)
203    }
204}
205#[derive(Debug, Clone, PartialEq)]
206pub struct EntryData {
207    /// The quota entity description.
208    pub entity: Vec<EntityData>,
209    /// The quota values for the entity.
210    pub values: Vec<ValueData>,
211    pub _unknown_tagged_fields: Vec<RawTaggedField>,
212}
213impl Default for EntryData {
214    fn default() -> Self {
215        Self {
216            entity: Vec::new(),
217            values: Vec::new(),
218            _unknown_tagged_fields: Vec::new(),
219        }
220    }
221}
222impl EntryData {
223    pub fn with_entity(mut self, value: Vec<EntityData>) -> Self {
224        self.entity = value;
225        self
226    }
227    pub fn with_values(mut self, value: Vec<ValueData>) -> Self {
228        self.values = value;
229        self
230    }
231    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
232        let entity;
233        let values;
234        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
235        if version >= 1 {
236            entity = {
237                let len = read_compact_array_length(buf)?;
238                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
239                for _ in 0..len {
240                    arr.push(EntityData::read(buf, version)?);
241                }
242                arr
243            };
244        } else {
245            entity = {
246                let len = read_array_length(buf)?;
247                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
248                for _ in 0..len {
249                    arr.push(EntityData::read(buf, version)?);
250                }
251                arr
252            };
253        }
254        if version >= 1 {
255            values = {
256                let len = read_compact_array_length(buf)?;
257                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
258                for _ in 0..len {
259                    arr.push(ValueData::read(buf, version)?);
260                }
261                arr
262            };
263        } else {
264            values = {
265                let len = read_array_length(buf)?;
266                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
267                for _ in 0..len {
268                    arr.push(ValueData::read(buf, version)?);
269                }
270                arr
271            };
272        }
273        if version >= 1 {
274            let tagged_fields = read_tagged_fields(buf)?;
275            for field in &tagged_fields {
276                match field.tag {
277                    _ => {
278                        _unknown_tagged_fields.push(field.clone());
279                    },
280                }
281            }
282        }
283        Ok(Self {
284            entity,
285            values,
286            _unknown_tagged_fields,
287        })
288    }
289    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
290        if version >= 1 {
291            write_compact_array_length(buf, self.entity.len() as i32);
292            for el in &self.entity {
293                el.write(buf, version)?;
294            }
295        } else {
296            write_array_length(buf, self.entity.len() as i32);
297            for el in &self.entity {
298                el.write(buf, version)?;
299            }
300        }
301        if version >= 1 {
302            write_compact_array_length(buf, self.values.len() as i32);
303            for el in &self.values {
304                el.write(buf, version)?;
305            }
306        } else {
307            write_array_length(buf, self.values.len() as i32);
308            for el in &self.values {
309                el.write(buf, version)?;
310            }
311        }
312        if version >= 1 {
313            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
314            all_tags.sort_by_key(|f| f.tag);
315            write_tagged_fields(buf, &all_tags)?;
316        }
317        Ok(())
318    }
319    pub fn encoded_len(&self, version: i16) -> Result<usize> {
320        let mut len: usize = 0;
321        if version >= 1 {
322            len += compact_array_length_len(self.entity.len() as i32);
323            for el in &self.entity {
324                len += el.encoded_len(version)?;
325            }
326        } else {
327            len += array_length_len();
328            for el in &self.entity {
329                len += el.encoded_len(version)?;
330            }
331        }
332        if version >= 1 {
333            len += compact_array_length_len(self.values.len() as i32);
334            for el in &self.values {
335                len += el.encoded_len(version)?;
336            }
337        } else {
338            len += array_length_len();
339            for el in &self.values {
340                len += el.encoded_len(version)?;
341            }
342        }
343        if version >= 1 {
344            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
345            all_tags.sort_by_key(|f| f.tag);
346            len += tagged_fields_len(&all_tags)?;
347        }
348        Ok(len)
349    }
350}
351#[derive(Debug, Clone, PartialEq)]
352pub struct EntityData {
353    /// The entity type.
354    pub entity_type: KafkaString,
355    /// The entity name, or null if the default.
356    pub entity_name: Option<KafkaString>,
357    pub _unknown_tagged_fields: Vec<RawTaggedField>,
358}
359impl Default for EntityData {
360    fn default() -> Self {
361        Self {
362            entity_type: KafkaString::default(),
363            entity_name: None,
364            _unknown_tagged_fields: Vec::new(),
365        }
366    }
367}
368impl EntityData {
369    pub fn with_entity_type(mut self, value: KafkaString) -> Self {
370        self.entity_type = value;
371        self
372    }
373    pub fn with_entity_name(mut self, value: Option<KafkaString>) -> Self {
374        self.entity_name = value;
375        self
376    }
377    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
378        let entity_type;
379        let entity_name;
380        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
381        if version >= 1 {
382            entity_type = read_compact_string(buf)?;
383        } else {
384            entity_type = read_string(buf)?;
385        }
386        if version >= 1 {
387            entity_name = read_compact_nullable_string(buf)?;
388        } else {
389            entity_name = read_nullable_string(buf)?;
390        }
391        if version >= 1 {
392            let tagged_fields = read_tagged_fields(buf)?;
393            for field in &tagged_fields {
394                match field.tag {
395                    _ => {
396                        _unknown_tagged_fields.push(field.clone());
397                    },
398                }
399            }
400        }
401        Ok(Self {
402            entity_type,
403            entity_name,
404            _unknown_tagged_fields,
405        })
406    }
407    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
408        if version >= 1 {
409            write_compact_string(buf, &self.entity_type)?;
410        } else {
411            write_string(buf, &self.entity_type)?;
412        }
413        if version >= 1 {
414            write_compact_nullable_string(buf, self.entity_name.as_ref())?;
415        } else {
416            write_nullable_string(buf, self.entity_name.as_ref())?;
417        }
418        if version >= 1 {
419            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
420            all_tags.sort_by_key(|f| f.tag);
421            write_tagged_fields(buf, &all_tags)?;
422        }
423        Ok(())
424    }
425    pub fn encoded_len(&self, version: i16) -> Result<usize> {
426        let mut len: usize = 0;
427        if version >= 1 {
428            len += compact_string_len(&self.entity_type)?;
429        } else {
430            len += string_len(&self.entity_type)?;
431        }
432        if version >= 1 {
433            len += compact_nullable_string_len(self.entity_name.as_ref())?;
434        } else {
435            len += nullable_string_len(self.entity_name.as_ref())?;
436        }
437        if version >= 1 {
438            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
439            all_tags.sort_by_key(|f| f.tag);
440            len += tagged_fields_len(&all_tags)?;
441        }
442        Ok(len)
443    }
444}
445#[derive(Debug, Clone, PartialEq)]
446pub struct ValueData {
447    /// The quota configuration key.
448    pub key: KafkaString,
449    /// The quota configuration value.
450    pub value: f64,
451    pub _unknown_tagged_fields: Vec<RawTaggedField>,
452}
453impl Default for ValueData {
454    fn default() -> Self {
455        Self {
456            key: KafkaString::default(),
457            value: 0.0_f64,
458            _unknown_tagged_fields: Vec::new(),
459        }
460    }
461}
462impl ValueData {
463    pub fn with_key(mut self, value: KafkaString) -> Self {
464        self.key = value;
465        self
466    }
467    pub fn with_value(mut self, value: f64) -> Self {
468        self.value = value;
469        self
470    }
471    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
472        let key;
473        let value;
474        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
475        if version >= 1 {
476            key = read_compact_string(buf)?;
477        } else {
478            key = read_string(buf)?;
479        }
480        value = read_f64(buf)?;
481        if version >= 1 {
482            let tagged_fields = read_tagged_fields(buf)?;
483            for field in &tagged_fields {
484                match field.tag {
485                    _ => {
486                        _unknown_tagged_fields.push(field.clone());
487                    },
488                }
489            }
490        }
491        Ok(Self {
492            key,
493            value,
494            _unknown_tagged_fields,
495        })
496    }
497    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
498        if version >= 1 {
499            write_compact_string(buf, &self.key)?;
500        } else {
501            write_string(buf, &self.key)?;
502        }
503        write_f64(buf, self.value);
504        if version >= 1 {
505            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
506            all_tags.sort_by_key(|f| f.tag);
507            write_tagged_fields(buf, &all_tags)?;
508        }
509        Ok(())
510    }
511    pub fn encoded_len(&self, version: i16) -> Result<usize> {
512        let mut len: usize = 0;
513        if version >= 1 {
514            len += compact_string_len(&self.key)?;
515        } else {
516            len += string_len(&self.key)?;
517        }
518        len += 8;
519        if version >= 1 {
520            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
521            all_tags.sort_by_key(|f| f.tag);
522            len += tagged_fields_len(&all_tags)?;
523        }
524        Ok(len)
525    }
526}
kacrab_protocol/generated/describe_client_quotas_response.rs

kacrab_protocol/generated/
describe_client_quotas_response.rs
