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