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.
2use 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}