kacrab_protocol/generated/
describe_acls_response.rs

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

kacrab_protocol/generated/
describe_acls_response.rs
