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

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

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