krabka_protocol/opt/rustwide/workdir/generated/
DeleteAclsRequest.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    owned::delete_acls_request,
7    primitives::{
8        array::{array_len_prefix_len, get_array_len, put_array_len},
9        fixed::{get_i8, put_i8},
10        string_bytes::{
11            compact_nullable_string_len, nullable_string_len, put_compact_nullable_string,
12            put_nullable_string,
13        },
14        string_bytes_borrowed::{
15            get_compact_nullable_string_borrowed, get_nullable_string_borrowed,
16        },
17    },
18    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
19};
20pub const API_KEY: i16 = 31;
21pub const MIN_VERSION: i16 = 1;
22pub const MAX_VERSION: i16 = 3;
23pub const LATEST_STABLE_VERSION: i16 = 3;
24pub const FLEXIBLE_MIN: i16 = 2;
25#[inline]
26#[must_use]
27pub fn is_flexible(version: i16) -> bool {
28    version >= FLEXIBLE_MIN
29}
30#[derive(Debug, Clone, PartialEq, Eq, Default)]
31pub struct DeleteAclsRequest<'a> {
32    pub filters: Vec<DeleteAclsFilter<'a>>,
33    pub unknown_tagged_fields: UnknownTaggedFields,
34}
35impl DeleteAclsRequest<'_> {
36    #[must_use]
37    pub fn to_owned(&self) -> delete_acls_request::DeleteAclsRequest {
38        delete_acls_request::DeleteAclsRequest {
39            filters: (self.filters)
40                .iter()
41                .map(DeleteAclsFilter::to_owned)
42                .collect(),
43            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
44        }
45    }
46}
47impl Encode for DeleteAclsRequest<'_> {
48    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
49        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
50            return Err(ProtocolError::UnsupportedVersion {
51                api_key: API_KEY,
52                version,
53            });
54        }
55        let flex = is_flexible(version);
56        if version >= 0 {
57            {
58                put_array_len(buf, (self.filters).len(), flex)?;
59                for it in &self.filters {
60                    it.encode(buf, version)?;
61                }
62            }
63        }
64        if flex {
65            let tagged = WriteTaggedFields::new();
66            tagged.write(buf, &self.unknown_tagged_fields)?;
67        }
68        Ok(())
69    }
70    fn encoded_len(&self, version: i16) -> usize {
71        let flex = is_flexible(version);
72        let mut n: usize = 0;
73        if version >= 0 {
74            n += {
75                let prefix = array_len_prefix_len((self.filters).len(), flex);
76                let body: usize = (self.filters)
77                    .iter()
78                    .map(|it| it.encoded_len(version))
79                    .sum();
80                prefix + body
81            };
82        }
83        if flex {
84            let known_pairs: Vec<(u32, usize)> = Vec::new();
85            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
86        }
87        n
88    }
89}
90impl<'de> DecodeBorrow<'de> for DeleteAclsRequest<'de> {
91    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
92        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
93            return Err(ProtocolError::UnsupportedVersion {
94                api_key: API_KEY,
95                version,
96            });
97        }
98        let flex = is_flexible(version);
99        let mut out = Self::default();
100        if version >= 0 {
101            out.filters = {
102                let n = get_array_len(buf, flex)?;
103                let mut v = Vec::with_capacity(n);
104                for _ in 0..n {
105                    v.push(DeleteAclsFilter::decode_borrow(buf, version)?);
106                }
107                v
108            };
109        }
110        if flex {
111            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
112        }
113        Ok(out)
114    }
115}
116#[cfg(test)]
117impl DeleteAclsRequest<'_> {
118    #[must_use]
119    pub fn populated(version: i16) -> Self {
120        let mut m = Self::default();
121        if version >= 0 {
122            m.filters = vec![DeleteAclsFilter::populated(version)];
123        }
124        m
125    }
126}
127#[derive(Debug, Clone, PartialEq, Eq)]
128pub struct DeleteAclsFilter<'a> {
129    pub resource_type_filter: i8,
130    pub resource_name_filter: Option<&'a str>,
131    pub pattern_type_filter: i8,
132    pub principal_filter: Option<&'a str>,
133    pub host_filter: Option<&'a str>,
134    pub operation: i8,
135    pub permission_type: i8,
136    pub unknown_tagged_fields: UnknownTaggedFields,
137}
138impl Default for DeleteAclsFilter<'_> {
139    fn default() -> Self {
140        Self {
141            resource_type_filter: 0i8,
142            resource_name_filter: Some(""),
143            pattern_type_filter: 3i8,
144            principal_filter: Some(""),
145            host_filter: Some(""),
146            operation: 0i8,
147            permission_type: 0i8,
148            unknown_tagged_fields: UnknownTaggedFields::default(),
149        }
150    }
151}
152impl DeleteAclsFilter<'_> {
153    #[must_use]
154    pub fn to_owned(&self) -> delete_acls_request::DeleteAclsFilter {
155        delete_acls_request::DeleteAclsFilter {
156            resource_type_filter: (self.resource_type_filter),
157            resource_name_filter: (self.resource_name_filter).map(str::to_owned),
158            pattern_type_filter: (self.pattern_type_filter),
159            principal_filter: (self.principal_filter).map(str::to_owned),
160            host_filter: (self.host_filter).map(str::to_owned),
161            operation: (self.operation),
162            permission_type: (self.permission_type),
163            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
164        }
165    }
166}
167impl Encode for DeleteAclsFilter<'_> {
168    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
169        let flex = version >= 2;
170        if version >= 0 {
171            put_i8(buf, self.resource_type_filter);
172        }
173        if version >= 0 {
174            if flex {
175                put_compact_nullable_string(buf, self.resource_name_filter)?;
176            } else {
177                put_nullable_string(buf, self.resource_name_filter)?;
178            }
179        }
180        if version >= 1 {
181            put_i8(buf, self.pattern_type_filter);
182        }
183        if version >= 0 {
184            if flex {
185                put_compact_nullable_string(buf, self.principal_filter)?;
186            } else {
187                put_nullable_string(buf, self.principal_filter)?;
188            }
189        }
190        if version >= 0 {
191            if flex {
192                put_compact_nullable_string(buf, self.host_filter)?;
193            } else {
194                put_nullable_string(buf, self.host_filter)?;
195            }
196        }
197        if version >= 0 {
198            put_i8(buf, self.operation);
199        }
200        if version >= 0 {
201            put_i8(buf, self.permission_type);
202        }
203        if flex {
204            let tagged = WriteTaggedFields::new();
205            tagged.write(buf, &self.unknown_tagged_fields)?;
206        }
207        Ok(())
208    }
209    fn encoded_len(&self, version: i16) -> usize {
210        let flex = version >= 2;
211        let mut n: usize = 0;
212        if version >= 0 {
213            n += 1;
214        }
215        if version >= 0 {
216            n += if flex {
217                compact_nullable_string_len(self.resource_name_filter)
218            } else {
219                nullable_string_len(self.resource_name_filter)
220            };
221        }
222        if version >= 1 {
223            n += 1;
224        }
225        if version >= 0 {
226            n += if flex {
227                compact_nullable_string_len(self.principal_filter)
228            } else {
229                nullable_string_len(self.principal_filter)
230            };
231        }
232        if version >= 0 {
233            n += if flex {
234                compact_nullable_string_len(self.host_filter)
235            } else {
236                nullable_string_len(self.host_filter)
237            };
238        }
239        if version >= 0 {
240            n += 1;
241        }
242        if version >= 0 {
243            n += 1;
244        }
245        if flex {
246            let known_pairs: Vec<(u32, usize)> = Vec::new();
247            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
248        }
249        n
250    }
251}
252impl<'de> DecodeBorrow<'de> for DeleteAclsFilter<'de> {
253    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
254        let flex = version >= 2;
255        let mut out = Self::default();
256        if version >= 0 {
257            out.resource_type_filter = get_i8(buf)?;
258        }
259        if version >= 0 {
260            out.resource_name_filter = if flex {
261                get_compact_nullable_string_borrowed(buf)?
262            } else {
263                get_nullable_string_borrowed(buf)?
264            };
265        }
266        if version >= 1 {
267            out.pattern_type_filter = get_i8(buf)?;
268        }
269        if version >= 0 {
270            out.principal_filter = if flex {
271                get_compact_nullable_string_borrowed(buf)?
272            } else {
273                get_nullable_string_borrowed(buf)?
274            };
275        }
276        if version >= 0 {
277            out.host_filter = if flex {
278                get_compact_nullable_string_borrowed(buf)?
279            } else {
280                get_nullable_string_borrowed(buf)?
281            };
282        }
283        if version >= 0 {
284            out.operation = get_i8(buf)?;
285        }
286        if version >= 0 {
287            out.permission_type = get_i8(buf)?;
288        }
289        if flex {
290            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
291        }
292        Ok(out)
293    }
294}
295#[cfg(test)]
296impl DeleteAclsFilter<'_> {
297    #[must_use]
298    pub fn populated(version: i16) -> Self {
299        let mut m = Self::default();
300        if version >= 0 {
301            m.resource_type_filter = 1i8;
302        }
303        if version >= 0 {
304            m.resource_name_filter = Some("x");
305        }
306        if version >= 1 {
307            m.pattern_type_filter = 1i8;
308        }
309        if version >= 0 {
310            m.principal_filter = Some("x");
311        }
312        if version >= 0 {
313            m.host_filter = Some("x");
314        }
315        if version >= 0 {
316            m.operation = 1i8;
317        }
318        if version >= 0 {
319            m.permission_type = 1i8;
320        }
321        m
322    }
323}
krabka_protocol/opt/rustwide/workdir/generated/DeleteAclsRequest.borrowed.rs

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