Skip to main content

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

1// AUTO-GENERATED by crabka-protocol-codegen against a9ce3221537b8653448750697915607dc7936cf3. Do not edit.
2
3use 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}