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

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