kacrab_protocol/generated/
describe_configs_request.rs

1//! Generated from DescribeConfigsRequest.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 DescribeConfigsRequestData {
17    /// The resources whose configurations we want to describe.
18    pub resources: Vec<DescribeConfigsResource>,
19    /// True if we should include all synonyms.
20    pub include_synonyms: bool,
21    /// True if we should include configuration documentation.
22    pub include_documentation: bool,
23    pub _unknown_tagged_fields: Vec<RawTaggedField>,
24}
25impl Default for DescribeConfigsRequestData {
26    fn default() -> Self {
27        Self {
28            resources: Vec::new(),
29            include_synonyms: false,
30            include_documentation: false,
31            _unknown_tagged_fields: Vec::new(),
32        }
33    }
34}
35impl DescribeConfigsRequestData {
36    pub fn with_resources(mut self, value: Vec<DescribeConfigsResource>) -> Self {
37        self.resources = value;
38        self
39    }
40    pub fn with_include_synonyms(mut self, value: bool) -> Self {
41        self.include_synonyms = value;
42        self
43    }
44    pub fn with_include_documentation(mut self, value: bool) -> Self {
45        self.include_documentation = value;
46        self
47    }
48    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
49        if version < 1 || version > 4 {
50            return Err(UnsupportedVersion::new(32, version).into());
51        }
52        let resources;
53        let include_synonyms;
54        let mut include_documentation = false;
55        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
56        if version >= 4 {
57            resources = {
58                let len = read_compact_array_length(buf)?;
59                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
60                for _ in 0..len {
61                    arr.push(DescribeConfigsResource::read(buf, version)?);
62                }
63                arr
64            };
65        } else {
66            resources = {
67                let len = read_array_length(buf)?;
68                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
69                for _ in 0..len {
70                    arr.push(DescribeConfigsResource::read(buf, version)?);
71                }
72                arr
73            };
74        }
75        include_synonyms = read_bool(buf)?;
76        if version >= 3 {
77            include_documentation = read_bool(buf)?;
78        }
79        if version >= 4 {
80            let tagged_fields = read_tagged_fields(buf)?;
81            for field in &tagged_fields {
82                match field.tag {
83                    _ => {
84                        _unknown_tagged_fields.push(field.clone());
85                    },
86                }
87            }
88        }
89        Ok(Self {
90            resources,
91            include_synonyms,
92            include_documentation,
93            _unknown_tagged_fields,
94        })
95    }
96    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
97        if version < 1 || version > 4 {
98            return Err(UnsupportedVersion::new(32, version).into());
99        }
100        if version >= 4 {
101            write_compact_array_length(buf, self.resources.len() as i32);
102            for el in &self.resources {
103                el.write(buf, version)?;
104            }
105        } else {
106            write_array_length(buf, self.resources.len() as i32);
107            for el in &self.resources {
108                el.write(buf, version)?;
109            }
110        }
111        write_bool(buf, self.include_synonyms);
112        if version >= 3 {
113            write_bool(buf, self.include_documentation);
114        } else if self.include_documentation != false {
115            return Err(UnsupportedFieldVersion::new(32, "include_documentation", version).into());
116        }
117        if version >= 4 {
118            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
119            all_tags.sort_by_key(|f| f.tag);
120            write_tagged_fields(buf, &all_tags)?;
121        }
122        Ok(())
123    }
124    pub fn encoded_len(&self, version: i16) -> Result<usize> {
125        if version < 1 || version > 4 {
126            return Err(UnsupportedVersion::new(32, version).into());
127        }
128        let mut len: usize = 0;
129        if version >= 4 {
130            len += compact_array_length_len(self.resources.len() as i32);
131            for el in &self.resources {
132                len += el.encoded_len(version)?;
133            }
134        } else {
135            len += array_length_len();
136            for el in &self.resources {
137                len += el.encoded_len(version)?;
138            }
139        }
140        len += 1;
141        if version >= 3 {
142            len += 1;
143        } else if self.include_documentation != false {
144            return Err(UnsupportedFieldVersion::new(32, "include_documentation", version).into());
145        }
146        if version >= 4 {
147            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
148            all_tags.sort_by_key(|f| f.tag);
149            len += tagged_fields_len(&all_tags)?;
150        }
151        Ok(len)
152    }
153}
154#[derive(Debug, Clone, PartialEq)]
155pub struct DescribeConfigsResource {
156    /// The resource type.
157    pub resource_type: i8,
158    /// The resource name.
159    pub resource_name: KafkaString,
160    /// The configuration keys to list, or null to list all configuration keys.
161    pub configuration_keys: Option<Vec<KafkaString>>,
162    pub _unknown_tagged_fields: Vec<RawTaggedField>,
163}
164impl Default for DescribeConfigsResource {
165    fn default() -> Self {
166        Self {
167            resource_type: 0_i8,
168            resource_name: KafkaString::default(),
169            configuration_keys: None,
170            _unknown_tagged_fields: Vec::new(),
171        }
172    }
173}
174impl DescribeConfigsResource {
175    pub fn with_resource_type(mut self, value: i8) -> Self {
176        self.resource_type = value;
177        self
178    }
179    pub fn with_resource_name(mut self, value: KafkaString) -> Self {
180        self.resource_name = value;
181        self
182    }
183    pub fn with_configuration_keys(mut self, value: Option<Vec<KafkaString>>) -> Self {
184        self.configuration_keys = value;
185        self
186    }
187    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
188        let resource_type;
189        let resource_name;
190        let configuration_keys;
191        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
192        resource_type = read_i8(buf)?;
193        if version >= 4 {
194            resource_name = read_compact_string(buf)?;
195        } else {
196            resource_name = read_string(buf)?;
197        }
198        if version >= 4 {
199            configuration_keys = {
200                let len = read_compact_array_length(buf)?;
201                if len < 0 {
202                    None
203                } else {
204                    let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
205                    for _ in 0..len {
206                        arr.push(read_compact_string(buf)?);
207                    }
208                    Some(arr)
209                }
210            };
211        } else {
212            configuration_keys = {
213                let len = read_array_length(buf)?;
214                if len < 0 {
215                    None
216                } else {
217                    let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
218                    for _ in 0..len {
219                        arr.push(read_string(buf)?);
220                    }
221                    Some(arr)
222                }
223            };
224        }
225        if version >= 4 {
226            let tagged_fields = read_tagged_fields(buf)?;
227            for field in &tagged_fields {
228                match field.tag {
229                    _ => {
230                        _unknown_tagged_fields.push(field.clone());
231                    },
232                }
233            }
234        }
235        Ok(Self {
236            resource_type,
237            resource_name,
238            configuration_keys,
239            _unknown_tagged_fields,
240        })
241    }
242    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
243        write_i8(buf, self.resource_type);
244        if version >= 4 {
245            write_compact_string(buf, &self.resource_name)?;
246        } else {
247            write_string(buf, &self.resource_name)?;
248        }
249        if version >= 4 {
250            match &self.configuration_keys {
251                None => {
252                    write_compact_array_length(buf, -1);
253                },
254                Some(arr) => {
255                    write_compact_array_length(buf, arr.len() as i32);
256                    for el in arr {
257                        write_compact_string(buf, el)?;
258                    }
259                },
260            }
261        } else {
262            match &self.configuration_keys {
263                None => {
264                    write_array_length(buf, -1);
265                },
266                Some(arr) => {
267                    write_array_length(buf, arr.len() as i32);
268                    for el in arr {
269                        write_string(buf, el)?;
270                    }
271                },
272            }
273        }
274        if version >= 4 {
275            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
276            all_tags.sort_by_key(|f| f.tag);
277            write_tagged_fields(buf, &all_tags)?;
278        }
279        Ok(())
280    }
281    pub fn encoded_len(&self, version: i16) -> Result<usize> {
282        let mut len: usize = 0;
283        len += 1;
284        if version >= 4 {
285            len += compact_string_len(&self.resource_name)?;
286        } else {
287            len += string_len(&self.resource_name)?;
288        }
289        if version >= 4 {
290            match &self.configuration_keys {
291                None => {
292                    len += compact_array_length_len(-1);
293                },
294                Some(arr) => {
295                    len += compact_array_length_len(arr.len() as i32);
296                    for el in arr {
297                        len += compact_string_len(el)?;
298                    }
299                },
300            }
301        } else {
302            match &self.configuration_keys {
303                None => {
304                    len += array_length_len();
305                },
306                Some(arr) => {
307                    len += array_length_len();
308                    for el in arr {
309                        len += string_len(el)?;
310                    }
311                },
312            }
313        }
314        if version >= 4 {
315            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
316            all_tags.sort_by_key(|f| f.tag);
317            len += tagged_fields_len(&all_tags)?;
318        }
319        Ok(len)
320    }
321}
kacrab_protocol/generated/describe_configs_request.rs

kacrab_protocol/generated/
describe_configs_request.rs
