Skip to main content

krabka_protocol/opt/rustwide/workdir/generated/
DescribeAclsRequest.borrowed.rs

1// AUTO-GENERATED by krabka-protocol-codegen against a9ce3221537b8653448750697915607dc7936cf3. Do not edit.
2use bytes::BufMut;
3
4use crate::{
5    DecodeBorrow, Encode, ProtocolError, UnknownTaggedFields,
6    primitives::{
7        fixed::{get_i8, put_i8},
8        string_bytes::{
9            compact_nullable_string_len, nullable_string_len, put_compact_nullable_string,
10            put_nullable_string,
11        },
12        string_bytes_borrowed::{
13            get_compact_nullable_string_borrowed, get_nullable_string_borrowed,
14        },
15    },
16    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
17};
18pub const API_KEY: i16 = 29;
19pub const MIN_VERSION: i16 = 1;
20pub const MAX_VERSION: i16 = 3;
21pub const LATEST_STABLE_VERSION: i16 = 3;
22pub const FLEXIBLE_MIN: i16 = 2;
23#[inline]
24#[must_use]
25pub fn is_flexible(version: i16) -> bool {
26    version >= FLEXIBLE_MIN
27}
28#[derive(Debug, Clone, PartialEq, Eq)]
29pub struct DescribeAclsRequest<'a> {
30    pub resource_type_filter: i8,
31    pub resource_name_filter: Option<&'a str>,
32    pub pattern_type_filter: i8,
33    pub principal_filter: Option<&'a str>,
34    pub host_filter: Option<&'a str>,
35    pub operation: i8,
36    pub permission_type: i8,
37    pub unknown_tagged_fields: UnknownTaggedFields,
38}
39impl Default for DescribeAclsRequest<'_> {
40    fn default() -> Self {
41        Self {
42            resource_type_filter: 0i8,
43            resource_name_filter: Some(""),
44            pattern_type_filter: 3i8,
45            principal_filter: Some(""),
46            host_filter: Some(""),
47            operation: 0i8,
48            permission_type: 0i8,
49            unknown_tagged_fields: UnknownTaggedFields::default(),
50        }
51    }
52}
53impl DescribeAclsRequest<'_> {
54    /// # Panics
55    ///
56    /// Panics if a records field contains an invalid encoded record batch.
57    #[must_use]
58    pub fn to_owned(&self) -> crate::owned::describe_acls_request::DescribeAclsRequest {
59        crate::owned::describe_acls_request::DescribeAclsRequest {
60            resource_type_filter: (self.resource_type_filter),
61            resource_name_filter: (self.resource_name_filter).map(std::string::ToString::to_string),
62            pattern_type_filter: (self.pattern_type_filter),
63            principal_filter: (self.principal_filter).map(std::string::ToString::to_string),
64            host_filter: (self.host_filter).map(std::string::ToString::to_string),
65            operation: (self.operation),
66            permission_type: (self.permission_type),
67            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
68        }
69    }
70}
71impl Encode for DescribeAclsRequest<'_> {
72    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
73        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
74            return Err(ProtocolError::UnsupportedVersion {
75                api_key: API_KEY,
76                version,
77            });
78        }
79        let flex = is_flexible(version);
80        if version >= 0 {
81            put_i8(buf, self.resource_type_filter);
82        }
83        if version >= 0 {
84            if flex {
85                let () = put_compact_nullable_string(buf, self.resource_name_filter);
86            } else {
87                let () = put_nullable_string(buf, self.resource_name_filter);
88            }
89        }
90        if version >= 1 {
91            put_i8(buf, self.pattern_type_filter);
92        }
93        if version >= 0 {
94            if flex {
95                let () = put_compact_nullable_string(buf, self.principal_filter);
96            } else {
97                let () = put_nullable_string(buf, self.principal_filter);
98            }
99        }
100        if version >= 0 {
101            if flex {
102                let () = put_compact_nullable_string(buf, self.host_filter);
103            } else {
104                let () = put_nullable_string(buf, self.host_filter);
105            }
106        }
107        if version >= 0 {
108            put_i8(buf, self.operation);
109        }
110        if version >= 0 {
111            put_i8(buf, self.permission_type);
112        }
113        if flex {
114            let tagged = WriteTaggedFields::new();
115            tagged.write(buf, &self.unknown_tagged_fields);
116        }
117        Ok(())
118    }
119    fn encoded_len(&self, version: i16) -> usize {
120        let flex = is_flexible(version);
121        let mut n: usize = 0;
122        if version >= 0 {
123            n += 1;
124        }
125        if version >= 0 {
126            n += if flex {
127                compact_nullable_string_len(self.resource_name_filter)
128            } else {
129                nullable_string_len(self.resource_name_filter)
130            };
131        }
132        if version >= 1 {
133            n += 1;
134        }
135        if version >= 0 {
136            n += if flex {
137                compact_nullable_string_len(self.principal_filter)
138            } else {
139                nullable_string_len(self.principal_filter)
140            };
141        }
142        if version >= 0 {
143            n += if flex {
144                compact_nullable_string_len(self.host_filter)
145            } else {
146                nullable_string_len(self.host_filter)
147            };
148        }
149        if version >= 0 {
150            n += 1;
151        }
152        if version >= 0 {
153            n += 1;
154        }
155        if flex {
156            let known_pairs: Vec<(u32, usize)> = Vec::new();
157            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
158        }
159        n
160    }
161}
162impl<'de> DecodeBorrow<'de> for DescribeAclsRequest<'de> {
163    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
164        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
165            return Err(ProtocolError::UnsupportedVersion {
166                api_key: API_KEY,
167                version,
168            });
169        }
170        let flex = is_flexible(version);
171        let mut out = Self::default();
172        if version >= 0 {
173            out.resource_type_filter = get_i8(buf)?;
174        }
175        if version >= 0 {
176            out.resource_name_filter = if flex {
177                get_compact_nullable_string_borrowed(buf)?
178            } else {
179                get_nullable_string_borrowed(buf)?
180            };
181        }
182        if version >= 1 {
183            out.pattern_type_filter = get_i8(buf)?;
184        }
185        if version >= 0 {
186            out.principal_filter = if flex {
187                get_compact_nullable_string_borrowed(buf)?
188            } else {
189                get_nullable_string_borrowed(buf)?
190            };
191        }
192        if version >= 0 {
193            out.host_filter = if flex {
194                get_compact_nullable_string_borrowed(buf)?
195            } else {
196                get_nullable_string_borrowed(buf)?
197            };
198        }
199        if version >= 0 {
200            out.operation = get_i8(buf)?;
201        }
202        if version >= 0 {
203            out.permission_type = get_i8(buf)?;
204        }
205        if flex {
206            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
207        }
208        Ok(out)
209    }
210}
211#[cfg(test)]
212impl DescribeAclsRequest<'_> {
213    #[must_use]
214    pub fn populated(version: i16) -> Self {
215        let mut m = Self::default();
216        if version >= 0 {
217            m.resource_type_filter = 1i8;
218        }
219        if version >= 0 {
220            m.resource_name_filter = Some("x");
221        }
222        if version >= 1 {
223            m.pattern_type_filter = 1i8;
224        }
225        if version >= 0 {
226            m.principal_filter = Some("x");
227        }
228        if version >= 0 {
229            m.host_filter = Some("x");
230        }
231        if version >= 0 {
232            m.operation = 1i8;
233        }
234        if version >= 0 {
235            m.permission_type = 1i8;
236        }
237        m
238    }
239}