kacrab_protocol/generated/
alter_configs_request.rs

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

kacrab_protocol/generated/
alter_configs_request.rs
