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

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