krabka_protocol/opt/rustwide/workdir/generated/
DeleteAclsResponse.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_response,
7    primitives::{
8        array::{array_len_prefix_len, get_array_len, put_array_len},
9        fixed::{get_i8, get_i16, get_i32, put_i8, put_i16, put_i32},
10        string_bytes::{
11            compact_nullable_string_len, compact_string_len, nullable_string_len,
12            put_compact_nullable_string, put_compact_string, put_nullable_string, put_string,
13            string_len,
14        },
15        string_bytes_borrowed::{
16            get_compact_nullable_string_borrowed, get_compact_string_borrowed,
17            get_nullable_string_borrowed, get_string_borrowed,
18        },
19    },
20    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
21};
22pub const API_KEY: i16 = 31;
23pub const MIN_VERSION: i16 = 1;
24pub const MAX_VERSION: i16 = 3;
25pub const FLEXIBLE_MIN: i16 = 2;
26#[inline]
27#[must_use]
28pub fn is_flexible(version: i16) -> bool {
29    version >= FLEXIBLE_MIN
30}
31#[derive(Debug, Clone, PartialEq, Eq, Default)]
32pub struct DeleteAclsResponse<'a> {
33    pub throttle_time_ms: i32,
34    pub filter_results: Vec<DeleteAclsFilterResult<'a>>,
35    pub unknown_tagged_fields: UnknownTaggedFields,
36}
37impl DeleteAclsResponse<'_> {
38    #[must_use]
39    pub fn to_owned(&self) -> delete_acls_response::DeleteAclsResponse {
40        delete_acls_response::DeleteAclsResponse {
41            throttle_time_ms: (self.throttle_time_ms),
42            filter_results: (self.filter_results)
43                .iter()
44                .map(DeleteAclsFilterResult::to_owned)
45                .collect(),
46            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
47        }
48    }
49}
50impl Encode for DeleteAclsResponse<'_> {
51    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
52        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
53            return Err(ProtocolError::UnsupportedVersion {
54                api_key: API_KEY,
55                version,
56            });
57        }
58        let flex = is_flexible(version);
59        if version >= 0 {
60            put_i32(buf, self.throttle_time_ms);
61        }
62        if version >= 0 {
63            {
64                put_array_len(buf, (self.filter_results).len(), flex)?;
65                for it in &self.filter_results {
66                    it.encode(buf, version)?;
67                }
68            }
69        }
70        if flex {
71            let tagged = WriteTaggedFields::new();
72            tagged.write(buf, &self.unknown_tagged_fields)?;
73        }
74        Ok(())
75    }
76    fn encoded_len(&self, version: i16) -> usize {
77        let flex = is_flexible(version);
78        let mut n: usize = 0;
79        if version >= 0 {
80            n += 4;
81        }
82        if version >= 0 {
83            n += {
84                let prefix = array_len_prefix_len((self.filter_results).len(), flex);
85                let body: usize = (self.filter_results)
86                    .iter()
87                    .map(|it| it.encoded_len(version))
88                    .sum();
89                prefix + body
90            };
91        }
92        if flex {
93            let known_pairs: Vec<(u32, usize)> = Vec::new();
94            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
95        }
96        n
97    }
98}
99impl<'de> DecodeBorrow<'de> for DeleteAclsResponse<'de> {
100    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
101        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
102            return Err(ProtocolError::UnsupportedVersion {
103                api_key: API_KEY,
104                version,
105            });
106        }
107        let flex = is_flexible(version);
108        let mut out = Self::default();
109        if version >= 0 {
110            out.throttle_time_ms = get_i32(buf)?;
111        }
112        if version >= 0 {
113            out.filter_results = {
114                let n = get_array_len(buf, flex)?;
115                let mut v = Vec::with_capacity(n);
116                for _ in 0..n {
117                    v.push(DeleteAclsFilterResult::decode_borrow(buf, version)?);
118                }
119                v
120            };
121        }
122        if flex {
123            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
124        }
125        Ok(out)
126    }
127}
128#[cfg(test)]
129impl DeleteAclsResponse<'_> {
130    #[must_use]
131    pub fn populated(version: i16) -> Self {
132        let mut m = Self::default();
133        if version >= 0 {
134            m.throttle_time_ms = 1i32;
135        }
136        if version >= 0 {
137            m.filter_results = vec![DeleteAclsFilterResult::populated(version)];
138        }
139        m
140    }
141}
142#[derive(Debug, Clone, PartialEq, Eq)]
143pub struct DeleteAclsFilterResult<'a> {
144    pub error_code: i16,
145    pub error_message: Option<&'a str>,
146    pub matching_acls: Vec<DeleteAclsMatchingAcl<'a>>,
147    pub unknown_tagged_fields: UnknownTaggedFields,
148}
149impl Default for DeleteAclsFilterResult<'_> {
150    fn default() -> Self {
151        Self {
152            error_code: 0i16,
153            error_message: Some(""),
154            matching_acls: Vec::new(),
155            unknown_tagged_fields: UnknownTaggedFields::default(),
156        }
157    }
158}
159impl DeleteAclsFilterResult<'_> {
160    #[must_use]
161    pub fn to_owned(&self) -> delete_acls_response::DeleteAclsFilterResult {
162        delete_acls_response::DeleteAclsFilterResult {
163            error_code: (self.error_code),
164            error_message: (self.error_message).map(str::to_owned),
165            matching_acls: (self.matching_acls)
166                .iter()
167                .map(DeleteAclsMatchingAcl::to_owned)
168                .collect(),
169            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
170        }
171    }
172}
173impl Encode for DeleteAclsFilterResult<'_> {
174    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
175        let flex = version >= 2;
176        if version >= 0 {
177            put_i16(buf, self.error_code);
178        }
179        if version >= 0 {
180            if flex {
181                put_compact_nullable_string(buf, self.error_message)?;
182            } else {
183                put_nullable_string(buf, self.error_message)?;
184            }
185        }
186        if version >= 0 {
187            {
188                put_array_len(buf, (self.matching_acls).len(), flex)?;
189                for it in &self.matching_acls {
190                    it.encode(buf, version)?;
191                }
192            }
193        }
194        if flex {
195            let tagged = WriteTaggedFields::new();
196            tagged.write(buf, &self.unknown_tagged_fields)?;
197        }
198        Ok(())
199    }
200    fn encoded_len(&self, version: i16) -> usize {
201        let flex = version >= 2;
202        let mut n: usize = 0;
203        if version >= 0 {
204            n += 2;
205        }
206        if version >= 0 {
207            n += if flex {
208                compact_nullable_string_len(self.error_message)
209            } else {
210                nullable_string_len(self.error_message)
211            };
212        }
213        if version >= 0 {
214            n += {
215                let prefix = array_len_prefix_len((self.matching_acls).len(), flex);
216                let body: usize = (self.matching_acls)
217                    .iter()
218                    .map(|it| it.encoded_len(version))
219                    .sum();
220                prefix + body
221            };
222        }
223        if flex {
224            let known_pairs: Vec<(u32, usize)> = Vec::new();
225            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
226        }
227        n
228    }
229}
230impl<'de> DecodeBorrow<'de> for DeleteAclsFilterResult<'de> {
231    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
232        let flex = version >= 2;
233        let mut out = Self::default();
234        if version >= 0 {
235            out.error_code = get_i16(buf)?;
236        }
237        if version >= 0 {
238            out.error_message = if flex {
239                get_compact_nullable_string_borrowed(buf)?
240            } else {
241                get_nullable_string_borrowed(buf)?
242            };
243        }
244        if version >= 0 {
245            out.matching_acls = {
246                let n = get_array_len(buf, flex)?;
247                let mut v = Vec::with_capacity(n);
248                for _ in 0..n {
249                    v.push(DeleteAclsMatchingAcl::decode_borrow(buf, version)?);
250                }
251                v
252            };
253        }
254        if flex {
255            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
256        }
257        Ok(out)
258    }
259}
260#[cfg(test)]
261impl DeleteAclsFilterResult<'_> {
262    #[must_use]
263    pub fn populated(version: i16) -> Self {
264        let mut m = Self::default();
265        if version >= 0 {
266            m.error_code = 1i16;
267        }
268        if version >= 0 {
269            m.error_message = Some("x");
270        }
271        if version >= 0 {
272            m.matching_acls = vec![DeleteAclsMatchingAcl::populated(version)];
273        }
274        m
275    }
276}
277#[derive(Debug, Clone, PartialEq, Eq)]
278pub struct DeleteAclsMatchingAcl<'a> {
279    pub error_code: i16,
280    pub error_message: Option<&'a str>,
281    pub resource_type: i8,
282    pub resource_name: &'a str,
283    pub pattern_type: i8,
284    pub principal: &'a str,
285    pub host: &'a str,
286    pub operation: i8,
287    pub permission_type: i8,
288    pub unknown_tagged_fields: UnknownTaggedFields,
289}
290impl Default for DeleteAclsMatchingAcl<'_> {
291    fn default() -> Self {
292        Self {
293            error_code: 0i16,
294            error_message: Some(""),
295            resource_type: 0i8,
296            resource_name: "",
297            pattern_type: 3i8,
298            principal: "",
299            host: "",
300            operation: 0i8,
301            permission_type: 0i8,
302            unknown_tagged_fields: UnknownTaggedFields::default(),
303        }
304    }
305}
306impl<'a> DeleteAclsMatchingAcl<'a> {
307    #[must_use]
308    pub fn to_owned(&self) -> delete_acls_response::DeleteAclsMatchingAcl {
309        delete_acls_response::DeleteAclsMatchingAcl {
310            error_code: (self.error_code),
311            error_message: (self.error_message).map(str::to_owned),
312            resource_type: (self.resource_type),
313            resource_name: (self.resource_name).to_owned(),
314            pattern_type: (self.pattern_type),
315            principal: (self.principal).to_owned(),
316            host: (self.host).to_owned(),
317            operation: (self.operation),
318            permission_type: (self.permission_type),
319            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
320        }
321    }
322    fn encode_field_0<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
323        if version >= 0 {
324            put_i16(buf, self.error_code);
325        }
326    }
327    fn encode_field_1<B: BufMut>(
328        &self,
329        buf: &mut B,
330        version: i16,
331        flex: bool,
332    ) -> Result<(), ProtocolError> {
333        if version >= 0 {
334            if flex {
335                put_compact_nullable_string(buf, self.error_message)?;
336            } else {
337                put_nullable_string(buf, self.error_message)?;
338            }
339        }
340        Ok(())
341    }
342    fn encode_field_2<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
343        if version >= 0 {
344            put_i8(buf, self.resource_type);
345        }
346    }
347    fn encode_field_3<B: BufMut>(
348        &self,
349        buf: &mut B,
350        version: i16,
351        flex: bool,
352    ) -> Result<(), ProtocolError> {
353        if version >= 0 {
354            if flex {
355                put_compact_string(buf, self.resource_name)?;
356            } else {
357                put_string(buf, self.resource_name)?;
358            }
359        }
360        Ok(())
361    }
362    fn encode_field_4<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
363        if version >= 1 {
364            put_i8(buf, self.pattern_type);
365        }
366    }
367    fn encode_field_5<B: BufMut>(
368        &self,
369        buf: &mut B,
370        version: i16,
371        flex: bool,
372    ) -> Result<(), ProtocolError> {
373        if version >= 0 {
374            if flex {
375                put_compact_string(buf, self.principal)?;
376            } else {
377                put_string(buf, self.principal)?;
378            }
379        }
380        Ok(())
381    }
382    fn encode_field_6<B: BufMut>(
383        &self,
384        buf: &mut B,
385        version: i16,
386        flex: bool,
387    ) -> Result<(), ProtocolError> {
388        if version >= 0 {
389            if flex {
390                put_compact_string(buf, self.host)?;
391            } else {
392                put_string(buf, self.host)?;
393            }
394        }
395        Ok(())
396    }
397    fn encode_field_7<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
398        if version >= 0 {
399            put_i8(buf, self.operation);
400        }
401    }
402    fn encode_field_8<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
403        if version >= 0 {
404            put_i8(buf, self.permission_type);
405        }
406    }
407    fn encode_tagged_fields<B: BufMut>(
408        &self,
409        buf: &mut B,
410        _version: i16,
411        flex: bool,
412    ) -> Result<(), ProtocolError> {
413        if flex {
414            let tagged = WriteTaggedFields::new();
415            tagged.write(buf, &self.unknown_tagged_fields)?;
416        }
417        Ok(())
418    }
419    fn decode_field_0(
420        out: &mut Self,
421        buf: &mut &'a [u8],
422        version: i16,
423        _flex: bool,
424    ) -> Result<(), ProtocolError> {
425        if version >= 0 {
426            out.error_code = get_i16(buf)?;
427        }
428        Ok(())
429    }
430    fn decode_field_1(
431        out: &mut Self,
432        buf: &mut &'a [u8],
433        version: i16,
434        flex: bool,
435    ) -> Result<(), ProtocolError> {
436        if version >= 0 {
437            out.error_message = if flex {
438                get_compact_nullable_string_borrowed(buf)?
439            } else {
440                get_nullable_string_borrowed(buf)?
441            };
442        }
443        Ok(())
444    }
445    fn decode_field_2(
446        out: &mut Self,
447        buf: &mut &'a [u8],
448        version: i16,
449        _flex: bool,
450    ) -> Result<(), ProtocolError> {
451        if version >= 0 {
452            out.resource_type = get_i8(buf)?;
453        }
454        Ok(())
455    }
456    fn decode_field_3(
457        out: &mut Self,
458        buf: &mut &'a [u8],
459        version: i16,
460        flex: bool,
461    ) -> Result<(), ProtocolError> {
462        if version >= 0 {
463            out.resource_name = if flex {
464                get_compact_string_borrowed(buf)?
465            } else {
466                get_string_borrowed(buf)?
467            };
468        }
469        Ok(())
470    }
471    fn decode_field_4(
472        out: &mut Self,
473        buf: &mut &'a [u8],
474        version: i16,
475        _flex: bool,
476    ) -> Result<(), ProtocolError> {
477        if version >= 1 {
478            out.pattern_type = get_i8(buf)?;
479        }
480        Ok(())
481    }
482    fn decode_field_5(
483        out: &mut Self,
484        buf: &mut &'a [u8],
485        version: i16,
486        flex: bool,
487    ) -> Result<(), ProtocolError> {
488        if version >= 0 {
489            out.principal = if flex {
490                get_compact_string_borrowed(buf)?
491            } else {
492                get_string_borrowed(buf)?
493            };
494        }
495        Ok(())
496    }
497    fn decode_field_6(
498        out: &mut Self,
499        buf: &mut &'a [u8],
500        version: i16,
501        flex: bool,
502    ) -> Result<(), ProtocolError> {
503        if version >= 0 {
504            out.host = if flex {
505                get_compact_string_borrowed(buf)?
506            } else {
507                get_string_borrowed(buf)?
508            };
509        }
510        Ok(())
511    }
512    fn decode_field_7(
513        out: &mut Self,
514        buf: &mut &'a [u8],
515        version: i16,
516        _flex: bool,
517    ) -> Result<(), ProtocolError> {
518        if version >= 0 {
519            out.operation = get_i8(buf)?;
520        }
521        Ok(())
522    }
523    fn decode_field_8(
524        out: &mut Self,
525        buf: &mut &'a [u8],
526        version: i16,
527        _flex: bool,
528    ) -> Result<(), ProtocolError> {
529        if version >= 0 {
530            out.permission_type = get_i8(buf)?;
531        }
532        Ok(())
533    }
534    fn decode_tagged_fields(
535        out: &mut Self,
536        buf: &mut &'a [u8],
537        _version: i16,
538        flex: bool,
539    ) -> Result<(), ProtocolError> {
540        if flex {
541            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
542        }
543        Ok(())
544    }
545}
546impl Encode for DeleteAclsMatchingAcl<'_> {
547    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
548        let flex = version >= 2;
549        self.encode_field_0(buf, version, flex);
550        self.encode_field_1(buf, version, flex)?;
551        self.encode_field_2(buf, version, flex);
552        self.encode_field_3(buf, version, flex)?;
553        self.encode_field_4(buf, version, flex);
554        self.encode_field_5(buf, version, flex)?;
555        self.encode_field_6(buf, version, flex)?;
556        self.encode_field_7(buf, version, flex);
557        self.encode_field_8(buf, version, flex);
558        self.encode_tagged_fields(buf, version, flex)?;
559        Ok(())
560    }
561    fn encoded_len(&self, version: i16) -> usize {
562        let flex = version >= 2;
563        let mut n: usize = 0;
564        if version >= 0 {
565            n += 2;
566        }
567        if version >= 0 {
568            n += if flex {
569                compact_nullable_string_len(self.error_message)
570            } else {
571                nullable_string_len(self.error_message)
572            };
573        }
574        if version >= 0 {
575            n += 1;
576        }
577        if version >= 0 {
578            n += if flex {
579                compact_string_len(self.resource_name)
580            } else {
581                string_len(self.resource_name)
582            };
583        }
584        if version >= 1 {
585            n += 1;
586        }
587        if version >= 0 {
588            n += if flex {
589                compact_string_len(self.principal)
590            } else {
591                string_len(self.principal)
592            };
593        }
594        if version >= 0 {
595            n += if flex {
596                compact_string_len(self.host)
597            } else {
598                string_len(self.host)
599            };
600        }
601        if version >= 0 {
602            n += 1;
603        }
604        if version >= 0 {
605            n += 1;
606        }
607        if flex {
608            let known_pairs: Vec<(u32, usize)> = Vec::new();
609            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
610        }
611        n
612    }
613}
614impl<'de> DecodeBorrow<'de> for DeleteAclsMatchingAcl<'de> {
615    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
616        let flex = version >= 2;
617        let mut out = Self::default();
618        Self::decode_field_0(&mut out, buf, version, flex)?;
619        Self::decode_field_1(&mut out, buf, version, flex)?;
620        Self::decode_field_2(&mut out, buf, version, flex)?;
621        Self::decode_field_3(&mut out, buf, version, flex)?;
622        Self::decode_field_4(&mut out, buf, version, flex)?;
623        Self::decode_field_5(&mut out, buf, version, flex)?;
624        Self::decode_field_6(&mut out, buf, version, flex)?;
625        Self::decode_field_7(&mut out, buf, version, flex)?;
626        Self::decode_field_8(&mut out, buf, version, flex)?;
627        Self::decode_tagged_fields(&mut out, buf, version, flex)?;
628        Ok(out)
629    }
630}
631#[cfg(test)]
632impl DeleteAclsMatchingAcl<'_> {
633    #[must_use]
634    pub fn populated(version: i16) -> Self {
635        let mut m = Self::default();
636        if version >= 0 {
637            m.error_code = 1i16;
638        }
639        if version >= 0 {
640            m.error_message = Some("x");
641        }
642        if version >= 0 {
643            m.resource_type = 1i8;
644        }
645        if version >= 0 {
646            m.resource_name = "x";
647        }
648        if version >= 1 {
649            m.pattern_type = 1i8;
650        }
651        if version >= 0 {
652            m.principal = "x";
653        }
654        if version >= 0 {
655            m.host = "x";
656        }
657        if version >= 0 {
658            m.operation = 1i8;
659        }
660        if version >= 0 {
661            m.permission_type = 1i8;
662        }
663        m
664    }
665}
krabka_protocol/opt/rustwide/workdir/generated/DeleteAclsResponse.borrowed.rs

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