krabka_protocol/opt/rustwide/workdir/generated/
CreateDelegationTokenResponse.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 = 38;
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 CreateDelegationTokenResponse<'a> {
30    pub error_code: i16,
31    pub principal_type: &'a str,
32    pub principal_name: &'a str,
33    pub token_requester_principal_type: &'a str,
34    pub token_requester_principal_name: &'a str,
35    pub issue_timestamp_ms: i64,
36    pub expiry_timestamp_ms: i64,
37    pub max_timestamp_ms: i64,
38    pub token_id: &'a str,
39    pub hmac: &'a [u8],
40    pub throttle_time_ms: i32,
41    pub unknown_tagged_fields: UnknownTaggedFields,
42}
43impl<'a> CreateDelegationTokenResponse<'a> {
44    /// # Panics
45    ///
46    /// Panics if a records field contains an invalid encoded record batch.
47    #[must_use]
48    pub fn to_owned(
49        &self,
50    ) -> crate::owned::create_delegation_token_response::CreateDelegationTokenResponse {
51        crate::owned::create_delegation_token_response::CreateDelegationTokenResponse {
52            error_code: (self.error_code),
53            principal_type: (self.principal_type).to_string(),
54            principal_name: (self.principal_name).to_string(),
55            token_requester_principal_type: (self.token_requester_principal_type).to_string(),
56            token_requester_principal_name: (self.token_requester_principal_name).to_string(),
57            issue_timestamp_ms: (self.issue_timestamp_ms),
58            expiry_timestamp_ms: (self.expiry_timestamp_ms),
59            max_timestamp_ms: (self.max_timestamp_ms),
60            token_id: (self.token_id).to_string(),
61            hmac: Bytes::copy_from_slice(self.hmac),
62            throttle_time_ms: (self.throttle_time_ms),
63            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
64        }
65    }
66    fn encode_field_0<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
67        if version >= 0 {
68            put_i16(buf, self.error_code);
69        }
70    }
71    fn encode_field_1<B: BufMut>(&self, buf: &mut B, version: i16, flex: bool) {
72        if version >= 0 {
73            if flex {
74                let () = put_compact_string(buf, self.principal_type);
75            } else {
76                let () = put_string(buf, self.principal_type);
77            }
78        }
79    }
80    fn encode_field_2<B: BufMut>(&self, buf: &mut B, version: i16, flex: bool) {
81        if version >= 0 {
82            if flex {
83                let () = put_compact_string(buf, self.principal_name);
84            } else {
85                let () = put_string(buf, self.principal_name);
86            }
87        }
88    }
89    fn encode_field_3<B: BufMut>(&self, buf: &mut B, version: i16, flex: bool) {
90        if version >= 3 {
91            if flex {
92                let () = put_compact_string(buf, self.token_requester_principal_type);
93            } else {
94                let () = put_string(buf, self.token_requester_principal_type);
95            }
96        }
97    }
98    fn encode_field_4<B: BufMut>(&self, buf: &mut B, version: i16, flex: bool) {
99        if version >= 3 {
100            if flex {
101                let () = put_compact_string(buf, self.token_requester_principal_name);
102            } else {
103                let () = put_string(buf, self.token_requester_principal_name);
104            }
105        }
106    }
107    fn encode_field_5<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
108        if version >= 0 {
109            put_i64(buf, self.issue_timestamp_ms);
110        }
111    }
112    fn encode_field_6<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
113        if version >= 0 {
114            put_i64(buf, self.expiry_timestamp_ms);
115        }
116    }
117    fn encode_field_7<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
118        if version >= 0 {
119            put_i64(buf, self.max_timestamp_ms);
120        }
121    }
122    fn encode_field_8<B: BufMut>(&self, buf: &mut B, version: i16, flex: bool) {
123        if version >= 0 {
124            if flex {
125                let () = put_compact_string(buf, self.token_id);
126            } else {
127                let () = put_string(buf, self.token_id);
128            }
129        }
130    }
131    fn encode_field_9<B: BufMut>(&self, buf: &mut B, version: i16, flex: bool) {
132        if version >= 0 {
133            if flex {
134                let () = put_compact_bytes(buf, self.hmac);
135            } else {
136                let () = put_bytes(buf, self.hmac);
137            }
138        }
139    }
140    fn encode_field_10<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
141        if version >= 0 {
142            put_i32(buf, self.throttle_time_ms);
143        }
144    }
145    fn encode_tagged_fields<B: BufMut>(&self, buf: &mut B, _version: i16, flex: bool) {
146        if flex {
147            let tagged = WriteTaggedFields::new();
148            tagged.write(buf, &self.unknown_tagged_fields);
149        }
150    }
151    fn decode_field_0(
152        out: &mut Self,
153        buf: &mut &'a [u8],
154        version: i16,
155        _flex: bool,
156    ) -> Result<(), ProtocolError> {
157        if version >= 0 {
158            out.error_code = get_i16(buf)?;
159        }
160        Ok(())
161    }
162    fn decode_field_1(
163        out: &mut Self,
164        buf: &mut &'a [u8],
165        version: i16,
166        flex: bool,
167    ) -> Result<(), ProtocolError> {
168        if version >= 0 {
169            out.principal_type = if flex {
170                get_compact_string_borrowed(buf)?
171            } else {
172                get_string_borrowed(buf)?
173            };
174        }
175        Ok(())
176    }
177    fn decode_field_2(
178        out: &mut Self,
179        buf: &mut &'a [u8],
180        version: i16,
181        flex: bool,
182    ) -> Result<(), ProtocolError> {
183        if version >= 0 {
184            out.principal_name = if flex {
185                get_compact_string_borrowed(buf)?
186            } else {
187                get_string_borrowed(buf)?
188            };
189        }
190        Ok(())
191    }
192    fn decode_field_3(
193        out: &mut Self,
194        buf: &mut &'a [u8],
195        version: i16,
196        flex: bool,
197    ) -> Result<(), ProtocolError> {
198        if version >= 3 {
199            out.token_requester_principal_type = if flex {
200                get_compact_string_borrowed(buf)?
201            } else {
202                get_string_borrowed(buf)?
203            };
204        }
205        Ok(())
206    }
207    fn decode_field_4(
208        out: &mut Self,
209        buf: &mut &'a [u8],
210        version: i16,
211        flex: bool,
212    ) -> Result<(), ProtocolError> {
213        if version >= 3 {
214            out.token_requester_principal_name = if flex {
215                get_compact_string_borrowed(buf)?
216            } else {
217                get_string_borrowed(buf)?
218            };
219        }
220        Ok(())
221    }
222    fn decode_field_5(
223        out: &mut Self,
224        buf: &mut &'a [u8],
225        version: i16,
226        _flex: bool,
227    ) -> Result<(), ProtocolError> {
228        if version >= 0 {
229            out.issue_timestamp_ms = get_i64(buf)?;
230        }
231        Ok(())
232    }
233    fn decode_field_6(
234        out: &mut Self,
235        buf: &mut &'a [u8],
236        version: i16,
237        _flex: bool,
238    ) -> Result<(), ProtocolError> {
239        if version >= 0 {
240            out.expiry_timestamp_ms = get_i64(buf)?;
241        }
242        Ok(())
243    }
244    fn decode_field_7(
245        out: &mut Self,
246        buf: &mut &'a [u8],
247        version: i16,
248        _flex: bool,
249    ) -> Result<(), ProtocolError> {
250        if version >= 0 {
251            out.max_timestamp_ms = get_i64(buf)?;
252        }
253        Ok(())
254    }
255    fn decode_field_8(
256        out: &mut Self,
257        buf: &mut &'a [u8],
258        version: i16,
259        flex: bool,
260    ) -> Result<(), ProtocolError> {
261        if version >= 0 {
262            out.token_id = if flex {
263                get_compact_string_borrowed(buf)?
264            } else {
265                get_string_borrowed(buf)?
266            };
267        }
268        Ok(())
269    }
270    fn decode_field_9(
271        out: &mut Self,
272        buf: &mut &'a [u8],
273        version: i16,
274        flex: bool,
275    ) -> Result<(), ProtocolError> {
276        if version >= 0 {
277            out.hmac = if flex {
278                get_compact_bytes_borrowed(buf)?
279            } else {
280                get_bytes_borrowed(buf)?
281            };
282        }
283        Ok(())
284    }
285    fn decode_field_10(
286        out: &mut Self,
287        buf: &mut &'a [u8],
288        version: i16,
289        _flex: bool,
290    ) -> Result<(), ProtocolError> {
291        if version >= 0 {
292            out.throttle_time_ms = get_i32(buf)?;
293        }
294        Ok(())
295    }
296    fn decode_tagged_fields(
297        out: &mut Self,
298        buf: &mut &'a [u8],
299        _version: i16,
300        flex: bool,
301    ) -> Result<(), ProtocolError> {
302        if flex {
303            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
304        }
305        Ok(())
306    }
307}
308impl Encode for CreateDelegationTokenResponse<'_> {
309    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
310        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
311            return Err(ProtocolError::UnsupportedVersion {
312                api_key: API_KEY,
313                version,
314            });
315        }
316        let flex = is_flexible(version);
317        self.encode_field_0(buf, version, flex);
318        self.encode_field_1(buf, version, flex);
319        self.encode_field_2(buf, version, flex);
320        self.encode_field_3(buf, version, flex);
321        self.encode_field_4(buf, version, flex);
322        self.encode_field_5(buf, version, flex);
323        self.encode_field_6(buf, version, flex);
324        self.encode_field_7(buf, version, flex);
325        self.encode_field_8(buf, version, flex);
326        self.encode_field_9(buf, version, flex);
327        self.encode_field_10(buf, version, flex);
328        self.encode_tagged_fields(buf, version, flex);
329        Ok(())
330    }
331    fn encoded_len(&self, version: i16) -> usize {
332        let flex = is_flexible(version);
333        let mut n: usize = 0;
334        if version >= 0 {
335            n += 2;
336        }
337        if version >= 0 {
338            n += if flex {
339                compact_string_len(self.principal_type)
340            } else {
341                string_len(self.principal_type)
342            };
343        }
344        if version >= 0 {
345            n += if flex {
346                compact_string_len(self.principal_name)
347            } else {
348                string_len(self.principal_name)
349            };
350        }
351        if version >= 3 {
352            n += if flex {
353                compact_string_len(self.token_requester_principal_type)
354            } else {
355                string_len(self.token_requester_principal_type)
356            };
357        }
358        if version >= 3 {
359            n += if flex {
360                compact_string_len(self.token_requester_principal_name)
361            } else {
362                string_len(self.token_requester_principal_name)
363            };
364        }
365        if version >= 0 {
366            n += 8;
367        }
368        if version >= 0 {
369            n += 8;
370        }
371        if version >= 0 {
372            n += 8;
373        }
374        if version >= 0 {
375            n += if flex {
376                compact_string_len(self.token_id)
377            } else {
378                string_len(self.token_id)
379            };
380        }
381        if version >= 0 {
382            n += if flex {
383                crate::primitives::varint::uvarint_len(
384                    u32::try_from((self.hmac).len() + 1).unwrap(),
385                ) + (self.hmac).len()
386            } else {
387                4 + (self.hmac).len()
388            };
389        }
390        if version >= 0 {
391            n += 4;
392        }
393        if flex {
394            let known_pairs: Vec<(u32, usize)> = Vec::new();
395            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
396        }
397        n
398    }
399}
400impl<'de> DecodeBorrow<'de> for CreateDelegationTokenResponse<'de> {
401    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
402        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
403            return Err(ProtocolError::UnsupportedVersion {
404                api_key: API_KEY,
405                version,
406            });
407        }
408        let flex = is_flexible(version);
409        let mut out = Self::default();
410        Self::decode_field_0(&mut out, buf, version, flex)?;
411        Self::decode_field_1(&mut out, buf, version, flex)?;
412        Self::decode_field_2(&mut out, buf, version, flex)?;
413        Self::decode_field_3(&mut out, buf, version, flex)?;
414        Self::decode_field_4(&mut out, buf, version, flex)?;
415        Self::decode_field_5(&mut out, buf, version, flex)?;
416        Self::decode_field_6(&mut out, buf, version, flex)?;
417        Self::decode_field_7(&mut out, buf, version, flex)?;
418        Self::decode_field_8(&mut out, buf, version, flex)?;
419        Self::decode_field_9(&mut out, buf, version, flex)?;
420        Self::decode_field_10(&mut out, buf, version, flex)?;
421        Self::decode_tagged_fields(&mut out, buf, version, flex)?;
422        Ok(out)
423    }
424}
425#[cfg(test)]
426impl CreateDelegationTokenResponse<'_> {
427    #[must_use]
428    pub fn populated(version: i16) -> Self {
429        let mut m = Self::default();
430        if version >= 0 {
431            m.error_code = 1i16;
432        }
433        if version >= 0 {
434            m.principal_type = "x";
435        }
436        if version >= 0 {
437            m.principal_name = "x";
438        }
439        if version >= 3 {
440            m.token_requester_principal_type = "x";
441        }
442        if version >= 3 {
443            m.token_requester_principal_name = "x";
444        }
445        if version >= 0 {
446            m.issue_timestamp_ms = 1i64;
447        }
448        if version >= 0 {
449            m.expiry_timestamp_ms = 1i64;
450        }
451        if version >= 0 {
452            m.max_timestamp_ms = 1i64;
453        }
454        if version >= 0 {
455            m.token_id = "x";
456        }
457        if version >= 0 {
458            m.hmac = &b"x"[..];
459        }
460        if version >= 0 {
461            m.throttle_time_ms = 1i32;
462        }
463        m
464    }
465}
krabka_protocol/opt/rustwide/workdir/generated/CreateDelegationTokenResponse.borrowed.rs

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