kacrab_protocol/generated/
describe_user_scram_credentials_response.rs

1//! Generated from DescribeUserScramCredentialsResponse.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 DescribeUserScramCredentialsResponseData {
17    /// The duration in milliseconds for which the request was throttled due to a quota violation,
18    /// or zero if the request did not violate any quota.
19    pub throttle_time_ms: i32,
20    /// The message-level error code, 0 except for user authorization or infrastructure issues.
21    pub error_code: i16,
22    /// The message-level error message, if any.
23    pub error_message: Option<KafkaString>,
24    /// The results for descriptions, one per user.
25    pub results: Vec<DescribeUserScramCredentialsResult>,
26    pub _unknown_tagged_fields: Vec<RawTaggedField>,
27}
28impl Default for DescribeUserScramCredentialsResponseData {
29    fn default() -> Self {
30        Self {
31            throttle_time_ms: 0_i32,
32            error_code: 0_i16,
33            error_message: None,
34            results: Vec::new(),
35            _unknown_tagged_fields: Vec::new(),
36        }
37    }
38}
39impl DescribeUserScramCredentialsResponseData {
40    pub fn with_throttle_time_ms(mut self, value: i32) -> Self {
41        self.throttle_time_ms = value;
42        self
43    }
44    pub fn with_error_code(mut self, value: i16) -> Self {
45        self.error_code = value;
46        self
47    }
48    pub fn with_error_message(mut self, value: Option<KafkaString>) -> Self {
49        self.error_message = value;
50        self
51    }
52    pub fn with_results(mut self, value: Vec<DescribeUserScramCredentialsResult>) -> Self {
53        self.results = value;
54        self
55    }
56    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
57        if version < 0 || version > 0 {
58            return Err(UnsupportedVersion::new(50, version).into());
59        }
60        let throttle_time_ms;
61        let error_code;
62        let error_message;
63        let results;
64        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
65        throttle_time_ms = read_i32(buf)?;
66        error_code = read_i16(buf)?;
67        error_message = read_compact_nullable_string(buf)?;
68        results = {
69            let len = read_compact_array_length(buf)?;
70            let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
71            for _ in 0..len {
72                arr.push(DescribeUserScramCredentialsResult::read(buf, version)?);
73            }
74            arr
75        };
76        let tagged_fields = read_tagged_fields(buf)?;
77        for field in &tagged_fields {
78            match field.tag {
79                _ => {
80                    _unknown_tagged_fields.push(field.clone());
81                },
82            }
83        }
84        Ok(Self {
85            throttle_time_ms,
86            error_code,
87            error_message,
88            results,
89            _unknown_tagged_fields,
90        })
91    }
92    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
93        if version < 0 || version > 0 {
94            return Err(UnsupportedVersion::new(50, version).into());
95        }
96        write_i32(buf, self.throttle_time_ms);
97        write_i16(buf, self.error_code);
98        write_compact_nullable_string(buf, self.error_message.as_ref())?;
99        write_compact_array_length(buf, self.results.len() as i32);
100        for el in &self.results {
101            el.write(buf, version)?;
102        }
103        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
104        all_tags.sort_by_key(|f| f.tag);
105        write_tagged_fields(buf, &all_tags)?;
106        Ok(())
107    }
108    pub fn encoded_len(&self, version: i16) -> Result<usize> {
109        if version < 0 || version > 0 {
110            return Err(UnsupportedVersion::new(50, version).into());
111        }
112        let mut len: usize = 0;
113        len += 4;
114        len += 2;
115        len += compact_nullable_string_len(self.error_message.as_ref())?;
116        len += compact_array_length_len(self.results.len() as i32);
117        for el in &self.results {
118            len += el.encoded_len(version)?;
119        }
120        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
121        all_tags.sort_by_key(|f| f.tag);
122        len += tagged_fields_len(&all_tags)?;
123        Ok(len)
124    }
125}
126#[derive(Debug, Clone, PartialEq)]
127pub struct DescribeUserScramCredentialsResult {
128    /// The user name.
129    pub user: KafkaString,
130    /// The user-level error code.
131    pub error_code: i16,
132    /// The user-level error message, if any.
133    pub error_message: Option<KafkaString>,
134    /// The mechanism and related information associated with the user's SCRAM credentials.
135    pub credential_infos: Vec<CredentialInfo>,
136    pub _unknown_tagged_fields: Vec<RawTaggedField>,
137}
138impl Default for DescribeUserScramCredentialsResult {
139    fn default() -> Self {
140        Self {
141            user: KafkaString::default(),
142            error_code: 0_i16,
143            error_message: None,
144            credential_infos: Vec::new(),
145            _unknown_tagged_fields: Vec::new(),
146        }
147    }
148}
149impl DescribeUserScramCredentialsResult {
150    pub fn with_user(mut self, value: KafkaString) -> Self {
151        self.user = value;
152        self
153    }
154    pub fn with_error_code(mut self, value: i16) -> Self {
155        self.error_code = value;
156        self
157    }
158    pub fn with_error_message(mut self, value: Option<KafkaString>) -> Self {
159        self.error_message = value;
160        self
161    }
162    pub fn with_credential_infos(mut self, value: Vec<CredentialInfo>) -> Self {
163        self.credential_infos = value;
164        self
165    }
166    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
167        let user;
168        let error_code;
169        let error_message;
170        let credential_infos;
171        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
172        user = read_compact_string(buf)?;
173        error_code = read_i16(buf)?;
174        error_message = read_compact_nullable_string(buf)?;
175        credential_infos = {
176            let len = read_compact_array_length(buf)?;
177            let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
178            for _ in 0..len {
179                arr.push(CredentialInfo::read(buf, version)?);
180            }
181            arr
182        };
183        let tagged_fields = read_tagged_fields(buf)?;
184        for field in &tagged_fields {
185            match field.tag {
186                _ => {
187                    _unknown_tagged_fields.push(field.clone());
188                },
189            }
190        }
191        Ok(Self {
192            user,
193            error_code,
194            error_message,
195            credential_infos,
196            _unknown_tagged_fields,
197        })
198    }
199    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
200        write_compact_string(buf, &self.user)?;
201        write_i16(buf, self.error_code);
202        write_compact_nullable_string(buf, self.error_message.as_ref())?;
203        write_compact_array_length(buf, self.credential_infos.len() as i32);
204        for el in &self.credential_infos {
205            el.write(buf, version)?;
206        }
207        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
208        all_tags.sort_by_key(|f| f.tag);
209        write_tagged_fields(buf, &all_tags)?;
210        Ok(())
211    }
212    pub fn encoded_len(&self, version: i16) -> Result<usize> {
213        let mut len: usize = 0;
214        len += compact_string_len(&self.user)?;
215        len += 2;
216        len += compact_nullable_string_len(self.error_message.as_ref())?;
217        len += compact_array_length_len(self.credential_infos.len() as i32);
218        for el in &self.credential_infos {
219            len += el.encoded_len(version)?;
220        }
221        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
222        all_tags.sort_by_key(|f| f.tag);
223        len += tagged_fields_len(&all_tags)?;
224        Ok(len)
225    }
226}
227#[derive(Debug, Clone, PartialEq)]
228pub struct CredentialInfo {
229    /// The SCRAM mechanism.
230    pub mechanism: i8,
231    /// The number of iterations used in the SCRAM credential.
232    pub iterations: i32,
233    pub _unknown_tagged_fields: Vec<RawTaggedField>,
234}
235impl Default for CredentialInfo {
236    fn default() -> Self {
237        Self {
238            mechanism: 0_i8,
239            iterations: 0_i32,
240            _unknown_tagged_fields: Vec::new(),
241        }
242    }
243}
244impl CredentialInfo {
245    pub fn with_mechanism(mut self, value: i8) -> Self {
246        self.mechanism = value;
247        self
248    }
249    pub fn with_iterations(mut self, value: i32) -> Self {
250        self.iterations = value;
251        self
252    }
253    pub fn read(buf: &mut Bytes, _version: i16) -> Result<Self> {
254        let mechanism;
255        let iterations;
256        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
257        mechanism = read_i8(buf)?;
258        iterations = read_i32(buf)?;
259        let tagged_fields = read_tagged_fields(buf)?;
260        for field in &tagged_fields {
261            match field.tag {
262                _ => {
263                    _unknown_tagged_fields.push(field.clone());
264                },
265            }
266        }
267        Ok(Self {
268            mechanism,
269            iterations,
270            _unknown_tagged_fields,
271        })
272    }
273    pub fn write(&self, buf: &mut BytesMut, _version: i16) -> Result<()> {
274        write_i8(buf, self.mechanism);
275        write_i32(buf, self.iterations);
276        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
277        all_tags.sort_by_key(|f| f.tag);
278        write_tagged_fields(buf, &all_tags)?;
279        Ok(())
280    }
281    pub fn encoded_len(&self, _version: i16) -> Result<usize> {
282        let mut len: usize = 0;
283        len += 1;
284        len += 4;
285        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
286        all_tags.sort_by_key(|f| f.tag);
287        len += tagged_fields_len(&all_tags)?;
288        Ok(len)
289    }
290}
kacrab_protocol/generated/describe_user_scram_credentials_response.rs

kacrab_protocol/generated/
describe_user_scram_credentials_response.rs
