crabka_protocol/opt/rustwide/workdir/generated/
RenewDelegationTokenResponse.borrowed.rs1use crate::primitives::fixed::{get_i16, get_i32, get_i64, put_i16, put_i32, put_i64};
3use crate::tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len};
4use crate::{DecodeBorrow, Encode, ProtocolError, UnknownTaggedFields};
5use bytes::BufMut;
6pub const API_KEY: i16 = 39;
7pub const MIN_VERSION: i16 = 1;
8pub const MAX_VERSION: i16 = 2;
9pub const FLEXIBLE_MIN: i16 = 2;
10#[inline]
11fn is_flexible(version: i16) -> bool {
12 version >= FLEXIBLE_MIN
13}
14#[derive(Debug, Clone, PartialEq, Eq, Default)]
15pub struct RenewDelegationTokenResponse {
16 pub error_code: i16,
17 pub expiry_timestamp_ms: i64,
18 pub throttle_time_ms: i32,
19 pub unknown_tagged_fields: UnknownTaggedFields,
20}
21impl RenewDelegationTokenResponse {
22 pub fn to_owned(
23 &self,
24 ) -> crate::owned::renew_delegation_token_response::RenewDelegationTokenResponse {
25 crate::owned::renew_delegation_token_response::RenewDelegationTokenResponse {
26 error_code: (self.error_code),
27 expiry_timestamp_ms: (self.expiry_timestamp_ms),
28 throttle_time_ms: (self.throttle_time_ms),
29 unknown_tagged_fields: self.unknown_tagged_fields.clone(),
30 }
31 }
32}
33impl Encode for RenewDelegationTokenResponse {
34 fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
35 if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
36 return Err(ProtocolError::UnsupportedVersion {
37 api_key: API_KEY,
38 version,
39 });
40 }
41 let flex = is_flexible(version);
42 if version >= 0 {
43 put_i16(buf, self.error_code);
44 }
45 if version >= 0 {
46 put_i64(buf, self.expiry_timestamp_ms);
47 }
48 if version >= 0 {
49 put_i32(buf, self.throttle_time_ms);
50 }
51 if flex {
52 let tagged = WriteTaggedFields::new();
53 tagged.write(buf, &self.unknown_tagged_fields);
54 }
55 Ok(())
56 }
57 fn encoded_len(&self, version: i16) -> usize {
58 let flex = is_flexible(version);
59 let mut n: usize = 0;
60 if version >= 0 {
61 n += 2;
62 }
63 if version >= 0 {
64 n += 8;
65 }
66 if version >= 0 {
67 n += 4;
68 }
69 if flex {
70 let known_pairs: Vec<(u32, usize)> = Vec::new();
71 n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
72 }
73 n
74 }
75}
76impl<'de> DecodeBorrow<'de> for RenewDelegationTokenResponse {
77 fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
78 if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
79 return Err(ProtocolError::UnsupportedVersion {
80 api_key: API_KEY,
81 version,
82 });
83 }
84 let flex = is_flexible(version);
85 let mut out = Self::default();
86 if version >= 0 {
87 out.error_code = get_i16(buf)?;
88 }
89 if version >= 0 {
90 out.expiry_timestamp_ms = get_i64(buf)?;
91 }
92 if version >= 0 {
93 out.throttle_time_ms = get_i32(buf)?;
94 }
95 if flex {
96 out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
97 }
98 Ok(out)
99 }
100}
101#[cfg(test)]
102impl RenewDelegationTokenResponse {
103 #[must_use]
104 pub fn populated(version: i16) -> Self {
105 let mut m = Self::default();
106 if version >= 0 {
107 m.error_code = 1i16;
108 }
109 if version >= 0 {
110 m.expiry_timestamp_ms = 1i64;
111 }
112 if version >= 0 {
113 m.throttle_time_ms = 1i32;
114 }
115 m
116 }
117}