krabka_protocol/opt/rustwide/workdir/generated/
DescribeAclsRequest.borrowed.rs1use 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 #[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}