kacrab_protocol/generated/
describe_acls_request.rs

1//! Generated from DescribeAclsRequest.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 DescribeAclsRequestData {
17    /// The resource type.
18    pub resource_type_filter: i8,
19    /// The resource name, or null to match any resource name.
20    pub resource_name_filter: Option<KafkaString>,
21    /// The resource pattern to match.
22    pub pattern_type_filter: i8,
23    /// The principal to match, or null to match any principal.
24    pub principal_filter: Option<KafkaString>,
25    /// The host to match, or null to match any host.
26    pub host_filter: Option<KafkaString>,
27    /// The operation to match.
28    pub operation: i8,
29    /// The permission type to match.
30    pub permission_type: i8,
31    pub _unknown_tagged_fields: Vec<RawTaggedField>,
32}
33impl Default for DescribeAclsRequestData {
34    fn default() -> Self {
35        Self {
36            resource_type_filter: 0_i8,
37            resource_name_filter: None,
38            pattern_type_filter: 3i8,
39            principal_filter: None,
40            host_filter: None,
41            operation: 0_i8,
42            permission_type: 0_i8,
43            _unknown_tagged_fields: Vec::new(),
44        }
45    }
46}
47impl DescribeAclsRequestData {
48    pub fn with_resource_type_filter(mut self, value: i8) -> Self {
49        self.resource_type_filter = value;
50        self
51    }
52    pub fn with_resource_name_filter(mut self, value: Option<KafkaString>) -> Self {
53        self.resource_name_filter = value;
54        self
55    }
56    pub fn with_pattern_type_filter(mut self, value: i8) -> Self {
57        self.pattern_type_filter = value;
58        self
59    }
60    pub fn with_principal_filter(mut self, value: Option<KafkaString>) -> Self {
61        self.principal_filter = value;
62        self
63    }
64    pub fn with_host_filter(mut self, value: Option<KafkaString>) -> Self {
65        self.host_filter = value;
66        self
67    }
68    pub fn with_operation(mut self, value: i8) -> Self {
69        self.operation = value;
70        self
71    }
72    pub fn with_permission_type(mut self, value: i8) -> Self {
73        self.permission_type = value;
74        self
75    }
76    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
77        if version < 1 || version > 3 {
78            return Err(UnsupportedVersion::new(29, version).into());
79        }
80        let resource_type_filter;
81        let resource_name_filter;
82        let pattern_type_filter;
83        let principal_filter;
84        let host_filter;
85        let operation;
86        let permission_type;
87        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
88        resource_type_filter = read_i8(buf)?;
89        if version >= 2 {
90            resource_name_filter = read_compact_nullable_string(buf)?;
91        } else {
92            resource_name_filter = read_nullable_string(buf)?;
93        }
94        pattern_type_filter = read_i8(buf)?;
95        if version >= 2 {
96            principal_filter = read_compact_nullable_string(buf)?;
97        } else {
98            principal_filter = read_nullable_string(buf)?;
99        }
100        if version >= 2 {
101            host_filter = read_compact_nullable_string(buf)?;
102        } else {
103            host_filter = read_nullable_string(buf)?;
104        }
105        operation = read_i8(buf)?;
106        permission_type = read_i8(buf)?;
107        if version >= 2 {
108            let tagged_fields = read_tagged_fields(buf)?;
109            for field in &tagged_fields {
110                match field.tag {
111                    _ => {
112                        _unknown_tagged_fields.push(field.clone());
113                    },
114                }
115            }
116        }
117        Ok(Self {
118            resource_type_filter,
119            resource_name_filter,
120            pattern_type_filter,
121            principal_filter,
122            host_filter,
123            operation,
124            permission_type,
125            _unknown_tagged_fields,
126        })
127    }
128    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
129        if version < 1 || version > 3 {
130            return Err(UnsupportedVersion::new(29, version).into());
131        }
132        write_i8(buf, self.resource_type_filter);
133        if version >= 2 {
134            write_compact_nullable_string(buf, self.resource_name_filter.as_ref())?;
135        } else {
136            write_nullable_string(buf, self.resource_name_filter.as_ref())?;
137        }
138        write_i8(buf, self.pattern_type_filter);
139        if version >= 2 {
140            write_compact_nullable_string(buf, self.principal_filter.as_ref())?;
141        } else {
142            write_nullable_string(buf, self.principal_filter.as_ref())?;
143        }
144        if version >= 2 {
145            write_compact_nullable_string(buf, self.host_filter.as_ref())?;
146        } else {
147            write_nullable_string(buf, self.host_filter.as_ref())?;
148        }
149        write_i8(buf, self.operation);
150        write_i8(buf, self.permission_type);
151        if version >= 2 {
152            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
153            all_tags.sort_by_key(|f| f.tag);
154            write_tagged_fields(buf, &all_tags)?;
155        }
156        Ok(())
157    }
158    pub fn encoded_len(&self, version: i16) -> Result<usize> {
159        if version < 1 || version > 3 {
160            return Err(UnsupportedVersion::new(29, version).into());
161        }
162        let mut len: usize = 0;
163        len += 1;
164        if version >= 2 {
165            len += compact_nullable_string_len(self.resource_name_filter.as_ref())?;
166        } else {
167            len += nullable_string_len(self.resource_name_filter.as_ref())?;
168        }
169        len += 1;
170        if version >= 2 {
171            len += compact_nullable_string_len(self.principal_filter.as_ref())?;
172        } else {
173            len += nullable_string_len(self.principal_filter.as_ref())?;
174        }
175        if version >= 2 {
176            len += compact_nullable_string_len(self.host_filter.as_ref())?;
177        } else {
178            len += nullable_string_len(self.host_filter.as_ref())?;
179        }
180        len += 1;
181        len += 1;
182        if version >= 2 {
183            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
184            all_tags.sort_by_key(|f| f.tag);
185            len += tagged_fields_len(&all_tags)?;
186        }
187        Ok(len)
188    }
189}
kacrab_protocol/generated/describe_acls_request.rs

kacrab_protocol/generated/
describe_acls_request.rs
