kacrab_protocol/generated/
alter_client_quotas_request.rs

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

kacrab_protocol/generated/
alter_client_quotas_request.rs
