kacrab_protocol/generated/
create_delegation_token_request.rs

1//! Generated from CreateDelegationTokenRequest.json - DO NOT EDIT
2#![allow(
3    missing_docs,
4    clippy::all,
5    clippy::pedantic,
6    clippy::nursery,
7    clippy::arithmetic_side_effects,
8    reason = "Generated protocol modules mirror Kafka's schema shape and intentionally trade \
9              hand-written lint style for reproducible wire-code output."
10)]
11use bytes::{Bytes, BytesMut};
12
13use crate::*;
14
15#[derive(Debug, Clone, PartialEq)]
16pub struct CreateDelegationTokenRequestData {
17    /// The principal type of the owner of the token. If it's null it defaults to the token request
18    /// principal.
19    pub owner_principal_type: Option<KafkaString>,
20    /// The principal name of the owner of the token. If it's null it defaults to the token request
21    /// principal.
22    pub owner_principal_name: Option<KafkaString>,
23    /// A list of those who are allowed to renew this token before it expires.
24    pub renewers: Vec<CreatableRenewers>,
25    /// The maximum lifetime of the token in milliseconds, or -1 to use the server side default.
26    pub max_lifetime_ms: i64,
27    pub _unknown_tagged_fields: Vec<RawTaggedField>,
28}
29impl Default for CreateDelegationTokenRequestData {
30    fn default() -> Self {
31        Self {
32            owner_principal_type: None,
33            owner_principal_name: None,
34            renewers: Vec::new(),
35            max_lifetime_ms: 0_i64,
36            _unknown_tagged_fields: Vec::new(),
37        }
38    }
39}
40impl CreateDelegationTokenRequestData {
41    pub fn with_owner_principal_type(mut self, value: Option<KafkaString>) -> Self {
42        self.owner_principal_type = value;
43        self
44    }
45    pub fn with_owner_principal_name(mut self, value: Option<KafkaString>) -> Self {
46        self.owner_principal_name = value;
47        self
48    }
49    pub fn with_renewers(mut self, value: Vec<CreatableRenewers>) -> Self {
50        self.renewers = value;
51        self
52    }
53    pub fn with_max_lifetime_ms(mut self, value: i64) -> Self {
54        self.max_lifetime_ms = value;
55        self
56    }
57    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
58        if version < 1 || version > 3 {
59            return Err(UnsupportedVersion::new(38, version).into());
60        }
61        let mut owner_principal_type = None;
62        let mut owner_principal_name = None;
63        let renewers;
64        let max_lifetime_ms;
65        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
66        if version >= 3 {
67            owner_principal_type = read_compact_nullable_string(buf)?;
68        }
69        if version >= 3 {
70            owner_principal_name = read_compact_nullable_string(buf)?;
71        }
72        if version >= 2 {
73            renewers = {
74                let len = read_compact_array_length(buf)?;
75                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
76                for _ in 0..len {
77                    arr.push(CreatableRenewers::read(buf, version)?);
78                }
79                arr
80            };
81        } else {
82            renewers = {
83                let len = read_array_length(buf)?;
84                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
85                for _ in 0..len {
86                    arr.push(CreatableRenewers::read(buf, version)?);
87                }
88                arr
89            };
90        }
91        max_lifetime_ms = read_i64(buf)?;
92        if version >= 2 {
93            let tagged_fields = read_tagged_fields(buf)?;
94            for field in &tagged_fields {
95                match field.tag {
96                    _ => {
97                        _unknown_tagged_fields.push(field.clone());
98                    },
99                }
100            }
101        }
102        Ok(Self {
103            owner_principal_type,
104            owner_principal_name,
105            renewers,
106            max_lifetime_ms,
107            _unknown_tagged_fields,
108        })
109    }
110    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
111        if version < 1 || version > 3 {
112            return Err(UnsupportedVersion::new(38, version).into());
113        }
114        if version >= 3 {
115            write_compact_nullable_string(buf, self.owner_principal_type.as_ref())?;
116        } else if self.owner_principal_type != None {
117            return Err(UnsupportedFieldVersion::new(38, "owner_principal_type", version).into());
118        }
119        if version >= 3 {
120            write_compact_nullable_string(buf, self.owner_principal_name.as_ref())?;
121        } else if self.owner_principal_name != None {
122            return Err(UnsupportedFieldVersion::new(38, "owner_principal_name", version).into());
123        }
124        if version >= 2 {
125            write_compact_array_length(buf, self.renewers.len() as i32);
126            for el in &self.renewers {
127                el.write(buf, version)?;
128            }
129        } else {
130            write_array_length(buf, self.renewers.len() as i32);
131            for el in &self.renewers {
132                el.write(buf, version)?;
133            }
134        }
135        write_i64(buf, self.max_lifetime_ms);
136        if version >= 2 {
137            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
138            all_tags.sort_by_key(|f| f.tag);
139            write_tagged_fields(buf, &all_tags)?;
140        }
141        Ok(())
142    }
143    pub fn encoded_len(&self, version: i16) -> Result<usize> {
144        if version < 1 || version > 3 {
145            return Err(UnsupportedVersion::new(38, version).into());
146        }
147        let mut len: usize = 0;
148        if version >= 3 {
149            len += compact_nullable_string_len(self.owner_principal_type.as_ref())?;
150        } else if self.owner_principal_type != None {
151            return Err(UnsupportedFieldVersion::new(38, "owner_principal_type", version).into());
152        }
153        if version >= 3 {
154            len += compact_nullable_string_len(self.owner_principal_name.as_ref())?;
155        } else if self.owner_principal_name != None {
156            return Err(UnsupportedFieldVersion::new(38, "owner_principal_name", version).into());
157        }
158        if version >= 2 {
159            len += compact_array_length_len(self.renewers.len() as i32);
160            for el in &self.renewers {
161                len += el.encoded_len(version)?;
162            }
163        } else {
164            len += array_length_len();
165            for el in &self.renewers {
166                len += el.encoded_len(version)?;
167            }
168        }
169        len += 8;
170        if version >= 2 {
171            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
172            all_tags.sort_by_key(|f| f.tag);
173            len += tagged_fields_len(&all_tags)?;
174        }
175        Ok(len)
176    }
177}
178#[derive(Debug, Clone, PartialEq)]
179pub struct CreatableRenewers {
180    /// The type of the Kafka principal.
181    pub principal_type: KafkaString,
182    /// The name of the Kafka principal.
183    pub principal_name: KafkaString,
184    pub _unknown_tagged_fields: Vec<RawTaggedField>,
185}
186impl Default for CreatableRenewers {
187    fn default() -> Self {
188        Self {
189            principal_type: KafkaString::default(),
190            principal_name: KafkaString::default(),
191            _unknown_tagged_fields: Vec::new(),
192        }
193    }
194}
195impl CreatableRenewers {
196    pub fn with_principal_type(mut self, value: KafkaString) -> Self {
197        self.principal_type = value;
198        self
199    }
200    pub fn with_principal_name(mut self, value: KafkaString) -> Self {
201        self.principal_name = value;
202        self
203    }
204    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
205        let principal_type;
206        let principal_name;
207        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
208        if version >= 2 {
209            principal_type = read_compact_string(buf)?;
210        } else {
211            principal_type = read_string(buf)?;
212        }
213        if version >= 2 {
214            principal_name = read_compact_string(buf)?;
215        } else {
216            principal_name = read_string(buf)?;
217        }
218        if version >= 2 {
219            let tagged_fields = read_tagged_fields(buf)?;
220            for field in &tagged_fields {
221                match field.tag {
222                    _ => {
223                        _unknown_tagged_fields.push(field.clone());
224                    },
225                }
226            }
227        }
228        Ok(Self {
229            principal_type,
230            principal_name,
231            _unknown_tagged_fields,
232        })
233    }
234    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
235        if version >= 2 {
236            write_compact_string(buf, &self.principal_type)?;
237        } else {
238            write_string(buf, &self.principal_type)?;
239        }
240        if version >= 2 {
241            write_compact_string(buf, &self.principal_name)?;
242        } else {
243            write_string(buf, &self.principal_name)?;
244        }
245        if version >= 2 {
246            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
247            all_tags.sort_by_key(|f| f.tag);
248            write_tagged_fields(buf, &all_tags)?;
249        }
250        Ok(())
251    }
252    pub fn encoded_len(&self, version: i16) -> Result<usize> {
253        let mut len: usize = 0;
254        if version >= 2 {
255            len += compact_string_len(&self.principal_type)?;
256        } else {
257            len += string_len(&self.principal_type)?;
258        }
259        if version >= 2 {
260            len += compact_string_len(&self.principal_name)?;
261        } else {
262            len += string_len(&self.principal_name)?;
263        }
264        if version >= 2 {
265            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
266            all_tags.sort_by_key(|f| f.tag);
267            len += tagged_fields_len(&all_tags)?;
268        }
269        Ok(len)
270    }
271}
kacrab_protocol/generated/create_delegation_token_request.rs

kacrab_protocol/generated/
create_delegation_token_request.rs
