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