kacrab_protocol/generated/
delete_acls_response.rs

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

kacrab_protocol/generated/
delete_acls_response.rs
